00001
00002
00003
00004
00005
00006
00007 #define R__DICTIONARY_FILENAME geomdIgeomdIsrcdIG__Geom2
00008 #include "RConfig.h"
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010
00011 #define private public
00012 #define protected public
00013 #endif
00014
00015
00016 namespace std {} using namespace std;
00017 #include "G__Geom2.h"
00018
00019 #include "TClass.h"
00020 #include "TBuffer.h"
00021 #include "TMemberInspector.h"
00022 #include "TError.h"
00023
00024 #ifndef G__ROOT
00025 #define G__ROOT
00026 #endif
00027
00028 #include "RtypesImp.h"
00029 #include "TIsAProxy.h"
00030
00031
00032
00033 namespace ROOT {
00034 namespace Shadow {
00035 }
00036 }
00037
00038
00039 namespace ROOT {
00040 void TGeoPatternFinder_ShowMembers(void *obj, TMemberInspector &R__insp);
00041 static void *new_TGeoPatternFinder(void *p = 0);
00042 static void *newArray_TGeoPatternFinder(Long_t size, void *p);
00043 static void delete_TGeoPatternFinder(void *p);
00044 static void deleteArray_TGeoPatternFinder(void *p);
00045 static void destruct_TGeoPatternFinder(void *p);
00046
00047
00048 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternFinder*)
00049 {
00050 ::TGeoPatternFinder *ptr = 0;
00051 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternFinder >(0);
00052 static ::ROOT::TGenericClassInfo
00053 instance("TGeoPatternFinder", ::TGeoPatternFinder::Class_Version(), "include/TGeoPatternFinder.h", 34,
00054 typeid(::TGeoPatternFinder), DefineBehavior(ptr, ptr),
00055 &::TGeoPatternFinder::Dictionary, isa_proxy, 4,
00056 sizeof(::TGeoPatternFinder) );
00057 instance.SetNew(&new_TGeoPatternFinder);
00058 instance.SetNewArray(&newArray_TGeoPatternFinder);
00059 instance.SetDelete(&delete_TGeoPatternFinder);
00060 instance.SetDeleteArray(&deleteArray_TGeoPatternFinder);
00061 instance.SetDestructor(&destruct_TGeoPatternFinder);
00062 return &instance;
00063 }
00064 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternFinder*)
00065 {
00066 return GenerateInitInstanceLocal((::TGeoPatternFinder*)0);
00067 }
00068
00069 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternFinder*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00070 }
00071
00072 namespace ROOT {
00073 void TGeoPatternX_ShowMembers(void *obj, TMemberInspector &R__insp);
00074 static void *new_TGeoPatternX(void *p = 0);
00075 static void *newArray_TGeoPatternX(Long_t size, void *p);
00076 static void delete_TGeoPatternX(void *p);
00077 static void deleteArray_TGeoPatternX(void *p);
00078 static void destruct_TGeoPatternX(void *p);
00079
00080
00081 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternX*)
00082 {
00083 ::TGeoPatternX *ptr = 0;
00084 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternX >(0);
00085 static ::ROOT::TGenericClassInfo
00086 instance("TGeoPatternX", ::TGeoPatternX::Class_Version(), "include/TGeoPatternFinder.h", 95,
00087 typeid(::TGeoPatternX), DefineBehavior(ptr, ptr),
00088 &::TGeoPatternX::Dictionary, isa_proxy, 4,
00089 sizeof(::TGeoPatternX) );
00090 instance.SetNew(&new_TGeoPatternX);
00091 instance.SetNewArray(&newArray_TGeoPatternX);
00092 instance.SetDelete(&delete_TGeoPatternX);
00093 instance.SetDeleteArray(&deleteArray_TGeoPatternX);
00094 instance.SetDestructor(&destruct_TGeoPatternX);
00095 return &instance;
00096 }
00097 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternX*)
00098 {
00099 return GenerateInitInstanceLocal((::TGeoPatternX*)0);
00100 }
00101
00102 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternX*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00103 }
00104
00105 namespace ROOT {
00106 void TGeoPatternY_ShowMembers(void *obj, TMemberInspector &R__insp);
00107 static void *new_TGeoPatternY(void *p = 0);
00108 static void *newArray_TGeoPatternY(Long_t size, void *p);
00109 static void delete_TGeoPatternY(void *p);
00110 static void deleteArray_TGeoPatternY(void *p);
00111 static void destruct_TGeoPatternY(void *p);
00112
00113
00114 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternY*)
00115 {
00116 ::TGeoPatternY *ptr = 0;
00117 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternY >(0);
00118 static ::ROOT::TGenericClassInfo
00119 instance("TGeoPatternY", ::TGeoPatternY::Class_Version(), "include/TGeoPatternFinder.h", 125,
00120 typeid(::TGeoPatternY), DefineBehavior(ptr, ptr),
00121 &::TGeoPatternY::Dictionary, isa_proxy, 4,
00122 sizeof(::TGeoPatternY) );
00123 instance.SetNew(&new_TGeoPatternY);
00124 instance.SetNewArray(&newArray_TGeoPatternY);
00125 instance.SetDelete(&delete_TGeoPatternY);
00126 instance.SetDeleteArray(&deleteArray_TGeoPatternY);
00127 instance.SetDestructor(&destruct_TGeoPatternY);
00128 return &instance;
00129 }
00130 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternY*)
00131 {
00132 return GenerateInitInstanceLocal((::TGeoPatternY*)0);
00133 }
00134
00135 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternY*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00136 }
00137
00138 namespace ROOT {
00139 void TGeoPatternZ_ShowMembers(void *obj, TMemberInspector &R__insp);
00140 static void *new_TGeoPatternZ(void *p = 0);
00141 static void *newArray_TGeoPatternZ(Long_t size, void *p);
00142 static void delete_TGeoPatternZ(void *p);
00143 static void deleteArray_TGeoPatternZ(void *p);
00144 static void destruct_TGeoPatternZ(void *p);
00145
00146
00147 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternZ*)
00148 {
00149 ::TGeoPatternZ *ptr = 0;
00150 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternZ >(0);
00151 static ::ROOT::TGenericClassInfo
00152 instance("TGeoPatternZ", ::TGeoPatternZ::Class_Version(), "include/TGeoPatternFinder.h", 154,
00153 typeid(::TGeoPatternZ), DefineBehavior(ptr, ptr),
00154 &::TGeoPatternZ::Dictionary, isa_proxy, 4,
00155 sizeof(::TGeoPatternZ) );
00156 instance.SetNew(&new_TGeoPatternZ);
00157 instance.SetNewArray(&newArray_TGeoPatternZ);
00158 instance.SetDelete(&delete_TGeoPatternZ);
00159 instance.SetDeleteArray(&deleteArray_TGeoPatternZ);
00160 instance.SetDestructor(&destruct_TGeoPatternZ);
00161 return &instance;
00162 }
00163 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternZ*)
00164 {
00165 return GenerateInitInstanceLocal((::TGeoPatternZ*)0);
00166 }
00167
00168 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternZ*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00169 }
00170
00171 namespace ROOT {
00172 void TGeoPatternParaX_ShowMembers(void *obj, TMemberInspector &R__insp);
00173 static void *new_TGeoPatternParaX(void *p = 0);
00174 static void *newArray_TGeoPatternParaX(Long_t size, void *p);
00175 static void delete_TGeoPatternParaX(void *p);
00176 static void deleteArray_TGeoPatternParaX(void *p);
00177 static void destruct_TGeoPatternParaX(void *p);
00178
00179
00180 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternParaX*)
00181 {
00182 ::TGeoPatternParaX *ptr = 0;
00183 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternParaX >(0);
00184 static ::ROOT::TGenericClassInfo
00185 instance("TGeoPatternParaX", ::TGeoPatternParaX::Class_Version(), "include/TGeoPatternFinder.h", 183,
00186 typeid(::TGeoPatternParaX), DefineBehavior(ptr, ptr),
00187 &::TGeoPatternParaX::Dictionary, isa_proxy, 4,
00188 sizeof(::TGeoPatternParaX) );
00189 instance.SetNew(&new_TGeoPatternParaX);
00190 instance.SetNewArray(&newArray_TGeoPatternParaX);
00191 instance.SetDelete(&delete_TGeoPatternParaX);
00192 instance.SetDeleteArray(&deleteArray_TGeoPatternParaX);
00193 instance.SetDestructor(&destruct_TGeoPatternParaX);
00194 return &instance;
00195 }
00196 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternParaX*)
00197 {
00198 return GenerateInitInstanceLocal((::TGeoPatternParaX*)0);
00199 }
00200
00201 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternParaX*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00202 }
00203
00204 namespace ROOT {
00205 void TGeoPatternParaY_ShowMembers(void *obj, TMemberInspector &R__insp);
00206 static void *new_TGeoPatternParaY(void *p = 0);
00207 static void *newArray_TGeoPatternParaY(Long_t size, void *p);
00208 static void delete_TGeoPatternParaY(void *p);
00209 static void deleteArray_TGeoPatternParaY(void *p);
00210 static void destruct_TGeoPatternParaY(void *p);
00211
00212
00213 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternParaY*)
00214 {
00215 ::TGeoPatternParaY *ptr = 0;
00216 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternParaY >(0);
00217 static ::ROOT::TGenericClassInfo
00218 instance("TGeoPatternParaY", ::TGeoPatternParaY::Class_Version(), "include/TGeoPatternFinder.h", 212,
00219 typeid(::TGeoPatternParaY), DefineBehavior(ptr, ptr),
00220 &::TGeoPatternParaY::Dictionary, isa_proxy, 4,
00221 sizeof(::TGeoPatternParaY) );
00222 instance.SetNew(&new_TGeoPatternParaY);
00223 instance.SetNewArray(&newArray_TGeoPatternParaY);
00224 instance.SetDelete(&delete_TGeoPatternParaY);
00225 instance.SetDeleteArray(&deleteArray_TGeoPatternParaY);
00226 instance.SetDestructor(&destruct_TGeoPatternParaY);
00227 return &instance;
00228 }
00229 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternParaY*)
00230 {
00231 return GenerateInitInstanceLocal((::TGeoPatternParaY*)0);
00232 }
00233
00234 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternParaY*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00235 }
00236
00237 namespace ROOT {
00238 void TGeoPatternParaZ_ShowMembers(void *obj, TMemberInspector &R__insp);
00239 static void *new_TGeoPatternParaZ(void *p = 0);
00240 static void *newArray_TGeoPatternParaZ(Long_t size, void *p);
00241 static void delete_TGeoPatternParaZ(void *p);
00242 static void deleteArray_TGeoPatternParaZ(void *p);
00243 static void destruct_TGeoPatternParaZ(void *p);
00244
00245
00246 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternParaZ*)
00247 {
00248 ::TGeoPatternParaZ *ptr = 0;
00249 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternParaZ >(0);
00250 static ::ROOT::TGenericClassInfo
00251 instance("TGeoPatternParaZ", ::TGeoPatternParaZ::Class_Version(), "include/TGeoPatternFinder.h", 244,
00252 typeid(::TGeoPatternParaZ), DefineBehavior(ptr, ptr),
00253 &::TGeoPatternParaZ::Dictionary, isa_proxy, 4,
00254 sizeof(::TGeoPatternParaZ) );
00255 instance.SetNew(&new_TGeoPatternParaZ);
00256 instance.SetNewArray(&newArray_TGeoPatternParaZ);
00257 instance.SetDelete(&delete_TGeoPatternParaZ);
00258 instance.SetDeleteArray(&deleteArray_TGeoPatternParaZ);
00259 instance.SetDestructor(&destruct_TGeoPatternParaZ);
00260 return &instance;
00261 }
00262 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternParaZ*)
00263 {
00264 return GenerateInitInstanceLocal((::TGeoPatternParaZ*)0);
00265 }
00266
00267 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternParaZ*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00268 }
00269
00270 namespace ROOT {
00271 void TGeoPatternTrapZ_ShowMembers(void *obj, TMemberInspector &R__insp);
00272 static void *new_TGeoPatternTrapZ(void *p = 0);
00273 static void *newArray_TGeoPatternTrapZ(Long_t size, void *p);
00274 static void delete_TGeoPatternTrapZ(void *p);
00275 static void deleteArray_TGeoPatternTrapZ(void *p);
00276 static void destruct_TGeoPatternTrapZ(void *p);
00277
00278
00279 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternTrapZ*)
00280 {
00281 ::TGeoPatternTrapZ *ptr = 0;
00282 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternTrapZ >(0);
00283 static ::ROOT::TGenericClassInfo
00284 instance("TGeoPatternTrapZ", ::TGeoPatternTrapZ::Class_Version(), "include/TGeoPatternFinder.h", 277,
00285 typeid(::TGeoPatternTrapZ), DefineBehavior(ptr, ptr),
00286 &::TGeoPatternTrapZ::Dictionary, isa_proxy, 4,
00287 sizeof(::TGeoPatternTrapZ) );
00288 instance.SetNew(&new_TGeoPatternTrapZ);
00289 instance.SetNewArray(&newArray_TGeoPatternTrapZ);
00290 instance.SetDelete(&delete_TGeoPatternTrapZ);
00291 instance.SetDeleteArray(&deleteArray_TGeoPatternTrapZ);
00292 instance.SetDestructor(&destruct_TGeoPatternTrapZ);
00293 return &instance;
00294 }
00295 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternTrapZ*)
00296 {
00297 return GenerateInitInstanceLocal((::TGeoPatternTrapZ*)0);
00298 }
00299
00300 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternTrapZ*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00301 }
00302
00303 namespace ROOT {
00304 void TGeoPatternCylR_ShowMembers(void *obj, TMemberInspector &R__insp);
00305 static void *new_TGeoPatternCylR(void *p = 0);
00306 static void *newArray_TGeoPatternCylR(Long_t size, void *p);
00307 static void delete_TGeoPatternCylR(void *p);
00308 static void deleteArray_TGeoPatternCylR(void *p);
00309 static void destruct_TGeoPatternCylR(void *p);
00310
00311
00312 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternCylR*)
00313 {
00314 ::TGeoPatternCylR *ptr = 0;
00315 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternCylR >(0);
00316 static ::ROOT::TGenericClassInfo
00317 instance("TGeoPatternCylR", ::TGeoPatternCylR::Class_Version(), "include/TGeoPatternFinder.h", 313,
00318 typeid(::TGeoPatternCylR), DefineBehavior(ptr, ptr),
00319 &::TGeoPatternCylR::Dictionary, isa_proxy, 4,
00320 sizeof(::TGeoPatternCylR) );
00321 instance.SetNew(&new_TGeoPatternCylR);
00322 instance.SetNewArray(&newArray_TGeoPatternCylR);
00323 instance.SetDelete(&delete_TGeoPatternCylR);
00324 instance.SetDeleteArray(&deleteArray_TGeoPatternCylR);
00325 instance.SetDestructor(&destruct_TGeoPatternCylR);
00326 return &instance;
00327 }
00328 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternCylR*)
00329 {
00330 return GenerateInitInstanceLocal((::TGeoPatternCylR*)0);
00331 }
00332
00333 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternCylR*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00334 }
00335
00336 namespace ROOT {
00337 void TGeoPatternCylPhi_ShowMembers(void *obj, TMemberInspector &R__insp);
00338 static void *new_TGeoPatternCylPhi(void *p = 0);
00339 static void *newArray_TGeoPatternCylPhi(Long_t size, void *p);
00340 static void delete_TGeoPatternCylPhi(void *p);
00341 static void deleteArray_TGeoPatternCylPhi(void *p);
00342 static void destruct_TGeoPatternCylPhi(void *p);
00343
00344
00345 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternCylPhi*)
00346 {
00347 ::TGeoPatternCylPhi *ptr = 0;
00348 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternCylPhi >(0);
00349 static ::ROOT::TGenericClassInfo
00350 instance("TGeoPatternCylPhi", ::TGeoPatternCylPhi::Class_Version(), "include/TGeoPatternFinder.h", 341,
00351 typeid(::TGeoPatternCylPhi), DefineBehavior(ptr, ptr),
00352 &::TGeoPatternCylPhi::Dictionary, isa_proxy, 4,
00353 sizeof(::TGeoPatternCylPhi) );
00354 instance.SetNew(&new_TGeoPatternCylPhi);
00355 instance.SetNewArray(&newArray_TGeoPatternCylPhi);
00356 instance.SetDelete(&delete_TGeoPatternCylPhi);
00357 instance.SetDeleteArray(&deleteArray_TGeoPatternCylPhi);
00358 instance.SetDestructor(&destruct_TGeoPatternCylPhi);
00359 return &instance;
00360 }
00361 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternCylPhi*)
00362 {
00363 return GenerateInitInstanceLocal((::TGeoPatternCylPhi*)0);
00364 }
00365
00366 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternCylPhi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00367 }
00368
00369 namespace ROOT {
00370 void TGeoPatternSphR_ShowMembers(void *obj, TMemberInspector &R__insp);
00371 static void *new_TGeoPatternSphR(void *p = 0);
00372 static void *newArray_TGeoPatternSphR(Long_t size, void *p);
00373 static void delete_TGeoPatternSphR(void *p);
00374 static void deleteArray_TGeoPatternSphR(void *p);
00375 static void destruct_TGeoPatternSphR(void *p);
00376
00377
00378 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternSphR*)
00379 {
00380 ::TGeoPatternSphR *ptr = 0;
00381 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternSphR >(0);
00382 static ::ROOT::TGenericClassInfo
00383 instance("TGeoPatternSphR", ::TGeoPatternSphR::Class_Version(), "include/TGeoPatternFinder.h", 380,
00384 typeid(::TGeoPatternSphR), DefineBehavior(ptr, ptr),
00385 &::TGeoPatternSphR::Dictionary, isa_proxy, 4,
00386 sizeof(::TGeoPatternSphR) );
00387 instance.SetNew(&new_TGeoPatternSphR);
00388 instance.SetNewArray(&newArray_TGeoPatternSphR);
00389 instance.SetDelete(&delete_TGeoPatternSphR);
00390 instance.SetDeleteArray(&deleteArray_TGeoPatternSphR);
00391 instance.SetDestructor(&destruct_TGeoPatternSphR);
00392 return &instance;
00393 }
00394 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternSphR*)
00395 {
00396 return GenerateInitInstanceLocal((::TGeoPatternSphR*)0);
00397 }
00398
00399 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternSphR*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00400 }
00401
00402 namespace ROOT {
00403 void TGeoPatternSphTheta_ShowMembers(void *obj, TMemberInspector &R__insp);
00404 static void *new_TGeoPatternSphTheta(void *p = 0);
00405 static void *newArray_TGeoPatternSphTheta(Long_t size, void *p);
00406 static void delete_TGeoPatternSphTheta(void *p);
00407 static void deleteArray_TGeoPatternSphTheta(void *p);
00408 static void destruct_TGeoPatternSphTheta(void *p);
00409
00410
00411 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternSphTheta*)
00412 {
00413 ::TGeoPatternSphTheta *ptr = 0;
00414 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternSphTheta >(0);
00415 static ::ROOT::TGenericClassInfo
00416 instance("TGeoPatternSphTheta", ::TGeoPatternSphTheta::Class_Version(), "include/TGeoPatternFinder.h", 407,
00417 typeid(::TGeoPatternSphTheta), DefineBehavior(ptr, ptr),
00418 &::TGeoPatternSphTheta::Dictionary, isa_proxy, 4,
00419 sizeof(::TGeoPatternSphTheta) );
00420 instance.SetNew(&new_TGeoPatternSphTheta);
00421 instance.SetNewArray(&newArray_TGeoPatternSphTheta);
00422 instance.SetDelete(&delete_TGeoPatternSphTheta);
00423 instance.SetDeleteArray(&deleteArray_TGeoPatternSphTheta);
00424 instance.SetDestructor(&destruct_TGeoPatternSphTheta);
00425 return &instance;
00426 }
00427 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternSphTheta*)
00428 {
00429 return GenerateInitInstanceLocal((::TGeoPatternSphTheta*)0);
00430 }
00431
00432 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternSphTheta*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00433 }
00434
00435 namespace ROOT {
00436 void TGeoPatternSphPhi_ShowMembers(void *obj, TMemberInspector &R__insp);
00437 static void *new_TGeoPatternSphPhi(void *p = 0);
00438 static void *newArray_TGeoPatternSphPhi(Long_t size, void *p);
00439 static void delete_TGeoPatternSphPhi(void *p);
00440 static void deleteArray_TGeoPatternSphPhi(void *p);
00441 static void destruct_TGeoPatternSphPhi(void *p);
00442
00443
00444 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternSphPhi*)
00445 {
00446 ::TGeoPatternSphPhi *ptr = 0;
00447 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternSphPhi >(0);
00448 static ::ROOT::TGenericClassInfo
00449 instance("TGeoPatternSphPhi", ::TGeoPatternSphPhi::Class_Version(), "include/TGeoPatternFinder.h", 434,
00450 typeid(::TGeoPatternSphPhi), DefineBehavior(ptr, ptr),
00451 &::TGeoPatternSphPhi::Dictionary, isa_proxy, 4,
00452 sizeof(::TGeoPatternSphPhi) );
00453 instance.SetNew(&new_TGeoPatternSphPhi);
00454 instance.SetNewArray(&newArray_TGeoPatternSphPhi);
00455 instance.SetDelete(&delete_TGeoPatternSphPhi);
00456 instance.SetDeleteArray(&deleteArray_TGeoPatternSphPhi);
00457 instance.SetDestructor(&destruct_TGeoPatternSphPhi);
00458 return &instance;
00459 }
00460 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternSphPhi*)
00461 {
00462 return GenerateInitInstanceLocal((::TGeoPatternSphPhi*)0);
00463 }
00464
00465 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternSphPhi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00466 }
00467
00468 namespace ROOT {
00469 void TGeoPatternHoneycomb_ShowMembers(void *obj, TMemberInspector &R__insp);
00470 static void *new_TGeoPatternHoneycomb(void *p = 0);
00471 static void *newArray_TGeoPatternHoneycomb(Long_t size, void *p);
00472 static void delete_TGeoPatternHoneycomb(void *p);
00473 static void deleteArray_TGeoPatternHoneycomb(void *p);
00474 static void destruct_TGeoPatternHoneycomb(void *p);
00475
00476
00477 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPatternHoneycomb*)
00478 {
00479 ::TGeoPatternHoneycomb *ptr = 0;
00480 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPatternHoneycomb >(0);
00481 static ::ROOT::TGenericClassInfo
00482 instance("TGeoPatternHoneycomb", ::TGeoPatternHoneycomb::Class_Version(), "include/TGeoPatternFinder.h", 461,
00483 typeid(::TGeoPatternHoneycomb), DefineBehavior(ptr, ptr),
00484 &::TGeoPatternHoneycomb::Dictionary, isa_proxy, 4,
00485 sizeof(::TGeoPatternHoneycomb) );
00486 instance.SetNew(&new_TGeoPatternHoneycomb);
00487 instance.SetNewArray(&newArray_TGeoPatternHoneycomb);
00488 instance.SetDelete(&delete_TGeoPatternHoneycomb);
00489 instance.SetDeleteArray(&deleteArray_TGeoPatternHoneycomb);
00490 instance.SetDestructor(&destruct_TGeoPatternHoneycomb);
00491 return &instance;
00492 }
00493 TGenericClassInfo *GenerateInitInstance(const ::TGeoPatternHoneycomb*)
00494 {
00495 return GenerateInitInstanceLocal((::TGeoPatternHoneycomb*)0);
00496 }
00497
00498 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPatternHoneycomb*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00499 }
00500
00501 namespace ROOT {
00502 void TGeoCacheState_ShowMembers(void *obj, TMemberInspector &R__insp);
00503 static void *new_TGeoCacheState(void *p = 0);
00504 static void *newArray_TGeoCacheState(Long_t size, void *p);
00505 static void delete_TGeoCacheState(void *p);
00506 static void deleteArray_TGeoCacheState(void *p);
00507 static void destruct_TGeoCacheState(void *p);
00508
00509
00510 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoCacheState*)
00511 {
00512 ::TGeoCacheState *ptr = 0;
00513 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoCacheState >(0);
00514 static ::ROOT::TGenericClassInfo
00515 instance("TGeoCacheState", ::TGeoCacheState::Class_Version(), "include/TGeoCache.h", 31,
00516 typeid(::TGeoCacheState), DefineBehavior(ptr, ptr),
00517 &::TGeoCacheState::Dictionary, isa_proxy, 4,
00518 sizeof(::TGeoCacheState) );
00519 instance.SetNew(&new_TGeoCacheState);
00520 instance.SetNewArray(&newArray_TGeoCacheState);
00521 instance.SetDelete(&delete_TGeoCacheState);
00522 instance.SetDeleteArray(&deleteArray_TGeoCacheState);
00523 instance.SetDestructor(&destruct_TGeoCacheState);
00524 return &instance;
00525 }
00526 TGenericClassInfo *GenerateInitInstance(const ::TGeoCacheState*)
00527 {
00528 return GenerateInitInstanceLocal((::TGeoCacheState*)0);
00529 }
00530
00531 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoCacheState*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00532 }
00533
00534 namespace ROOT {
00535 void TGeoNodeCache_ShowMembers(void *obj, TMemberInspector &R__insp);
00536 static void *new_TGeoNodeCache(void *p = 0);
00537 static void *newArray_TGeoNodeCache(Long_t size, void *p);
00538 static void delete_TGeoNodeCache(void *p);
00539 static void deleteArray_TGeoNodeCache(void *p);
00540 static void destruct_TGeoNodeCache(void *p);
00541
00542
00543 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoNodeCache*)
00544 {
00545 ::TGeoNodeCache *ptr = 0;
00546 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoNodeCache >(0);
00547 static ::ROOT::TGenericClassInfo
00548 instance("TGeoNodeCache", ::TGeoNodeCache::Class_Version(), "include/TGeoCache.h", 66,
00549 typeid(::TGeoNodeCache), DefineBehavior(ptr, ptr),
00550 &::TGeoNodeCache::Dictionary, isa_proxy, 4,
00551 sizeof(::TGeoNodeCache) );
00552 instance.SetNew(&new_TGeoNodeCache);
00553 instance.SetNewArray(&newArray_TGeoNodeCache);
00554 instance.SetDelete(&delete_TGeoNodeCache);
00555 instance.SetDeleteArray(&deleteArray_TGeoNodeCache);
00556 instance.SetDestructor(&destruct_TGeoNodeCache);
00557 return &instance;
00558 }
00559 TGenericClassInfo *GenerateInitInstance(const ::TGeoNodeCache*)
00560 {
00561 return GenerateInitInstanceLocal((::TGeoNodeCache*)0);
00562 }
00563
00564 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoNodeCache*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00565 }
00566
00567 namespace ROOT {
00568 void TVirtualMagField_ShowMembers(void *obj, TMemberInspector &R__insp);
00569 static void delete_TVirtualMagField(void *p);
00570 static void deleteArray_TVirtualMagField(void *p);
00571 static void destruct_TVirtualMagField(void *p);
00572
00573
00574 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVirtualMagField*)
00575 {
00576 ::TVirtualMagField *ptr = 0;
00577 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TVirtualMagField >(0);
00578 static ::ROOT::TGenericClassInfo
00579 instance("TVirtualMagField", ::TVirtualMagField::Class_Version(), "include/TVirtualMagField.h", 26,
00580 typeid(::TVirtualMagField), DefineBehavior(ptr, ptr),
00581 &::TVirtualMagField::Dictionary, isa_proxy, 4,
00582 sizeof(::TVirtualMagField) );
00583 instance.SetDelete(&delete_TVirtualMagField);
00584 instance.SetDeleteArray(&deleteArray_TVirtualMagField);
00585 instance.SetDestructor(&destruct_TVirtualMagField);
00586 return &instance;
00587 }
00588 TGenericClassInfo *GenerateInitInstance(const ::TVirtualMagField*)
00589 {
00590 return GenerateInitInstanceLocal((::TVirtualMagField*)0);
00591 }
00592
00593 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualMagField*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00594 }
00595
00596 namespace ROOT {
00597 void TGeoUniformMagField_ShowMembers(void *obj, TMemberInspector &R__insp);
00598 static void *new_TGeoUniformMagField(void *p = 0);
00599 static void *newArray_TGeoUniformMagField(Long_t size, void *p);
00600 static void delete_TGeoUniformMagField(void *p);
00601 static void deleteArray_TGeoUniformMagField(void *p);
00602 static void destruct_TGeoUniformMagField(void *p);
00603
00604
00605 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoUniformMagField*)
00606 {
00607 ::TGeoUniformMagField *ptr = 0;
00608 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoUniformMagField >(0);
00609 static ::ROOT::TGenericClassInfo
00610 instance("TGeoUniformMagField", ::TGeoUniformMagField::Class_Version(), "include/TVirtualMagField.h", 45,
00611 typeid(::TGeoUniformMagField), DefineBehavior(ptr, ptr),
00612 &::TGeoUniformMagField::Dictionary, isa_proxy, 4,
00613 sizeof(::TGeoUniformMagField) );
00614 instance.SetNew(&new_TGeoUniformMagField);
00615 instance.SetNewArray(&newArray_TGeoUniformMagField);
00616 instance.SetDelete(&delete_TGeoUniformMagField);
00617 instance.SetDeleteArray(&deleteArray_TGeoUniformMagField);
00618 instance.SetDestructor(&destruct_TGeoUniformMagField);
00619 return &instance;
00620 }
00621 TGenericClassInfo *GenerateInitInstance(const ::TGeoUniformMagField*)
00622 {
00623 return GenerateInitInstanceLocal((::TGeoUniformMagField*)0);
00624 }
00625
00626 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoUniformMagField*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00627 }
00628
00629 namespace ROOT {
00630 void TGeoGlobalMagField_ShowMembers(void *obj, TMemberInspector &R__insp);
00631 static void *new_TGeoGlobalMagField(void *p = 0);
00632 static void *newArray_TGeoGlobalMagField(Long_t size, void *p);
00633 static void delete_TGeoGlobalMagField(void *p);
00634 static void deleteArray_TGeoGlobalMagField(void *p);
00635 static void destruct_TGeoGlobalMagField(void *p);
00636 static void streamer_TGeoGlobalMagField(TBuffer &buf, void *obj);
00637
00638
00639 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoGlobalMagField*)
00640 {
00641 ::TGeoGlobalMagField *ptr = 0;
00642 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoGlobalMagField >(0);
00643 static ::ROOT::TGenericClassInfo
00644 instance("TGeoGlobalMagField", ::TGeoGlobalMagField::Class_Version(), "include/TGeoGlobalMagField.h", 31,
00645 typeid(::TGeoGlobalMagField), DefineBehavior(ptr, ptr),
00646 &::TGeoGlobalMagField::Dictionary, isa_proxy, 0,
00647 sizeof(::TGeoGlobalMagField) );
00648 instance.SetNew(&new_TGeoGlobalMagField);
00649 instance.SetNewArray(&newArray_TGeoGlobalMagField);
00650 instance.SetDelete(&delete_TGeoGlobalMagField);
00651 instance.SetDeleteArray(&deleteArray_TGeoGlobalMagField);
00652 instance.SetDestructor(&destruct_TGeoGlobalMagField);
00653 instance.SetStreamerFunc(&streamer_TGeoGlobalMagField);
00654 return &instance;
00655 }
00656 TGenericClassInfo *GenerateInitInstance(const ::TGeoGlobalMagField*)
00657 {
00658 return GenerateInitInstanceLocal((::TGeoGlobalMagField*)0);
00659 }
00660
00661 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoGlobalMagField*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00662 }
00663
00664
00665 TClass *TGeoPatternFinder::fgIsA = 0;
00666
00667
00668 const char *TGeoPatternFinder::Class_Name()
00669 {
00670 return "TGeoPatternFinder";
00671 }
00672
00673
00674 const char *TGeoPatternFinder::ImplFileName()
00675 {
00676 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternFinder*)0x0)->GetImplFileName();
00677 }
00678
00679
00680 int TGeoPatternFinder::ImplFileLine()
00681 {
00682 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternFinder*)0x0)->GetImplFileLine();
00683 }
00684
00685
00686 void TGeoPatternFinder::Dictionary()
00687 {
00688 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternFinder*)0x0)->GetClass();
00689 }
00690
00691
00692 TClass *TGeoPatternFinder::Class()
00693 {
00694 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternFinder*)0x0)->GetClass();
00695 return fgIsA;
00696 }
00697
00698
00699 TClass *TGeoPatternX::fgIsA = 0;
00700
00701
00702 const char *TGeoPatternX::Class_Name()
00703 {
00704 return "TGeoPatternX";
00705 }
00706
00707
00708 const char *TGeoPatternX::ImplFileName()
00709 {
00710 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternX*)0x0)->GetImplFileName();
00711 }
00712
00713
00714 int TGeoPatternX::ImplFileLine()
00715 {
00716 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternX*)0x0)->GetImplFileLine();
00717 }
00718
00719
00720 void TGeoPatternX::Dictionary()
00721 {
00722 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternX*)0x0)->GetClass();
00723 }
00724
00725
00726 TClass *TGeoPatternX::Class()
00727 {
00728 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternX*)0x0)->GetClass();
00729 return fgIsA;
00730 }
00731
00732
00733 TClass *TGeoPatternY::fgIsA = 0;
00734
00735
00736 const char *TGeoPatternY::Class_Name()
00737 {
00738 return "TGeoPatternY";
00739 }
00740
00741
00742 const char *TGeoPatternY::ImplFileName()
00743 {
00744 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternY*)0x0)->GetImplFileName();
00745 }
00746
00747
00748 int TGeoPatternY::ImplFileLine()
00749 {
00750 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternY*)0x0)->GetImplFileLine();
00751 }
00752
00753
00754 void TGeoPatternY::Dictionary()
00755 {
00756 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternY*)0x0)->GetClass();
00757 }
00758
00759
00760 TClass *TGeoPatternY::Class()
00761 {
00762 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternY*)0x0)->GetClass();
00763 return fgIsA;
00764 }
00765
00766
00767 TClass *TGeoPatternZ::fgIsA = 0;
00768
00769
00770 const char *TGeoPatternZ::Class_Name()
00771 {
00772 return "TGeoPatternZ";
00773 }
00774
00775
00776 const char *TGeoPatternZ::ImplFileName()
00777 {
00778 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternZ*)0x0)->GetImplFileName();
00779 }
00780
00781
00782 int TGeoPatternZ::ImplFileLine()
00783 {
00784 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternZ*)0x0)->GetImplFileLine();
00785 }
00786
00787
00788 void TGeoPatternZ::Dictionary()
00789 {
00790 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternZ*)0x0)->GetClass();
00791 }
00792
00793
00794 TClass *TGeoPatternZ::Class()
00795 {
00796 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternZ*)0x0)->GetClass();
00797 return fgIsA;
00798 }
00799
00800
00801 TClass *TGeoPatternParaX::fgIsA = 0;
00802
00803
00804 const char *TGeoPatternParaX::Class_Name()
00805 {
00806 return "TGeoPatternParaX";
00807 }
00808
00809
00810 const char *TGeoPatternParaX::ImplFileName()
00811 {
00812 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaX*)0x0)->GetImplFileName();
00813 }
00814
00815
00816 int TGeoPatternParaX::ImplFileLine()
00817 {
00818 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaX*)0x0)->GetImplFileLine();
00819 }
00820
00821
00822 void TGeoPatternParaX::Dictionary()
00823 {
00824 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaX*)0x0)->GetClass();
00825 }
00826
00827
00828 TClass *TGeoPatternParaX::Class()
00829 {
00830 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaX*)0x0)->GetClass();
00831 return fgIsA;
00832 }
00833
00834
00835 TClass *TGeoPatternParaY::fgIsA = 0;
00836
00837
00838 const char *TGeoPatternParaY::Class_Name()
00839 {
00840 return "TGeoPatternParaY";
00841 }
00842
00843
00844 const char *TGeoPatternParaY::ImplFileName()
00845 {
00846 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaY*)0x0)->GetImplFileName();
00847 }
00848
00849
00850 int TGeoPatternParaY::ImplFileLine()
00851 {
00852 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaY*)0x0)->GetImplFileLine();
00853 }
00854
00855
00856 void TGeoPatternParaY::Dictionary()
00857 {
00858 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaY*)0x0)->GetClass();
00859 }
00860
00861
00862 TClass *TGeoPatternParaY::Class()
00863 {
00864 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaY*)0x0)->GetClass();
00865 return fgIsA;
00866 }
00867
00868
00869 TClass *TGeoPatternParaZ::fgIsA = 0;
00870
00871
00872 const char *TGeoPatternParaZ::Class_Name()
00873 {
00874 return "TGeoPatternParaZ";
00875 }
00876
00877
00878 const char *TGeoPatternParaZ::ImplFileName()
00879 {
00880 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaZ*)0x0)->GetImplFileName();
00881 }
00882
00883
00884 int TGeoPatternParaZ::ImplFileLine()
00885 {
00886 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaZ*)0x0)->GetImplFileLine();
00887 }
00888
00889
00890 void TGeoPatternParaZ::Dictionary()
00891 {
00892 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaZ*)0x0)->GetClass();
00893 }
00894
00895
00896 TClass *TGeoPatternParaZ::Class()
00897 {
00898 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternParaZ*)0x0)->GetClass();
00899 return fgIsA;
00900 }
00901
00902
00903 TClass *TGeoPatternTrapZ::fgIsA = 0;
00904
00905
00906 const char *TGeoPatternTrapZ::Class_Name()
00907 {
00908 return "TGeoPatternTrapZ";
00909 }
00910
00911
00912 const char *TGeoPatternTrapZ::ImplFileName()
00913 {
00914 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternTrapZ*)0x0)->GetImplFileName();
00915 }
00916
00917
00918 int TGeoPatternTrapZ::ImplFileLine()
00919 {
00920 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternTrapZ*)0x0)->GetImplFileLine();
00921 }
00922
00923
00924 void TGeoPatternTrapZ::Dictionary()
00925 {
00926 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternTrapZ*)0x0)->GetClass();
00927 }
00928
00929
00930 TClass *TGeoPatternTrapZ::Class()
00931 {
00932 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternTrapZ*)0x0)->GetClass();
00933 return fgIsA;
00934 }
00935
00936
00937 TClass *TGeoPatternCylR::fgIsA = 0;
00938
00939
00940 const char *TGeoPatternCylR::Class_Name()
00941 {
00942 return "TGeoPatternCylR";
00943 }
00944
00945
00946 const char *TGeoPatternCylR::ImplFileName()
00947 {
00948 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternCylR*)0x0)->GetImplFileName();
00949 }
00950
00951
00952 int TGeoPatternCylR::ImplFileLine()
00953 {
00954 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternCylR*)0x0)->GetImplFileLine();
00955 }
00956
00957
00958 void TGeoPatternCylR::Dictionary()
00959 {
00960 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternCylR*)0x0)->GetClass();
00961 }
00962
00963
00964 TClass *TGeoPatternCylR::Class()
00965 {
00966 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternCylR*)0x0)->GetClass();
00967 return fgIsA;
00968 }
00969
00970
00971 TClass *TGeoPatternCylPhi::fgIsA = 0;
00972
00973
00974 const char *TGeoPatternCylPhi::Class_Name()
00975 {
00976 return "TGeoPatternCylPhi";
00977 }
00978
00979
00980 const char *TGeoPatternCylPhi::ImplFileName()
00981 {
00982 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternCylPhi*)0x0)->GetImplFileName();
00983 }
00984
00985
00986 int TGeoPatternCylPhi::ImplFileLine()
00987 {
00988 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternCylPhi*)0x0)->GetImplFileLine();
00989 }
00990
00991
00992 void TGeoPatternCylPhi::Dictionary()
00993 {
00994 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternCylPhi*)0x0)->GetClass();
00995 }
00996
00997
00998 TClass *TGeoPatternCylPhi::Class()
00999 {
01000 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternCylPhi*)0x0)->GetClass();
01001 return fgIsA;
01002 }
01003
01004
01005 TClass *TGeoPatternSphR::fgIsA = 0;
01006
01007
01008 const char *TGeoPatternSphR::Class_Name()
01009 {
01010 return "TGeoPatternSphR";
01011 }
01012
01013
01014 const char *TGeoPatternSphR::ImplFileName()
01015 {
01016 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphR*)0x0)->GetImplFileName();
01017 }
01018
01019
01020 int TGeoPatternSphR::ImplFileLine()
01021 {
01022 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphR*)0x0)->GetImplFileLine();
01023 }
01024
01025
01026 void TGeoPatternSphR::Dictionary()
01027 {
01028 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphR*)0x0)->GetClass();
01029 }
01030
01031
01032 TClass *TGeoPatternSphR::Class()
01033 {
01034 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphR*)0x0)->GetClass();
01035 return fgIsA;
01036 }
01037
01038
01039 TClass *TGeoPatternSphTheta::fgIsA = 0;
01040
01041
01042 const char *TGeoPatternSphTheta::Class_Name()
01043 {
01044 return "TGeoPatternSphTheta";
01045 }
01046
01047
01048 const char *TGeoPatternSphTheta::ImplFileName()
01049 {
01050 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphTheta*)0x0)->GetImplFileName();
01051 }
01052
01053
01054 int TGeoPatternSphTheta::ImplFileLine()
01055 {
01056 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphTheta*)0x0)->GetImplFileLine();
01057 }
01058
01059
01060 void TGeoPatternSphTheta::Dictionary()
01061 {
01062 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphTheta*)0x0)->GetClass();
01063 }
01064
01065
01066 TClass *TGeoPatternSphTheta::Class()
01067 {
01068 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphTheta*)0x0)->GetClass();
01069 return fgIsA;
01070 }
01071
01072
01073 TClass *TGeoPatternSphPhi::fgIsA = 0;
01074
01075
01076 const char *TGeoPatternSphPhi::Class_Name()
01077 {
01078 return "TGeoPatternSphPhi";
01079 }
01080
01081
01082 const char *TGeoPatternSphPhi::ImplFileName()
01083 {
01084 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphPhi*)0x0)->GetImplFileName();
01085 }
01086
01087
01088 int TGeoPatternSphPhi::ImplFileLine()
01089 {
01090 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphPhi*)0x0)->GetImplFileLine();
01091 }
01092
01093
01094 void TGeoPatternSphPhi::Dictionary()
01095 {
01096 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphPhi*)0x0)->GetClass();
01097 }
01098
01099
01100 TClass *TGeoPatternSphPhi::Class()
01101 {
01102 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternSphPhi*)0x0)->GetClass();
01103 return fgIsA;
01104 }
01105
01106
01107 TClass *TGeoPatternHoneycomb::fgIsA = 0;
01108
01109
01110 const char *TGeoPatternHoneycomb::Class_Name()
01111 {
01112 return "TGeoPatternHoneycomb";
01113 }
01114
01115
01116 const char *TGeoPatternHoneycomb::ImplFileName()
01117 {
01118 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternHoneycomb*)0x0)->GetImplFileName();
01119 }
01120
01121
01122 int TGeoPatternHoneycomb::ImplFileLine()
01123 {
01124 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternHoneycomb*)0x0)->GetImplFileLine();
01125 }
01126
01127
01128 void TGeoPatternHoneycomb::Dictionary()
01129 {
01130 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternHoneycomb*)0x0)->GetClass();
01131 }
01132
01133
01134 TClass *TGeoPatternHoneycomb::Class()
01135 {
01136 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPatternHoneycomb*)0x0)->GetClass();
01137 return fgIsA;
01138 }
01139
01140
01141 TClass *TGeoCacheState::fgIsA = 0;
01142
01143
01144 const char *TGeoCacheState::Class_Name()
01145 {
01146 return "TGeoCacheState";
01147 }
01148
01149
01150 const char *TGeoCacheState::ImplFileName()
01151 {
01152 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoCacheState*)0x0)->GetImplFileName();
01153 }
01154
01155
01156 int TGeoCacheState::ImplFileLine()
01157 {
01158 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoCacheState*)0x0)->GetImplFileLine();
01159 }
01160
01161
01162 void TGeoCacheState::Dictionary()
01163 {
01164 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoCacheState*)0x0)->GetClass();
01165 }
01166
01167
01168 TClass *TGeoCacheState::Class()
01169 {
01170 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoCacheState*)0x0)->GetClass();
01171 return fgIsA;
01172 }
01173
01174
01175 TClass *TGeoNodeCache::fgIsA = 0;
01176
01177
01178 const char *TGeoNodeCache::Class_Name()
01179 {
01180 return "TGeoNodeCache";
01181 }
01182
01183
01184 const char *TGeoNodeCache::ImplFileName()
01185 {
01186 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoNodeCache*)0x0)->GetImplFileName();
01187 }
01188
01189
01190 int TGeoNodeCache::ImplFileLine()
01191 {
01192 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoNodeCache*)0x0)->GetImplFileLine();
01193 }
01194
01195
01196 void TGeoNodeCache::Dictionary()
01197 {
01198 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoNodeCache*)0x0)->GetClass();
01199 }
01200
01201
01202 TClass *TGeoNodeCache::Class()
01203 {
01204 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoNodeCache*)0x0)->GetClass();
01205 return fgIsA;
01206 }
01207
01208
01209 TClass *TVirtualMagField::fgIsA = 0;
01210
01211
01212 const char *TVirtualMagField::Class_Name()
01213 {
01214 return "TVirtualMagField";
01215 }
01216
01217
01218 const char *TVirtualMagField::ImplFileName()
01219 {
01220 return ::ROOT::GenerateInitInstanceLocal((const ::TVirtualMagField*)0x0)->GetImplFileName();
01221 }
01222
01223
01224 int TVirtualMagField::ImplFileLine()
01225 {
01226 return ::ROOT::GenerateInitInstanceLocal((const ::TVirtualMagField*)0x0)->GetImplFileLine();
01227 }
01228
01229
01230 void TVirtualMagField::Dictionary()
01231 {
01232 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVirtualMagField*)0x0)->GetClass();
01233 }
01234
01235
01236 TClass *TVirtualMagField::Class()
01237 {
01238 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVirtualMagField*)0x0)->GetClass();
01239 return fgIsA;
01240 }
01241
01242
01243 TClass *TGeoUniformMagField::fgIsA = 0;
01244
01245
01246 const char *TGeoUniformMagField::Class_Name()
01247 {
01248 return "TGeoUniformMagField";
01249 }
01250
01251
01252 const char *TGeoUniformMagField::ImplFileName()
01253 {
01254 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoUniformMagField*)0x0)->GetImplFileName();
01255 }
01256
01257
01258 int TGeoUniformMagField::ImplFileLine()
01259 {
01260 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoUniformMagField*)0x0)->GetImplFileLine();
01261 }
01262
01263
01264 void TGeoUniformMagField::Dictionary()
01265 {
01266 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoUniformMagField*)0x0)->GetClass();
01267 }
01268
01269
01270 TClass *TGeoUniformMagField::Class()
01271 {
01272 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoUniformMagField*)0x0)->GetClass();
01273 return fgIsA;
01274 }
01275
01276
01277 TClass *TGeoGlobalMagField::fgIsA = 0;
01278
01279
01280 const char *TGeoGlobalMagField::Class_Name()
01281 {
01282 return "TGeoGlobalMagField";
01283 }
01284
01285
01286 const char *TGeoGlobalMagField::ImplFileName()
01287 {
01288 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoGlobalMagField*)0x0)->GetImplFileName();
01289 }
01290
01291
01292 int TGeoGlobalMagField::ImplFileLine()
01293 {
01294 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoGlobalMagField*)0x0)->GetImplFileLine();
01295 }
01296
01297
01298 void TGeoGlobalMagField::Dictionary()
01299 {
01300 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoGlobalMagField*)0x0)->GetClass();
01301 }
01302
01303
01304 TClass *TGeoGlobalMagField::Class()
01305 {
01306 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoGlobalMagField*)0x0)->GetClass();
01307 return fgIsA;
01308 }
01309
01310
01311 void TGeoPatternFinder::Streamer(TBuffer &R__b)
01312 {
01313
01314
01315 if (R__b.IsReading()) {
01316 R__b.ReadClassBuffer(TGeoPatternFinder::Class(),this);
01317 } else {
01318 R__b.WriteClassBuffer(TGeoPatternFinder::Class(),this);
01319 }
01320 }
01321
01322
01323 void TGeoPatternFinder::ShowMembers(TMemberInspector &R__insp)
01324 {
01325
01326 TClass *R__cl = ::TGeoPatternFinder::IsA();
01327 if (R__cl || R__insp.IsA()) { }
01328 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStep", &fStep);
01329 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStart", &fStart);
01330 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnd", &fEnd);
01331 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrent", &fCurrent);
01332 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdivisions", &fNdivisions);
01333 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDivIndex", &fDivIndex);
01334 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &fMatrix);
01335 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolume", &fVolume);
01336 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNextIndex", &fNextIndex);
01337 TObject::ShowMembers(R__insp);
01338 }
01339
01340 namespace ROOT {
01341
01342 static void *new_TGeoPatternFinder(void *p) {
01343 return p ? new(p) ::TGeoPatternFinder : new ::TGeoPatternFinder;
01344 }
01345 static void *newArray_TGeoPatternFinder(Long_t nElements, void *p) {
01346 return p ? new(p) ::TGeoPatternFinder[nElements] : new ::TGeoPatternFinder[nElements];
01347 }
01348
01349 static void delete_TGeoPatternFinder(void *p) {
01350 delete ((::TGeoPatternFinder*)p);
01351 }
01352 static void deleteArray_TGeoPatternFinder(void *p) {
01353 delete [] ((::TGeoPatternFinder*)p);
01354 }
01355 static void destruct_TGeoPatternFinder(void *p) {
01356 typedef ::TGeoPatternFinder current_t;
01357 ((current_t*)p)->~current_t();
01358 }
01359 }
01360
01361
01362 void TGeoPatternX::Streamer(TBuffer &R__b)
01363 {
01364
01365
01366 if (R__b.IsReading()) {
01367 R__b.ReadClassBuffer(TGeoPatternX::Class(),this);
01368 } else {
01369 R__b.WriteClassBuffer(TGeoPatternX::Class(),this);
01370 }
01371 }
01372
01373
01374 void TGeoPatternX::ShowMembers(TMemberInspector &R__insp)
01375 {
01376
01377 TClass *R__cl = ::TGeoPatternX::IsA();
01378 if (R__cl || R__insp.IsA()) { }
01379 TGeoPatternFinder::ShowMembers(R__insp);
01380 }
01381
01382 namespace ROOT {
01383
01384 static void *new_TGeoPatternX(void *p) {
01385 return p ? new(p) ::TGeoPatternX : new ::TGeoPatternX;
01386 }
01387 static void *newArray_TGeoPatternX(Long_t nElements, void *p) {
01388 return p ? new(p) ::TGeoPatternX[nElements] : new ::TGeoPatternX[nElements];
01389 }
01390
01391 static void delete_TGeoPatternX(void *p) {
01392 delete ((::TGeoPatternX*)p);
01393 }
01394 static void deleteArray_TGeoPatternX(void *p) {
01395 delete [] ((::TGeoPatternX*)p);
01396 }
01397 static void destruct_TGeoPatternX(void *p) {
01398 typedef ::TGeoPatternX current_t;
01399 ((current_t*)p)->~current_t();
01400 }
01401 }
01402
01403
01404 void TGeoPatternY::Streamer(TBuffer &R__b)
01405 {
01406
01407
01408 if (R__b.IsReading()) {
01409 R__b.ReadClassBuffer(TGeoPatternY::Class(),this);
01410 } else {
01411 R__b.WriteClassBuffer(TGeoPatternY::Class(),this);
01412 }
01413 }
01414
01415
01416 void TGeoPatternY::ShowMembers(TMemberInspector &R__insp)
01417 {
01418
01419 TClass *R__cl = ::TGeoPatternY::IsA();
01420 if (R__cl || R__insp.IsA()) { }
01421 TGeoPatternFinder::ShowMembers(R__insp);
01422 }
01423
01424 namespace ROOT {
01425
01426 static void *new_TGeoPatternY(void *p) {
01427 return p ? new(p) ::TGeoPatternY : new ::TGeoPatternY;
01428 }
01429 static void *newArray_TGeoPatternY(Long_t nElements, void *p) {
01430 return p ? new(p) ::TGeoPatternY[nElements] : new ::TGeoPatternY[nElements];
01431 }
01432
01433 static void delete_TGeoPatternY(void *p) {
01434 delete ((::TGeoPatternY*)p);
01435 }
01436 static void deleteArray_TGeoPatternY(void *p) {
01437 delete [] ((::TGeoPatternY*)p);
01438 }
01439 static void destruct_TGeoPatternY(void *p) {
01440 typedef ::TGeoPatternY current_t;
01441 ((current_t*)p)->~current_t();
01442 }
01443 }
01444
01445
01446 void TGeoPatternZ::Streamer(TBuffer &R__b)
01447 {
01448
01449
01450 if (R__b.IsReading()) {
01451 R__b.ReadClassBuffer(TGeoPatternZ::Class(),this);
01452 } else {
01453 R__b.WriteClassBuffer(TGeoPatternZ::Class(),this);
01454 }
01455 }
01456
01457
01458 void TGeoPatternZ::ShowMembers(TMemberInspector &R__insp)
01459 {
01460
01461 TClass *R__cl = ::TGeoPatternZ::IsA();
01462 if (R__cl || R__insp.IsA()) { }
01463 TGeoPatternFinder::ShowMembers(R__insp);
01464 }
01465
01466 namespace ROOT {
01467
01468 static void *new_TGeoPatternZ(void *p) {
01469 return p ? new(p) ::TGeoPatternZ : new ::TGeoPatternZ;
01470 }
01471 static void *newArray_TGeoPatternZ(Long_t nElements, void *p) {
01472 return p ? new(p) ::TGeoPatternZ[nElements] : new ::TGeoPatternZ[nElements];
01473 }
01474
01475 static void delete_TGeoPatternZ(void *p) {
01476 delete ((::TGeoPatternZ*)p);
01477 }
01478 static void deleteArray_TGeoPatternZ(void *p) {
01479 delete [] ((::TGeoPatternZ*)p);
01480 }
01481 static void destruct_TGeoPatternZ(void *p) {
01482 typedef ::TGeoPatternZ current_t;
01483 ((current_t*)p)->~current_t();
01484 }
01485 }
01486
01487
01488 void TGeoPatternParaX::Streamer(TBuffer &R__b)
01489 {
01490
01491
01492 if (R__b.IsReading()) {
01493 R__b.ReadClassBuffer(TGeoPatternParaX::Class(),this);
01494 } else {
01495 R__b.WriteClassBuffer(TGeoPatternParaX::Class(),this);
01496 }
01497 }
01498
01499
01500 void TGeoPatternParaX::ShowMembers(TMemberInspector &R__insp)
01501 {
01502
01503 TClass *R__cl = ::TGeoPatternParaX::IsA();
01504 if (R__cl || R__insp.IsA()) { }
01505 TGeoPatternFinder::ShowMembers(R__insp);
01506 }
01507
01508 namespace ROOT {
01509
01510 static void *new_TGeoPatternParaX(void *p) {
01511 return p ? new(p) ::TGeoPatternParaX : new ::TGeoPatternParaX;
01512 }
01513 static void *newArray_TGeoPatternParaX(Long_t nElements, void *p) {
01514 return p ? new(p) ::TGeoPatternParaX[nElements] : new ::TGeoPatternParaX[nElements];
01515 }
01516
01517 static void delete_TGeoPatternParaX(void *p) {
01518 delete ((::TGeoPatternParaX*)p);
01519 }
01520 static void deleteArray_TGeoPatternParaX(void *p) {
01521 delete [] ((::TGeoPatternParaX*)p);
01522 }
01523 static void destruct_TGeoPatternParaX(void *p) {
01524 typedef ::TGeoPatternParaX current_t;
01525 ((current_t*)p)->~current_t();
01526 }
01527 }
01528
01529
01530 void TGeoPatternParaY::Streamer(TBuffer &R__b)
01531 {
01532
01533
01534 if (R__b.IsReading()) {
01535 R__b.ReadClassBuffer(TGeoPatternParaY::Class(),this);
01536 } else {
01537 R__b.WriteClassBuffer(TGeoPatternParaY::Class(),this);
01538 }
01539 }
01540
01541
01542 void TGeoPatternParaY::ShowMembers(TMemberInspector &R__insp)
01543 {
01544
01545 TClass *R__cl = ::TGeoPatternParaY::IsA();
01546 if (R__cl || R__insp.IsA()) { }
01547 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTxy", &fTxy);
01548 TGeoPatternFinder::ShowMembers(R__insp);
01549 }
01550
01551 namespace ROOT {
01552
01553 static void *new_TGeoPatternParaY(void *p) {
01554 return p ? new(p) ::TGeoPatternParaY : new ::TGeoPatternParaY;
01555 }
01556 static void *newArray_TGeoPatternParaY(Long_t nElements, void *p) {
01557 return p ? new(p) ::TGeoPatternParaY[nElements] : new ::TGeoPatternParaY[nElements];
01558 }
01559
01560 static void delete_TGeoPatternParaY(void *p) {
01561 delete ((::TGeoPatternParaY*)p);
01562 }
01563 static void deleteArray_TGeoPatternParaY(void *p) {
01564 delete [] ((::TGeoPatternParaY*)p);
01565 }
01566 static void destruct_TGeoPatternParaY(void *p) {
01567 typedef ::TGeoPatternParaY current_t;
01568 ((current_t*)p)->~current_t();
01569 }
01570 }
01571
01572
01573 void TGeoPatternParaZ::Streamer(TBuffer &R__b)
01574 {
01575
01576
01577 if (R__b.IsReading()) {
01578 R__b.ReadClassBuffer(TGeoPatternParaZ::Class(),this);
01579 } else {
01580 R__b.WriteClassBuffer(TGeoPatternParaZ::Class(),this);
01581 }
01582 }
01583
01584
01585 void TGeoPatternParaZ::ShowMembers(TMemberInspector &R__insp)
01586 {
01587
01588 TClass *R__cl = ::TGeoPatternParaZ::IsA();
01589 if (R__cl || R__insp.IsA()) { }
01590 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTxz", &fTxz);
01591 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTyz", &fTyz);
01592 TGeoPatternFinder::ShowMembers(R__insp);
01593 }
01594
01595 namespace ROOT {
01596
01597 static void *new_TGeoPatternParaZ(void *p) {
01598 return p ? new(p) ::TGeoPatternParaZ : new ::TGeoPatternParaZ;
01599 }
01600 static void *newArray_TGeoPatternParaZ(Long_t nElements, void *p) {
01601 return p ? new(p) ::TGeoPatternParaZ[nElements] : new ::TGeoPatternParaZ[nElements];
01602 }
01603
01604 static void delete_TGeoPatternParaZ(void *p) {
01605 delete ((::TGeoPatternParaZ*)p);
01606 }
01607 static void deleteArray_TGeoPatternParaZ(void *p) {
01608 delete [] ((::TGeoPatternParaZ*)p);
01609 }
01610 static void destruct_TGeoPatternParaZ(void *p) {
01611 typedef ::TGeoPatternParaZ current_t;
01612 ((current_t*)p)->~current_t();
01613 }
01614 }
01615
01616
01617 void TGeoPatternTrapZ::Streamer(TBuffer &R__b)
01618 {
01619
01620
01621 if (R__b.IsReading()) {
01622 R__b.ReadClassBuffer(TGeoPatternTrapZ::Class(),this);
01623 } else {
01624 R__b.WriteClassBuffer(TGeoPatternTrapZ::Class(),this);
01625 }
01626 }
01627
01628
01629 void TGeoPatternTrapZ::ShowMembers(TMemberInspector &R__insp)
01630 {
01631
01632 TClass *R__cl = ::TGeoPatternTrapZ::IsA();
01633 if (R__cl || R__insp.IsA()) { }
01634 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTxz", &fTxz);
01635 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTyz", &fTyz);
01636 TGeoPatternFinder::ShowMembers(R__insp);
01637 }
01638
01639 namespace ROOT {
01640
01641 static void *new_TGeoPatternTrapZ(void *p) {
01642 return p ? new(p) ::TGeoPatternTrapZ : new ::TGeoPatternTrapZ;
01643 }
01644 static void *newArray_TGeoPatternTrapZ(Long_t nElements, void *p) {
01645 return p ? new(p) ::TGeoPatternTrapZ[nElements] : new ::TGeoPatternTrapZ[nElements];
01646 }
01647
01648 static void delete_TGeoPatternTrapZ(void *p) {
01649 delete ((::TGeoPatternTrapZ*)p);
01650 }
01651 static void deleteArray_TGeoPatternTrapZ(void *p) {
01652 delete [] ((::TGeoPatternTrapZ*)p);
01653 }
01654 static void destruct_TGeoPatternTrapZ(void *p) {
01655 typedef ::TGeoPatternTrapZ current_t;
01656 ((current_t*)p)->~current_t();
01657 }
01658 }
01659
01660
01661 void TGeoPatternCylR::Streamer(TBuffer &R__b)
01662 {
01663
01664
01665 if (R__b.IsReading()) {
01666 R__b.ReadClassBuffer(TGeoPatternCylR::Class(),this);
01667 } else {
01668 R__b.WriteClassBuffer(TGeoPatternCylR::Class(),this);
01669 }
01670 }
01671
01672
01673 void TGeoPatternCylR::ShowMembers(TMemberInspector &R__insp)
01674 {
01675
01676 TClass *R__cl = ::TGeoPatternCylR::IsA();
01677 if (R__cl || R__insp.IsA()) { }
01678 TGeoPatternFinder::ShowMembers(R__insp);
01679 }
01680
01681 namespace ROOT {
01682
01683 static void *new_TGeoPatternCylR(void *p) {
01684 return p ? new(p) ::TGeoPatternCylR : new ::TGeoPatternCylR;
01685 }
01686 static void *newArray_TGeoPatternCylR(Long_t nElements, void *p) {
01687 return p ? new(p) ::TGeoPatternCylR[nElements] : new ::TGeoPatternCylR[nElements];
01688 }
01689
01690 static void delete_TGeoPatternCylR(void *p) {
01691 delete ((::TGeoPatternCylR*)p);
01692 }
01693 static void deleteArray_TGeoPatternCylR(void *p) {
01694 delete [] ((::TGeoPatternCylR*)p);
01695 }
01696 static void destruct_TGeoPatternCylR(void *p) {
01697 typedef ::TGeoPatternCylR current_t;
01698 ((current_t*)p)->~current_t();
01699 }
01700 }
01701
01702
01703 void TGeoPatternCylPhi::Streamer(TBuffer &R__b)
01704 {
01705
01706
01707 if (R__b.IsReading()) {
01708 R__b.ReadClassBuffer(TGeoPatternCylPhi::Class(),this);
01709 } else {
01710 R__b.WriteClassBuffer(TGeoPatternCylPhi::Class(),this);
01711 }
01712 }
01713
01714
01715 void TGeoPatternCylPhi::ShowMembers(TMemberInspector &R__insp)
01716 {
01717
01718 TClass *R__cl = ::TGeoPatternCylPhi::IsA();
01719 if (R__cl || R__insp.IsA()) { }
01720 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSinCos", &fSinCos);
01721 TGeoPatternFinder::ShowMembers(R__insp);
01722 }
01723
01724 namespace ROOT {
01725
01726 static void *new_TGeoPatternCylPhi(void *p) {
01727 return p ? new(p) ::TGeoPatternCylPhi : new ::TGeoPatternCylPhi;
01728 }
01729 static void *newArray_TGeoPatternCylPhi(Long_t nElements, void *p) {
01730 return p ? new(p) ::TGeoPatternCylPhi[nElements] : new ::TGeoPatternCylPhi[nElements];
01731 }
01732
01733 static void delete_TGeoPatternCylPhi(void *p) {
01734 delete ((::TGeoPatternCylPhi*)p);
01735 }
01736 static void deleteArray_TGeoPatternCylPhi(void *p) {
01737 delete [] ((::TGeoPatternCylPhi*)p);
01738 }
01739 static void destruct_TGeoPatternCylPhi(void *p) {
01740 typedef ::TGeoPatternCylPhi current_t;
01741 ((current_t*)p)->~current_t();
01742 }
01743 }
01744
01745
01746 void TGeoPatternSphR::Streamer(TBuffer &R__b)
01747 {
01748
01749
01750 if (R__b.IsReading()) {
01751 R__b.ReadClassBuffer(TGeoPatternSphR::Class(),this);
01752 } else {
01753 R__b.WriteClassBuffer(TGeoPatternSphR::Class(),this);
01754 }
01755 }
01756
01757
01758 void TGeoPatternSphR::ShowMembers(TMemberInspector &R__insp)
01759 {
01760
01761 TClass *R__cl = ::TGeoPatternSphR::IsA();
01762 if (R__cl || R__insp.IsA()) { }
01763 TGeoPatternFinder::ShowMembers(R__insp);
01764 }
01765
01766 namespace ROOT {
01767
01768 static void *new_TGeoPatternSphR(void *p) {
01769 return p ? new(p) ::TGeoPatternSphR : new ::TGeoPatternSphR;
01770 }
01771 static void *newArray_TGeoPatternSphR(Long_t nElements, void *p) {
01772 return p ? new(p) ::TGeoPatternSphR[nElements] : new ::TGeoPatternSphR[nElements];
01773 }
01774
01775 static void delete_TGeoPatternSphR(void *p) {
01776 delete ((::TGeoPatternSphR*)p);
01777 }
01778 static void deleteArray_TGeoPatternSphR(void *p) {
01779 delete [] ((::TGeoPatternSphR*)p);
01780 }
01781 static void destruct_TGeoPatternSphR(void *p) {
01782 typedef ::TGeoPatternSphR current_t;
01783 ((current_t*)p)->~current_t();
01784 }
01785 }
01786
01787
01788 void TGeoPatternSphTheta::Streamer(TBuffer &R__b)
01789 {
01790
01791
01792 if (R__b.IsReading()) {
01793 R__b.ReadClassBuffer(TGeoPatternSphTheta::Class(),this);
01794 } else {
01795 R__b.WriteClassBuffer(TGeoPatternSphTheta::Class(),this);
01796 }
01797 }
01798
01799
01800 void TGeoPatternSphTheta::ShowMembers(TMemberInspector &R__insp)
01801 {
01802
01803 TClass *R__cl = ::TGeoPatternSphTheta::IsA();
01804 if (R__cl || R__insp.IsA()) { }
01805 TGeoPatternFinder::ShowMembers(R__insp);
01806 }
01807
01808 namespace ROOT {
01809
01810 static void *new_TGeoPatternSphTheta(void *p) {
01811 return p ? new(p) ::TGeoPatternSphTheta : new ::TGeoPatternSphTheta;
01812 }
01813 static void *newArray_TGeoPatternSphTheta(Long_t nElements, void *p) {
01814 return p ? new(p) ::TGeoPatternSphTheta[nElements] : new ::TGeoPatternSphTheta[nElements];
01815 }
01816
01817 static void delete_TGeoPatternSphTheta(void *p) {
01818 delete ((::TGeoPatternSphTheta*)p);
01819 }
01820 static void deleteArray_TGeoPatternSphTheta(void *p) {
01821 delete [] ((::TGeoPatternSphTheta*)p);
01822 }
01823 static void destruct_TGeoPatternSphTheta(void *p) {
01824 typedef ::TGeoPatternSphTheta current_t;
01825 ((current_t*)p)->~current_t();
01826 }
01827 }
01828
01829
01830 void TGeoPatternSphPhi::Streamer(TBuffer &R__b)
01831 {
01832
01833
01834 if (R__b.IsReading()) {
01835 R__b.ReadClassBuffer(TGeoPatternSphPhi::Class(),this);
01836 } else {
01837 R__b.WriteClassBuffer(TGeoPatternSphPhi::Class(),this);
01838 }
01839 }
01840
01841
01842 void TGeoPatternSphPhi::ShowMembers(TMemberInspector &R__insp)
01843 {
01844
01845 TClass *R__cl = ::TGeoPatternSphPhi::IsA();
01846 if (R__cl || R__insp.IsA()) { }
01847 TGeoPatternFinder::ShowMembers(R__insp);
01848 }
01849
01850 namespace ROOT {
01851
01852 static void *new_TGeoPatternSphPhi(void *p) {
01853 return p ? new(p) ::TGeoPatternSphPhi : new ::TGeoPatternSphPhi;
01854 }
01855 static void *newArray_TGeoPatternSphPhi(Long_t nElements, void *p) {
01856 return p ? new(p) ::TGeoPatternSphPhi[nElements] : new ::TGeoPatternSphPhi[nElements];
01857 }
01858
01859 static void delete_TGeoPatternSphPhi(void *p) {
01860 delete ((::TGeoPatternSphPhi*)p);
01861 }
01862 static void deleteArray_TGeoPatternSphPhi(void *p) {
01863 delete [] ((::TGeoPatternSphPhi*)p);
01864 }
01865 static void destruct_TGeoPatternSphPhi(void *p) {
01866 typedef ::TGeoPatternSphPhi current_t;
01867 ((current_t*)p)->~current_t();
01868 }
01869 }
01870
01871
01872 void TGeoPatternHoneycomb::Streamer(TBuffer &R__b)
01873 {
01874
01875
01876 if (R__b.IsReading()) {
01877 R__b.ReadClassBuffer(TGeoPatternHoneycomb::Class(),this);
01878 } else {
01879 R__b.WriteClassBuffer(TGeoPatternHoneycomb::Class(),this);
01880 }
01881 }
01882
01883
01884 void TGeoPatternHoneycomb::ShowMembers(TMemberInspector &R__insp)
01885 {
01886
01887 TClass *R__cl = ::TGeoPatternHoneycomb::IsA();
01888 if (R__cl || R__insp.IsA()) { }
01889 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrows", &fNrows);
01890 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisOnRows", &fAxisOnRows);
01891 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNdivisions", &fNdivisions);
01892 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStart", &fStart);
01893 TGeoPatternFinder::ShowMembers(R__insp);
01894 }
01895
01896 namespace ROOT {
01897
01898 static void *new_TGeoPatternHoneycomb(void *p) {
01899 return p ? new(p) ::TGeoPatternHoneycomb : new ::TGeoPatternHoneycomb;
01900 }
01901 static void *newArray_TGeoPatternHoneycomb(Long_t nElements, void *p) {
01902 return p ? new(p) ::TGeoPatternHoneycomb[nElements] : new ::TGeoPatternHoneycomb[nElements];
01903 }
01904
01905 static void delete_TGeoPatternHoneycomb(void *p) {
01906 delete ((::TGeoPatternHoneycomb*)p);
01907 }
01908 static void deleteArray_TGeoPatternHoneycomb(void *p) {
01909 delete [] ((::TGeoPatternHoneycomb*)p);
01910 }
01911 static void destruct_TGeoPatternHoneycomb(void *p) {
01912 typedef ::TGeoPatternHoneycomb current_t;
01913 ((current_t*)p)->~current_t();
01914 }
01915 }
01916
01917
01918 void TGeoNodeCache::Streamer(TBuffer &R__b)
01919 {
01920
01921
01922 if (R__b.IsReading()) {
01923 R__b.ReadClassBuffer(TGeoNodeCache::Class(),this);
01924 } else {
01925 R__b.WriteClassBuffer(TGeoNodeCache::Class(),this);
01926 }
01927 }
01928
01929
01930 void TGeoNodeCache::ShowMembers(TMemberInspector &R__insp)
01931 {
01932
01933 TClass *R__cl = ::TGeoNodeCache::IsA();
01934 if (R__cl || R__insp.IsA()) { }
01935 R__insp.Inspect(R__cl, R__insp.GetParent(), "fGeoCacheMaxLevels", &fGeoCacheMaxLevels);
01936 R__insp.Inspect(R__cl, R__insp.GetParent(), "fGeoCacheStackSize", &fGeoCacheStackSize);
01937 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLevel", &fLevel);
01938 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStackLevel", &fStackLevel);
01939 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentID", &fCurrentID);
01940 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndex", &fIndex);
01941 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIdBranch[100]", fIdBranch);
01942 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPath", &fPath);
01943 R__insp.InspectMember(fPath, "fPath.");
01944 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTop", &fTop);
01945 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNode", &fNode);
01946 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &fMatrix);
01947 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStack", &fStack);
01948 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixBranch", &fMatrixBranch);
01949 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMPB", &fMPB);
01950 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeBranch", &fNodeBranch);
01951 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeIdArray", &fNodeIdArray);
01952 TObject::ShowMembers(R__insp);
01953 }
01954
01955 namespace ROOT {
01956
01957 static void *new_TGeoNodeCache(void *p) {
01958 return p ? new(p) ::TGeoNodeCache : new ::TGeoNodeCache;
01959 }
01960 static void *newArray_TGeoNodeCache(Long_t nElements, void *p) {
01961 return p ? new(p) ::TGeoNodeCache[nElements] : new ::TGeoNodeCache[nElements];
01962 }
01963
01964 static void delete_TGeoNodeCache(void *p) {
01965 delete ((::TGeoNodeCache*)p);
01966 }
01967 static void deleteArray_TGeoNodeCache(void *p) {
01968 delete [] ((::TGeoNodeCache*)p);
01969 }
01970 static void destruct_TGeoNodeCache(void *p) {
01971 typedef ::TGeoNodeCache current_t;
01972 ((current_t*)p)->~current_t();
01973 }
01974 }
01975
01976
01977 void TGeoCacheState::Streamer(TBuffer &R__b)
01978 {
01979
01980
01981 if (R__b.IsReading()) {
01982 R__b.ReadClassBuffer(TGeoCacheState::Class(),this);
01983 } else {
01984 R__b.WriteClassBuffer(TGeoCacheState::Class(),this);
01985 }
01986 }
01987
01988
01989 void TGeoCacheState::ShowMembers(TMemberInspector &R__insp)
01990 {
01991
01992 TClass *R__cl = ::TGeoCacheState::IsA();
01993 if (R__cl || R__insp.IsA()) { }
01994 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCapacity", &fCapacity);
01995 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLevel", &fLevel);
01996 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNmany", &fNmany);
01997 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStart", &fStart);
01998 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIdBranch[30]", fIdBranch);
01999 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPoint[3]", fPoint);
02000 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverlapping", &fOverlapping);
02001 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeBranch", &fNodeBranch);
02002 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixBranch", &fMatrixBranch);
02003 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatPtr", &fMatPtr);
02004 TObject::ShowMembers(R__insp);
02005 }
02006
02007 namespace ROOT {
02008
02009 static void *new_TGeoCacheState(void *p) {
02010 return p ? new(p) ::TGeoCacheState : new ::TGeoCacheState;
02011 }
02012 static void *newArray_TGeoCacheState(Long_t nElements, void *p) {
02013 return p ? new(p) ::TGeoCacheState[nElements] : new ::TGeoCacheState[nElements];
02014 }
02015
02016 static void delete_TGeoCacheState(void *p) {
02017 delete ((::TGeoCacheState*)p);
02018 }
02019 static void deleteArray_TGeoCacheState(void *p) {
02020 delete [] ((::TGeoCacheState*)p);
02021 }
02022 static void destruct_TGeoCacheState(void *p) {
02023 typedef ::TGeoCacheState current_t;
02024 ((current_t*)p)->~current_t();
02025 }
02026 }
02027
02028
02029 void TVirtualMagField::Streamer(TBuffer &R__b)
02030 {
02031
02032
02033 if (R__b.IsReading()) {
02034 R__b.ReadClassBuffer(TVirtualMagField::Class(),this);
02035 } else {
02036 R__b.WriteClassBuffer(TVirtualMagField::Class(),this);
02037 }
02038 }
02039
02040
02041 void TVirtualMagField::ShowMembers(TMemberInspector &R__insp)
02042 {
02043
02044 TClass *R__cl = ::TVirtualMagField::IsA();
02045 if (R__cl || R__insp.IsA()) { }
02046 TNamed::ShowMembers(R__insp);
02047 }
02048
02049 namespace ROOT {
02050
02051 static void delete_TVirtualMagField(void *p) {
02052 delete ((::TVirtualMagField*)p);
02053 }
02054 static void deleteArray_TVirtualMagField(void *p) {
02055 delete [] ((::TVirtualMagField*)p);
02056 }
02057 static void destruct_TVirtualMagField(void *p) {
02058 typedef ::TVirtualMagField current_t;
02059 ((current_t*)p)->~current_t();
02060 }
02061 }
02062
02063
02064 void TGeoUniformMagField::Streamer(TBuffer &R__b)
02065 {
02066
02067
02068 if (R__b.IsReading()) {
02069 R__b.ReadClassBuffer(TGeoUniformMagField::Class(),this);
02070 } else {
02071 R__b.WriteClassBuffer(TGeoUniformMagField::Class(),this);
02072 }
02073 }
02074
02075
02076 void TGeoUniformMagField::ShowMembers(TMemberInspector &R__insp)
02077 {
02078
02079 TClass *R__cl = ::TGeoUniformMagField::IsA();
02080 if (R__cl || R__insp.IsA()) { }
02081 R__insp.Inspect(R__cl, R__insp.GetParent(), "fB[3]", fB);
02082 TVirtualMagField::ShowMembers(R__insp);
02083 }
02084
02085 namespace ROOT {
02086
02087 static void *new_TGeoUniformMagField(void *p) {
02088 return p ? new(p) ::TGeoUniformMagField : new ::TGeoUniformMagField;
02089 }
02090 static void *newArray_TGeoUniformMagField(Long_t nElements, void *p) {
02091 return p ? new(p) ::TGeoUniformMagField[nElements] : new ::TGeoUniformMagField[nElements];
02092 }
02093
02094 static void delete_TGeoUniformMagField(void *p) {
02095 delete ((::TGeoUniformMagField*)p);
02096 }
02097 static void deleteArray_TGeoUniformMagField(void *p) {
02098 delete [] ((::TGeoUniformMagField*)p);
02099 }
02100 static void destruct_TGeoUniformMagField(void *p) {
02101 typedef ::TGeoUniformMagField current_t;
02102 ((current_t*)p)->~current_t();
02103 }
02104 }
02105
02106
02107 void TGeoGlobalMagField::Streamer(TBuffer &R__b)
02108 {
02109
02110
02111 TObject::Streamer(R__b);
02112 }
02113
02114
02115 void TGeoGlobalMagField::ShowMembers(TMemberInspector &R__insp)
02116 {
02117
02118 TClass *R__cl = ::TGeoGlobalMagField::IsA();
02119 if (R__cl || R__insp.IsA()) { }
02120 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fField", &fField);
02121 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLock", &fLock);
02122 TObject::ShowMembers(R__insp);
02123 }
02124
02125 namespace ROOT {
02126
02127 static void *new_TGeoGlobalMagField(void *p) {
02128 return p ? new(p) ::TGeoGlobalMagField : new ::TGeoGlobalMagField;
02129 }
02130 static void *newArray_TGeoGlobalMagField(Long_t nElements, void *p) {
02131 return p ? new(p) ::TGeoGlobalMagField[nElements] : new ::TGeoGlobalMagField[nElements];
02132 }
02133
02134 static void delete_TGeoGlobalMagField(void *p) {
02135 delete ((::TGeoGlobalMagField*)p);
02136 }
02137 static void deleteArray_TGeoGlobalMagField(void *p) {
02138 delete [] ((::TGeoGlobalMagField*)p);
02139 }
02140 static void destruct_TGeoGlobalMagField(void *p) {
02141 typedef ::TGeoGlobalMagField current_t;
02142 ((current_t*)p)->~current_t();
02143 }
02144
02145 static void streamer_TGeoGlobalMagField(TBuffer &buf, void *obj) {
02146 ((::TGeoGlobalMagField*)obj)->::TGeoGlobalMagField::Streamer(buf);
02147 }
02148 }
02149
02150
02151
02152
02153
02154
02155
02156
02157 #ifdef G__MEMTEST
02158 #undef malloc
02159 #undef free
02160 #endif
02161
02162 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
02163 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
02164 #endif
02165
02166 extern "C" void G__cpp_reset_tagtableG__Geom2();
02167
02168 extern "C" void G__set_cpp_environmentG__Geom2() {
02169 G__add_compiledheader("TObject.h");
02170 G__add_compiledheader("TMemberInspector.h");
02171 G__add_compiledheader("TGeoPatternFinder.h");
02172 G__add_compiledheader("TGeoCache.h");
02173 G__add_compiledheader("TVirtualMagField.h");
02174 G__add_compiledheader("TGeoUniformMagField.h");
02175 G__add_compiledheader("TGeoGlobalMagField.h");
02176 G__cpp_reset_tagtableG__Geom2();
02177 }
02178 #include <new>
02179 extern "C" int G__cpp_dllrevG__Geom2() { return(30051515); }
02180
02181
02182
02183
02184
02185
02186 static int G__G__Geom2_166_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02187 {
02188 TGeoPatternFinder* p = NULL;
02189 char* gvp = (char*) G__getgvp();
02190 int n = G__getaryconstruct();
02191 if (n) {
02192 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02193 p = new TGeoPatternFinder[n];
02194 } else {
02195 p = new((void*) gvp) TGeoPatternFinder[n];
02196 }
02197 } else {
02198 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02199 p = new TGeoPatternFinder;
02200 } else {
02201 p = new((void*) gvp) TGeoPatternFinder;
02202 }
02203 }
02204 result7->obj.i = (long) p;
02205 result7->ref = (long) p;
02206 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder));
02207 return(1 || funcname || hash || result7 || libp) ;
02208 }
02209
02210 static int G__G__Geom2_166_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02211 {
02212 TGeoPatternFinder* p = NULL;
02213 char* gvp = (char*) G__getgvp();
02214
02215 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02216 p = new TGeoPatternFinder((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
02217 } else {
02218 p = new((void*) gvp) TGeoPatternFinder((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
02219 }
02220 result7->obj.i = (long) p;
02221 result7->ref = (long) p;
02222 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder));
02223 return(1 || funcname || hash || result7 || libp) ;
02224 }
02225
02226 static int G__G__Geom2_166_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02227 {
02228 ((TGeoPatternFinder*) G__getstructoffset())->cd((Int_t) G__int(libp->para[0]));
02229 G__setnull(result7);
02230 return(1 || funcname || hash || result7 || libp) ;
02231 }
02232
02233 static int G__G__Geom2_166_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02234 {
02235 G__letint(result7, 85, (long) ((TGeoPatternFinder*) G__getstructoffset())->CdNext());
02236 return(1 || funcname || hash || result7 || libp) ;
02237 }
02238
02239 static int G__G__Geom2_166_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02240 {
02241 switch (libp->paran) {
02242 case 2:
02243 G__letint(result7, 85, (long) ((TGeoPatternFinder*) G__getstructoffset())->FindNode((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
02244 break;
02245 case 1:
02246 G__letint(result7, 85, (long) ((TGeoPatternFinder*) G__getstructoffset())->FindNode((Double_t*) G__int(libp->para[0])));
02247 break;
02248 }
02249 return(1 || funcname || hash || result7 || libp) ;
02250 }
02251
02252 static int G__G__Geom2_166_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02253 {
02254 G__letint(result7, 105, (long) ((const TGeoPatternFinder*) G__getstructoffset())->GetByteCount());
02255 return(1 || funcname || hash || result7 || libp) ;
02256 }
02257
02258 static int G__G__Geom2_166_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02259 {
02260 G__letint(result7, 105, (long) ((TGeoPatternFinder*) G__getstructoffset())->GetCurrent());
02261 return(1 || funcname || hash || result7 || libp) ;
02262 }
02263
02264 static int G__G__Geom2_166_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02265 {
02266 G__letint(result7, 105, (long) ((TGeoPatternFinder*) G__getstructoffset())->GetDivIndex());
02267 return(1 || funcname || hash || result7 || libp) ;
02268 }
02269
02270 static int G__G__Geom2_166_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02271 {
02272 G__letint(result7, 105, (long) ((TGeoPatternFinder*) G__getstructoffset())->GetDivAxis());
02273 return(1 || funcname || hash || result7 || libp) ;
02274 }
02275
02276 static int G__G__Geom2_166_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02277 {
02278 G__letint(result7, 85, (long) ((TGeoPatternFinder*) G__getstructoffset())->GetMatrix());
02279 return(1 || funcname || hash || result7 || libp) ;
02280 }
02281
02282 static int G__G__Geom2_166_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02283 {
02284 G__letint(result7, 105, (long) ((const TGeoPatternFinder*) G__getstructoffset())->GetNdiv());
02285 return(1 || funcname || hash || result7 || libp) ;
02286 }
02287
02288 static int G__G__Geom2_166_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02289 {
02290 G__letint(result7, 105, (long) ((const TGeoPatternFinder*) G__getstructoffset())->GetNext());
02291 return(1 || funcname || hash || result7 || libp) ;
02292 }
02293
02294 static int G__G__Geom2_166_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02295 {
02296 G__letint(result7, 85, (long) ((TGeoPatternFinder*) G__getstructoffset())->GetNodeOffset((Int_t) G__int(libp->para[0])));
02297 return(1 || funcname || hash || result7 || libp) ;
02298 }
02299
02300 static int G__G__Geom2_166_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02301 {
02302 G__letdouble(result7, 100, (double) ((const TGeoPatternFinder*) G__getstructoffset())->GetStart());
02303 return(1 || funcname || hash || result7 || libp) ;
02304 }
02305
02306 static int G__G__Geom2_166_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02307 {
02308 G__letdouble(result7, 100, (double) ((const TGeoPatternFinder*) G__getstructoffset())->GetStep());
02309 return(1 || funcname || hash || result7 || libp) ;
02310 }
02311
02312 static int G__G__Geom2_166_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02313 {
02314 G__letdouble(result7, 100, (double) ((const TGeoPatternFinder*) G__getstructoffset())->GetEnd());
02315 return(1 || funcname || hash || result7 || libp) ;
02316 }
02317
02318 static int G__G__Geom2_166_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02319 {
02320 G__letint(result7, 85, (long) ((const TGeoPatternFinder*) G__getstructoffset())->GetVolume());
02321 return(1 || funcname || hash || result7 || libp) ;
02322 }
02323
02324 static int G__G__Geom2_166_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02325 {
02326 G__letint(result7, 103, (long) ((const TGeoPatternFinder*) G__getstructoffset())->IsOnBoundary((Double_t*) G__int(libp->para[0])));
02327 return(1 || funcname || hash || result7 || libp) ;
02328 }
02329
02330 static int G__G__Geom2_166_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02331 {
02332 G__letint(result7, 103, (long) ((const TGeoPatternFinder*) G__getstructoffset())->IsReflected());
02333 return(1 || funcname || hash || result7 || libp) ;
02334 }
02335
02336 static int G__G__Geom2_166_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02337 {
02338 switch (libp->paran) {
02339 case 1:
02340 G__letint(result7, 85, (long) ((TGeoPatternFinder*) G__getstructoffset())->MakeCopy((Bool_t) G__int(libp->para[0])));
02341 break;
02342 case 0:
02343 G__letint(result7, 85, (long) ((TGeoPatternFinder*) G__getstructoffset())->MakeCopy());
02344 break;
02345 }
02346 return(1 || funcname || hash || result7 || libp) ;
02347 }
02348
02349 static int G__G__Geom2_166_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02350 {
02351 switch (libp->paran) {
02352 case 1:
02353 ((TGeoPatternFinder*) G__getstructoffset())->Reflect((Bool_t) G__int(libp->para[0]));
02354 G__setnull(result7);
02355 break;
02356 case 0:
02357 ((TGeoPatternFinder*) G__getstructoffset())->Reflect();
02358 G__setnull(result7);
02359 break;
02360 }
02361 return(1 || funcname || hash || result7 || libp) ;
02362 }
02363
02364 static int G__G__Geom2_166_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02365 {
02366 ((TGeoPatternFinder*) G__getstructoffset())->SetDivIndex((Int_t) G__int(libp->para[0]));
02367 G__setnull(result7);
02368 return(1 || funcname || hash || result7 || libp) ;
02369 }
02370
02371 static int G__G__Geom2_166_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02372 {
02373 ((TGeoPatternFinder*) G__getstructoffset())->SetNext((Int_t) G__int(libp->para[0]));
02374 G__setnull(result7);
02375 return(1 || funcname || hash || result7 || libp) ;
02376 }
02377
02378 static int G__G__Geom2_166_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02379 {
02380 ((TGeoPatternFinder*) G__getstructoffset())->SetVolume((TGeoVolume*) G__int(libp->para[0]));
02381 G__setnull(result7);
02382 return(1 || funcname || hash || result7 || libp) ;
02383 }
02384
02385 static int G__G__Geom2_166_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02386 {
02387 G__letint(result7, 85, (long) TGeoPatternFinder::Class());
02388 return(1 || funcname || hash || result7 || libp) ;
02389 }
02390
02391 static int G__G__Geom2_166_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02392 {
02393 G__letint(result7, 67, (long) TGeoPatternFinder::Class_Name());
02394 return(1 || funcname || hash || result7 || libp) ;
02395 }
02396
02397 static int G__G__Geom2_166_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02398 {
02399 G__letint(result7, 115, (long) TGeoPatternFinder::Class_Version());
02400 return(1 || funcname || hash || result7 || libp) ;
02401 }
02402
02403 static int G__G__Geom2_166_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02404 {
02405 TGeoPatternFinder::Dictionary();
02406 G__setnull(result7);
02407 return(1 || funcname || hash || result7 || libp) ;
02408 }
02409
02410 static int G__G__Geom2_166_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02411 {
02412 ((TGeoPatternFinder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
02413 G__setnull(result7);
02414 return(1 || funcname || hash || result7 || libp) ;
02415 }
02416
02417 static int G__G__Geom2_166_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02418 {
02419 G__letint(result7, 67, (long) TGeoPatternFinder::DeclFileName());
02420 return(1 || funcname || hash || result7 || libp) ;
02421 }
02422
02423 static int G__G__Geom2_166_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02424 {
02425 G__letint(result7, 105, (long) TGeoPatternFinder::ImplFileLine());
02426 return(1 || funcname || hash || result7 || libp) ;
02427 }
02428
02429 static int G__G__Geom2_166_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02430 {
02431 G__letint(result7, 67, (long) TGeoPatternFinder::ImplFileName());
02432 return(1 || funcname || hash || result7 || libp) ;
02433 }
02434
02435 static int G__G__Geom2_166_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02436 {
02437 G__letint(result7, 105, (long) TGeoPatternFinder::DeclFileLine());
02438 return(1 || funcname || hash || result7 || libp) ;
02439 }
02440
02441
02442 typedef TGeoPatternFinder G__TTGeoPatternFinder;
02443 static int G__G__Geom2_166_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02444 {
02445 char* gvp = (char*) G__getgvp();
02446 long soff = G__getstructoffset();
02447 int n = G__getaryconstruct();
02448
02449
02450
02451
02452
02453 if (!soff) {
02454 return(1);
02455 }
02456 if (n) {
02457 if (gvp == (char*)G__PVOID) {
02458 delete[] (TGeoPatternFinder*) soff;
02459 } else {
02460 G__setgvp((long) G__PVOID);
02461 for (int i = n - 1; i >= 0; --i) {
02462 ((TGeoPatternFinder*) (soff+(sizeof(TGeoPatternFinder)*i)))->~G__TTGeoPatternFinder();
02463 }
02464 G__setgvp((long)gvp);
02465 }
02466 } else {
02467 if (gvp == (char*)G__PVOID) {
02468 delete (TGeoPatternFinder*) soff;
02469 } else {
02470 G__setgvp((long) G__PVOID);
02471 ((TGeoPatternFinder*) (soff))->~G__TTGeoPatternFinder();
02472 G__setgvp((long)gvp);
02473 }
02474 }
02475 G__setnull(result7);
02476 return(1 || funcname || hash || result7 || libp) ;
02477 }
02478
02479
02480
02481 static int G__G__Geom2_174_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02482 {
02483 TGeoPatternX* p = NULL;
02484 char* gvp = (char*) G__getgvp();
02485 int n = G__getaryconstruct();
02486 if (n) {
02487 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02488 p = new TGeoPatternX[n];
02489 } else {
02490 p = new((void*) gvp) TGeoPatternX[n];
02491 }
02492 } else {
02493 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02494 p = new TGeoPatternX;
02495 } else {
02496 p = new((void*) gvp) TGeoPatternX;
02497 }
02498 }
02499 result7->obj.i = (long) p;
02500 result7->ref = (long) p;
02501 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX));
02502 return(1 || funcname || hash || result7 || libp) ;
02503 }
02504
02505 static int G__G__Geom2_174_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02506 {
02507 TGeoPatternX* p = NULL;
02508 char* gvp = (char*) G__getgvp();
02509
02510 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02511 p = new TGeoPatternX((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
02512 } else {
02513 p = new((void*) gvp) TGeoPatternX((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
02514 }
02515 result7->obj.i = (long) p;
02516 result7->ref = (long) p;
02517 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX));
02518 return(1 || funcname || hash || result7 || libp) ;
02519 }
02520
02521 static int G__G__Geom2_174_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02522 {
02523 TGeoPatternX* p = NULL;
02524 char* gvp = (char*) G__getgvp();
02525
02526 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02527 p = new TGeoPatternX(
02528 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02529 , (Double_t) G__double(libp->para[2]));
02530 } else {
02531 p = new((void*) gvp) TGeoPatternX(
02532 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02533 , (Double_t) G__double(libp->para[2]));
02534 }
02535 result7->obj.i = (long) p;
02536 result7->ref = (long) p;
02537 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX));
02538 return(1 || funcname || hash || result7 || libp) ;
02539 }
02540
02541 static int G__G__Geom2_174_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02542 {
02543 TGeoPatternX* p = NULL;
02544 char* gvp = (char*) G__getgvp();
02545
02546 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02547 p = new TGeoPatternX(
02548 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02549 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
02550 } else {
02551 p = new((void*) gvp) TGeoPatternX(
02552 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02553 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
02554 }
02555 result7->obj.i = (long) p;
02556 result7->ref = (long) p;
02557 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX));
02558 return(1 || funcname || hash || result7 || libp) ;
02559 }
02560
02561 static int G__G__Geom2_174_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02562 {
02563 G__letdouble(result7, 100, (double) ((TGeoPatternX*) G__getstructoffset())->FindNextBoundary((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
02564 , *(Int_t*) G__Intref(&libp->para[2])));
02565 return(1 || funcname || hash || result7 || libp) ;
02566 }
02567
02568 static int G__G__Geom2_174_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02569 {
02570 G__letint(result7, 85, (long) TGeoPatternX::Class());
02571 return(1 || funcname || hash || result7 || libp) ;
02572 }
02573
02574 static int G__G__Geom2_174_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02575 {
02576 G__letint(result7, 67, (long) TGeoPatternX::Class_Name());
02577 return(1 || funcname || hash || result7 || libp) ;
02578 }
02579
02580 static int G__G__Geom2_174_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02581 {
02582 G__letint(result7, 115, (long) TGeoPatternX::Class_Version());
02583 return(1 || funcname || hash || result7 || libp) ;
02584 }
02585
02586 static int G__G__Geom2_174_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02587 {
02588 TGeoPatternX::Dictionary();
02589 G__setnull(result7);
02590 return(1 || funcname || hash || result7 || libp) ;
02591 }
02592
02593 static int G__G__Geom2_174_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02594 {
02595 ((TGeoPatternX*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
02596 G__setnull(result7);
02597 return(1 || funcname || hash || result7 || libp) ;
02598 }
02599
02600 static int G__G__Geom2_174_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02601 {
02602 G__letint(result7, 67, (long) TGeoPatternX::DeclFileName());
02603 return(1 || funcname || hash || result7 || libp) ;
02604 }
02605
02606 static int G__G__Geom2_174_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02607 {
02608 G__letint(result7, 105, (long) TGeoPatternX::ImplFileLine());
02609 return(1 || funcname || hash || result7 || libp) ;
02610 }
02611
02612 static int G__G__Geom2_174_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02613 {
02614 G__letint(result7, 67, (long) TGeoPatternX::ImplFileName());
02615 return(1 || funcname || hash || result7 || libp) ;
02616 }
02617
02618 static int G__G__Geom2_174_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02619 {
02620 G__letint(result7, 105, (long) TGeoPatternX::DeclFileLine());
02621 return(1 || funcname || hash || result7 || libp) ;
02622 }
02623
02624
02625 static int G__G__Geom2_174_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02626
02627 {
02628 TGeoPatternX* p;
02629 void* tmp = (void*) G__int(libp->para[0]);
02630 p = new TGeoPatternX(*(TGeoPatternX*) tmp);
02631 result7->obj.i = (long) p;
02632 result7->ref = (long) p;
02633 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX));
02634 return(1 || funcname || hash || result7 || libp) ;
02635 }
02636
02637
02638 typedef TGeoPatternX G__TTGeoPatternX;
02639 static int G__G__Geom2_174_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02640 {
02641 char* gvp = (char*) G__getgvp();
02642 long soff = G__getstructoffset();
02643 int n = G__getaryconstruct();
02644
02645
02646
02647
02648
02649 if (!soff) {
02650 return(1);
02651 }
02652 if (n) {
02653 if (gvp == (char*)G__PVOID) {
02654 delete[] (TGeoPatternX*) soff;
02655 } else {
02656 G__setgvp((long) G__PVOID);
02657 for (int i = n - 1; i >= 0; --i) {
02658 ((TGeoPatternX*) (soff+(sizeof(TGeoPatternX)*i)))->~G__TTGeoPatternX();
02659 }
02660 G__setgvp((long)gvp);
02661 }
02662 } else {
02663 if (gvp == (char*)G__PVOID) {
02664 delete (TGeoPatternX*) soff;
02665 } else {
02666 G__setgvp((long) G__PVOID);
02667 ((TGeoPatternX*) (soff))->~G__TTGeoPatternX();
02668 G__setgvp((long)gvp);
02669 }
02670 }
02671 G__setnull(result7);
02672 return(1 || funcname || hash || result7 || libp) ;
02673 }
02674
02675
02676
02677 static int G__G__Geom2_175_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02678 {
02679 TGeoPatternY* p = NULL;
02680 char* gvp = (char*) G__getgvp();
02681 int n = G__getaryconstruct();
02682 if (n) {
02683 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02684 p = new TGeoPatternY[n];
02685 } else {
02686 p = new((void*) gvp) TGeoPatternY[n];
02687 }
02688 } else {
02689 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02690 p = new TGeoPatternY;
02691 } else {
02692 p = new((void*) gvp) TGeoPatternY;
02693 }
02694 }
02695 result7->obj.i = (long) p;
02696 result7->ref = (long) p;
02697 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY));
02698 return(1 || funcname || hash || result7 || libp) ;
02699 }
02700
02701 static int G__G__Geom2_175_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02702 {
02703 TGeoPatternY* p = NULL;
02704 char* gvp = (char*) G__getgvp();
02705
02706 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02707 p = new TGeoPatternY((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
02708 } else {
02709 p = new((void*) gvp) TGeoPatternY((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
02710 }
02711 result7->obj.i = (long) p;
02712 result7->ref = (long) p;
02713 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY));
02714 return(1 || funcname || hash || result7 || libp) ;
02715 }
02716
02717 static int G__G__Geom2_175_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02718 {
02719 TGeoPatternY* p = NULL;
02720 char* gvp = (char*) G__getgvp();
02721
02722 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02723 p = new TGeoPatternY(
02724 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02725 , (Double_t) G__double(libp->para[2]));
02726 } else {
02727 p = new((void*) gvp) TGeoPatternY(
02728 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02729 , (Double_t) G__double(libp->para[2]));
02730 }
02731 result7->obj.i = (long) p;
02732 result7->ref = (long) p;
02733 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY));
02734 return(1 || funcname || hash || result7 || libp) ;
02735 }
02736
02737 static int G__G__Geom2_175_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02738 {
02739 TGeoPatternY* p = NULL;
02740 char* gvp = (char*) G__getgvp();
02741
02742 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02743 p = new TGeoPatternY(
02744 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02745 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
02746 } else {
02747 p = new((void*) gvp) TGeoPatternY(
02748 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02749 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
02750 }
02751 result7->obj.i = (long) p;
02752 result7->ref = (long) p;
02753 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY));
02754 return(1 || funcname || hash || result7 || libp) ;
02755 }
02756
02757 static int G__G__Geom2_175_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02758 {
02759 G__letdouble(result7, 100, (double) ((TGeoPatternY*) G__getstructoffset())->FindNextBoundary((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
02760 , *(Int_t*) G__Intref(&libp->para[2])));
02761 return(1 || funcname || hash || result7 || libp) ;
02762 }
02763
02764 static int G__G__Geom2_175_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02765 {
02766 G__letint(result7, 85, (long) TGeoPatternY::Class());
02767 return(1 || funcname || hash || result7 || libp) ;
02768 }
02769
02770 static int G__G__Geom2_175_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02771 {
02772 G__letint(result7, 67, (long) TGeoPatternY::Class_Name());
02773 return(1 || funcname || hash || result7 || libp) ;
02774 }
02775
02776 static int G__G__Geom2_175_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02777 {
02778 G__letint(result7, 115, (long) TGeoPatternY::Class_Version());
02779 return(1 || funcname || hash || result7 || libp) ;
02780 }
02781
02782 static int G__G__Geom2_175_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02783 {
02784 TGeoPatternY::Dictionary();
02785 G__setnull(result7);
02786 return(1 || funcname || hash || result7 || libp) ;
02787 }
02788
02789 static int G__G__Geom2_175_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02790 {
02791 ((TGeoPatternY*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
02792 G__setnull(result7);
02793 return(1 || funcname || hash || result7 || libp) ;
02794 }
02795
02796 static int G__G__Geom2_175_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02797 {
02798 G__letint(result7, 67, (long) TGeoPatternY::DeclFileName());
02799 return(1 || funcname || hash || result7 || libp) ;
02800 }
02801
02802 static int G__G__Geom2_175_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02803 {
02804 G__letint(result7, 105, (long) TGeoPatternY::ImplFileLine());
02805 return(1 || funcname || hash || result7 || libp) ;
02806 }
02807
02808 static int G__G__Geom2_175_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02809 {
02810 G__letint(result7, 67, (long) TGeoPatternY::ImplFileName());
02811 return(1 || funcname || hash || result7 || libp) ;
02812 }
02813
02814 static int G__G__Geom2_175_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02815 {
02816 G__letint(result7, 105, (long) TGeoPatternY::DeclFileLine());
02817 return(1 || funcname || hash || result7 || libp) ;
02818 }
02819
02820
02821 static int G__G__Geom2_175_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02822
02823 {
02824 TGeoPatternY* p;
02825 void* tmp = (void*) G__int(libp->para[0]);
02826 p = new TGeoPatternY(*(TGeoPatternY*) tmp);
02827 result7->obj.i = (long) p;
02828 result7->ref = (long) p;
02829 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY));
02830 return(1 || funcname || hash || result7 || libp) ;
02831 }
02832
02833
02834 typedef TGeoPatternY G__TTGeoPatternY;
02835 static int G__G__Geom2_175_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02836 {
02837 char* gvp = (char*) G__getgvp();
02838 long soff = G__getstructoffset();
02839 int n = G__getaryconstruct();
02840
02841
02842
02843
02844
02845 if (!soff) {
02846 return(1);
02847 }
02848 if (n) {
02849 if (gvp == (char*)G__PVOID) {
02850 delete[] (TGeoPatternY*) soff;
02851 } else {
02852 G__setgvp((long) G__PVOID);
02853 for (int i = n - 1; i >= 0; --i) {
02854 ((TGeoPatternY*) (soff+(sizeof(TGeoPatternY)*i)))->~G__TTGeoPatternY();
02855 }
02856 G__setgvp((long)gvp);
02857 }
02858 } else {
02859 if (gvp == (char*)G__PVOID) {
02860 delete (TGeoPatternY*) soff;
02861 } else {
02862 G__setgvp((long) G__PVOID);
02863 ((TGeoPatternY*) (soff))->~G__TTGeoPatternY();
02864 G__setgvp((long)gvp);
02865 }
02866 }
02867 G__setnull(result7);
02868 return(1 || funcname || hash || result7 || libp) ;
02869 }
02870
02871
02872
02873 static int G__G__Geom2_176_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02874 {
02875 TGeoPatternZ* p = NULL;
02876 char* gvp = (char*) G__getgvp();
02877 int n = G__getaryconstruct();
02878 if (n) {
02879 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02880 p = new TGeoPatternZ[n];
02881 } else {
02882 p = new((void*) gvp) TGeoPatternZ[n];
02883 }
02884 } else {
02885 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02886 p = new TGeoPatternZ;
02887 } else {
02888 p = new((void*) gvp) TGeoPatternZ;
02889 }
02890 }
02891 result7->obj.i = (long) p;
02892 result7->ref = (long) p;
02893 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ));
02894 return(1 || funcname || hash || result7 || libp) ;
02895 }
02896
02897 static int G__G__Geom2_176_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02898 {
02899 TGeoPatternZ* p = NULL;
02900 char* gvp = (char*) G__getgvp();
02901
02902 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02903 p = new TGeoPatternZ((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
02904 } else {
02905 p = new((void*) gvp) TGeoPatternZ((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
02906 }
02907 result7->obj.i = (long) p;
02908 result7->ref = (long) p;
02909 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ));
02910 return(1 || funcname || hash || result7 || libp) ;
02911 }
02912
02913 static int G__G__Geom2_176_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02914 {
02915 TGeoPatternZ* p = NULL;
02916 char* gvp = (char*) G__getgvp();
02917
02918 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02919 p = new TGeoPatternZ(
02920 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02921 , (Double_t) G__double(libp->para[2]));
02922 } else {
02923 p = new((void*) gvp) TGeoPatternZ(
02924 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02925 , (Double_t) G__double(libp->para[2]));
02926 }
02927 result7->obj.i = (long) p;
02928 result7->ref = (long) p;
02929 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ));
02930 return(1 || funcname || hash || result7 || libp) ;
02931 }
02932
02933 static int G__G__Geom2_176_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02934 {
02935 TGeoPatternZ* p = NULL;
02936 char* gvp = (char*) G__getgvp();
02937
02938 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02939 p = new TGeoPatternZ(
02940 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02941 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
02942 } else {
02943 p = new((void*) gvp) TGeoPatternZ(
02944 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
02945 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
02946 }
02947 result7->obj.i = (long) p;
02948 result7->ref = (long) p;
02949 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ));
02950 return(1 || funcname || hash || result7 || libp) ;
02951 }
02952
02953 static int G__G__Geom2_176_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02954 {
02955 G__letdouble(result7, 100, (double) ((TGeoPatternZ*) G__getstructoffset())->FindNextBoundary((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
02956 , *(Int_t*) G__Intref(&libp->para[2])));
02957 return(1 || funcname || hash || result7 || libp) ;
02958 }
02959
02960 static int G__G__Geom2_176_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02961 {
02962 G__letint(result7, 85, (long) TGeoPatternZ::Class());
02963 return(1 || funcname || hash || result7 || libp) ;
02964 }
02965
02966 static int G__G__Geom2_176_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02967 {
02968 G__letint(result7, 67, (long) TGeoPatternZ::Class_Name());
02969 return(1 || funcname || hash || result7 || libp) ;
02970 }
02971
02972 static int G__G__Geom2_176_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02973 {
02974 G__letint(result7, 115, (long) TGeoPatternZ::Class_Version());
02975 return(1 || funcname || hash || result7 || libp) ;
02976 }
02977
02978 static int G__G__Geom2_176_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02979 {
02980 TGeoPatternZ::Dictionary();
02981 G__setnull(result7);
02982 return(1 || funcname || hash || result7 || libp) ;
02983 }
02984
02985 static int G__G__Geom2_176_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02986 {
02987 ((TGeoPatternZ*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
02988 G__setnull(result7);
02989 return(1 || funcname || hash || result7 || libp) ;
02990 }
02991
02992 static int G__G__Geom2_176_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02993 {
02994 G__letint(result7, 67, (long) TGeoPatternZ::DeclFileName());
02995 return(1 || funcname || hash || result7 || libp) ;
02996 }
02997
02998 static int G__G__Geom2_176_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02999 {
03000 G__letint(result7, 105, (long) TGeoPatternZ::ImplFileLine());
03001 return(1 || funcname || hash || result7 || libp) ;
03002 }
03003
03004 static int G__G__Geom2_176_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03005 {
03006 G__letint(result7, 67, (long) TGeoPatternZ::ImplFileName());
03007 return(1 || funcname || hash || result7 || libp) ;
03008 }
03009
03010 static int G__G__Geom2_176_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03011 {
03012 G__letint(result7, 105, (long) TGeoPatternZ::DeclFileLine());
03013 return(1 || funcname || hash || result7 || libp) ;
03014 }
03015
03016
03017 static int G__G__Geom2_176_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03018
03019 {
03020 TGeoPatternZ* p;
03021 void* tmp = (void*) G__int(libp->para[0]);
03022 p = new TGeoPatternZ(*(TGeoPatternZ*) tmp);
03023 result7->obj.i = (long) p;
03024 result7->ref = (long) p;
03025 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ));
03026 return(1 || funcname || hash || result7 || libp) ;
03027 }
03028
03029
03030 typedef TGeoPatternZ G__TTGeoPatternZ;
03031 static int G__G__Geom2_176_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03032 {
03033 char* gvp = (char*) G__getgvp();
03034 long soff = G__getstructoffset();
03035 int n = G__getaryconstruct();
03036
03037
03038
03039
03040
03041 if (!soff) {
03042 return(1);
03043 }
03044 if (n) {
03045 if (gvp == (char*)G__PVOID) {
03046 delete[] (TGeoPatternZ*) soff;
03047 } else {
03048 G__setgvp((long) G__PVOID);
03049 for (int i = n - 1; i >= 0; --i) {
03050 ((TGeoPatternZ*) (soff+(sizeof(TGeoPatternZ)*i)))->~G__TTGeoPatternZ();
03051 }
03052 G__setgvp((long)gvp);
03053 }
03054 } else {
03055 if (gvp == (char*)G__PVOID) {
03056 delete (TGeoPatternZ*) soff;
03057 } else {
03058 G__setgvp((long) G__PVOID);
03059 ((TGeoPatternZ*) (soff))->~G__TTGeoPatternZ();
03060 G__setgvp((long)gvp);
03061 }
03062 }
03063 G__setnull(result7);
03064 return(1 || funcname || hash || result7 || libp) ;
03065 }
03066
03067
03068
03069 static int G__G__Geom2_177_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03070 {
03071 TGeoPatternParaX* p = NULL;
03072 char* gvp = (char*) G__getgvp();
03073 int n = G__getaryconstruct();
03074 if (n) {
03075 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03076 p = new TGeoPatternParaX[n];
03077 } else {
03078 p = new((void*) gvp) TGeoPatternParaX[n];
03079 }
03080 } else {
03081 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03082 p = new TGeoPatternParaX;
03083 } else {
03084 p = new((void*) gvp) TGeoPatternParaX;
03085 }
03086 }
03087 result7->obj.i = (long) p;
03088 result7->ref = (long) p;
03089 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX));
03090 return(1 || funcname || hash || result7 || libp) ;
03091 }
03092
03093 static int G__G__Geom2_177_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03094 {
03095 TGeoPatternParaX* p = NULL;
03096 char* gvp = (char*) G__getgvp();
03097
03098 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03099 p = new TGeoPatternParaX((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03100 } else {
03101 p = new((void*) gvp) TGeoPatternParaX((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03102 }
03103 result7->obj.i = (long) p;
03104 result7->ref = (long) p;
03105 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX));
03106 return(1 || funcname || hash || result7 || libp) ;
03107 }
03108
03109 static int G__G__Geom2_177_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03110 {
03111 TGeoPatternParaX* p = NULL;
03112 char* gvp = (char*) G__getgvp();
03113
03114 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03115 p = new TGeoPatternParaX(
03116 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03117 , (Double_t) G__double(libp->para[2]));
03118 } else {
03119 p = new((void*) gvp) TGeoPatternParaX(
03120 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03121 , (Double_t) G__double(libp->para[2]));
03122 }
03123 result7->obj.i = (long) p;
03124 result7->ref = (long) p;
03125 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX));
03126 return(1 || funcname || hash || result7 || libp) ;
03127 }
03128
03129 static int G__G__Geom2_177_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03130 {
03131 TGeoPatternParaX* p = NULL;
03132 char* gvp = (char*) G__getgvp();
03133
03134 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03135 p = new TGeoPatternParaX(
03136 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03137 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03138 } else {
03139 p = new((void*) gvp) TGeoPatternParaX(
03140 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03141 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03142 }
03143 result7->obj.i = (long) p;
03144 result7->ref = (long) p;
03145 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX));
03146 return(1 || funcname || hash || result7 || libp) ;
03147 }
03148
03149 static int G__G__Geom2_177_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03150 {
03151 G__letint(result7, 85, (long) TGeoPatternParaX::Class());
03152 return(1 || funcname || hash || result7 || libp) ;
03153 }
03154
03155 static int G__G__Geom2_177_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03156 {
03157 G__letint(result7, 67, (long) TGeoPatternParaX::Class_Name());
03158 return(1 || funcname || hash || result7 || libp) ;
03159 }
03160
03161 static int G__G__Geom2_177_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03162 {
03163 G__letint(result7, 115, (long) TGeoPatternParaX::Class_Version());
03164 return(1 || funcname || hash || result7 || libp) ;
03165 }
03166
03167 static int G__G__Geom2_177_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03168 {
03169 TGeoPatternParaX::Dictionary();
03170 G__setnull(result7);
03171 return(1 || funcname || hash || result7 || libp) ;
03172 }
03173
03174 static int G__G__Geom2_177_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03175 {
03176 ((TGeoPatternParaX*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03177 G__setnull(result7);
03178 return(1 || funcname || hash || result7 || libp) ;
03179 }
03180
03181 static int G__G__Geom2_177_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03182 {
03183 G__letint(result7, 67, (long) TGeoPatternParaX::DeclFileName());
03184 return(1 || funcname || hash || result7 || libp) ;
03185 }
03186
03187 static int G__G__Geom2_177_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03188 {
03189 G__letint(result7, 105, (long) TGeoPatternParaX::ImplFileLine());
03190 return(1 || funcname || hash || result7 || libp) ;
03191 }
03192
03193 static int G__G__Geom2_177_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03194 {
03195 G__letint(result7, 67, (long) TGeoPatternParaX::ImplFileName());
03196 return(1 || funcname || hash || result7 || libp) ;
03197 }
03198
03199 static int G__G__Geom2_177_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03200 {
03201 G__letint(result7, 105, (long) TGeoPatternParaX::DeclFileLine());
03202 return(1 || funcname || hash || result7 || libp) ;
03203 }
03204
03205
03206 static int G__G__Geom2_177_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03207
03208 {
03209 TGeoPatternParaX* p;
03210 void* tmp = (void*) G__int(libp->para[0]);
03211 p = new TGeoPatternParaX(*(TGeoPatternParaX*) tmp);
03212 result7->obj.i = (long) p;
03213 result7->ref = (long) p;
03214 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX));
03215 return(1 || funcname || hash || result7 || libp) ;
03216 }
03217
03218
03219 typedef TGeoPatternParaX G__TTGeoPatternParaX;
03220 static int G__G__Geom2_177_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03221 {
03222 char* gvp = (char*) G__getgvp();
03223 long soff = G__getstructoffset();
03224 int n = G__getaryconstruct();
03225
03226
03227
03228
03229
03230 if (!soff) {
03231 return(1);
03232 }
03233 if (n) {
03234 if (gvp == (char*)G__PVOID) {
03235 delete[] (TGeoPatternParaX*) soff;
03236 } else {
03237 G__setgvp((long) G__PVOID);
03238 for (int i = n - 1; i >= 0; --i) {
03239 ((TGeoPatternParaX*) (soff+(sizeof(TGeoPatternParaX)*i)))->~G__TTGeoPatternParaX();
03240 }
03241 G__setgvp((long)gvp);
03242 }
03243 } else {
03244 if (gvp == (char*)G__PVOID) {
03245 delete (TGeoPatternParaX*) soff;
03246 } else {
03247 G__setgvp((long) G__PVOID);
03248 ((TGeoPatternParaX*) (soff))->~G__TTGeoPatternParaX();
03249 G__setgvp((long)gvp);
03250 }
03251 }
03252 G__setnull(result7);
03253 return(1 || funcname || hash || result7 || libp) ;
03254 }
03255
03256
03257
03258 static int G__G__Geom2_178_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03259 {
03260 TGeoPatternParaY* p = NULL;
03261 char* gvp = (char*) G__getgvp();
03262 int n = G__getaryconstruct();
03263 if (n) {
03264 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03265 p = new TGeoPatternParaY[n];
03266 } else {
03267 p = new((void*) gvp) TGeoPatternParaY[n];
03268 }
03269 } else {
03270 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03271 p = new TGeoPatternParaY;
03272 } else {
03273 p = new((void*) gvp) TGeoPatternParaY;
03274 }
03275 }
03276 result7->obj.i = (long) p;
03277 result7->ref = (long) p;
03278 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY));
03279 return(1 || funcname || hash || result7 || libp) ;
03280 }
03281
03282 static int G__G__Geom2_178_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03283 {
03284 TGeoPatternParaY* p = NULL;
03285 char* gvp = (char*) G__getgvp();
03286
03287 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03288 p = new TGeoPatternParaY((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03289 } else {
03290 p = new((void*) gvp) TGeoPatternParaY((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03291 }
03292 result7->obj.i = (long) p;
03293 result7->ref = (long) p;
03294 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY));
03295 return(1 || funcname || hash || result7 || libp) ;
03296 }
03297
03298 static int G__G__Geom2_178_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03299 {
03300 TGeoPatternParaY* p = NULL;
03301 char* gvp = (char*) G__getgvp();
03302
03303 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03304 p = new TGeoPatternParaY(
03305 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03306 , (Double_t) G__double(libp->para[2]));
03307 } else {
03308 p = new((void*) gvp) TGeoPatternParaY(
03309 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03310 , (Double_t) G__double(libp->para[2]));
03311 }
03312 result7->obj.i = (long) p;
03313 result7->ref = (long) p;
03314 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY));
03315 return(1 || funcname || hash || result7 || libp) ;
03316 }
03317
03318 static int G__G__Geom2_178_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03319 {
03320 TGeoPatternParaY* p = NULL;
03321 char* gvp = (char*) G__getgvp();
03322
03323 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03324 p = new TGeoPatternParaY(
03325 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03326 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03327 } else {
03328 p = new((void*) gvp) TGeoPatternParaY(
03329 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03330 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03331 }
03332 result7->obj.i = (long) p;
03333 result7->ref = (long) p;
03334 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY));
03335 return(1 || funcname || hash || result7 || libp) ;
03336 }
03337
03338 static int G__G__Geom2_178_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03339 {
03340 G__letint(result7, 85, (long) TGeoPatternParaY::Class());
03341 return(1 || funcname || hash || result7 || libp) ;
03342 }
03343
03344 static int G__G__Geom2_178_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03345 {
03346 G__letint(result7, 67, (long) TGeoPatternParaY::Class_Name());
03347 return(1 || funcname || hash || result7 || libp) ;
03348 }
03349
03350 static int G__G__Geom2_178_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03351 {
03352 G__letint(result7, 115, (long) TGeoPatternParaY::Class_Version());
03353 return(1 || funcname || hash || result7 || libp) ;
03354 }
03355
03356 static int G__G__Geom2_178_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03357 {
03358 TGeoPatternParaY::Dictionary();
03359 G__setnull(result7);
03360 return(1 || funcname || hash || result7 || libp) ;
03361 }
03362
03363 static int G__G__Geom2_178_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03364 {
03365 ((TGeoPatternParaY*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03366 G__setnull(result7);
03367 return(1 || funcname || hash || result7 || libp) ;
03368 }
03369
03370 static int G__G__Geom2_178_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03371 {
03372 G__letint(result7, 67, (long) TGeoPatternParaY::DeclFileName());
03373 return(1 || funcname || hash || result7 || libp) ;
03374 }
03375
03376 static int G__G__Geom2_178_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03377 {
03378 G__letint(result7, 105, (long) TGeoPatternParaY::ImplFileLine());
03379 return(1 || funcname || hash || result7 || libp) ;
03380 }
03381
03382 static int G__G__Geom2_178_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03383 {
03384 G__letint(result7, 67, (long) TGeoPatternParaY::ImplFileName());
03385 return(1 || funcname || hash || result7 || libp) ;
03386 }
03387
03388 static int G__G__Geom2_178_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03389 {
03390 G__letint(result7, 105, (long) TGeoPatternParaY::DeclFileLine());
03391 return(1 || funcname || hash || result7 || libp) ;
03392 }
03393
03394
03395 static int G__G__Geom2_178_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03396
03397 {
03398 TGeoPatternParaY* p;
03399 void* tmp = (void*) G__int(libp->para[0]);
03400 p = new TGeoPatternParaY(*(TGeoPatternParaY*) tmp);
03401 result7->obj.i = (long) p;
03402 result7->ref = (long) p;
03403 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY));
03404 return(1 || funcname || hash || result7 || libp) ;
03405 }
03406
03407
03408 typedef TGeoPatternParaY G__TTGeoPatternParaY;
03409 static int G__G__Geom2_178_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03410 {
03411 char* gvp = (char*) G__getgvp();
03412 long soff = G__getstructoffset();
03413 int n = G__getaryconstruct();
03414
03415
03416
03417
03418
03419 if (!soff) {
03420 return(1);
03421 }
03422 if (n) {
03423 if (gvp == (char*)G__PVOID) {
03424 delete[] (TGeoPatternParaY*) soff;
03425 } else {
03426 G__setgvp((long) G__PVOID);
03427 for (int i = n - 1; i >= 0; --i) {
03428 ((TGeoPatternParaY*) (soff+(sizeof(TGeoPatternParaY)*i)))->~G__TTGeoPatternParaY();
03429 }
03430 G__setgvp((long)gvp);
03431 }
03432 } else {
03433 if (gvp == (char*)G__PVOID) {
03434 delete (TGeoPatternParaY*) soff;
03435 } else {
03436 G__setgvp((long) G__PVOID);
03437 ((TGeoPatternParaY*) (soff))->~G__TTGeoPatternParaY();
03438 G__setgvp((long)gvp);
03439 }
03440 }
03441 G__setnull(result7);
03442 return(1 || funcname || hash || result7 || libp) ;
03443 }
03444
03445
03446
03447 static int G__G__Geom2_179_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03448 {
03449 TGeoPatternParaZ* p = NULL;
03450 char* gvp = (char*) G__getgvp();
03451 int n = G__getaryconstruct();
03452 if (n) {
03453 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03454 p = new TGeoPatternParaZ[n];
03455 } else {
03456 p = new((void*) gvp) TGeoPatternParaZ[n];
03457 }
03458 } else {
03459 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03460 p = new TGeoPatternParaZ;
03461 } else {
03462 p = new((void*) gvp) TGeoPatternParaZ;
03463 }
03464 }
03465 result7->obj.i = (long) p;
03466 result7->ref = (long) p;
03467 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ));
03468 return(1 || funcname || hash || result7 || libp) ;
03469 }
03470
03471 static int G__G__Geom2_179_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03472 {
03473 TGeoPatternParaZ* p = NULL;
03474 char* gvp = (char*) G__getgvp();
03475
03476 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03477 p = new TGeoPatternParaZ((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03478 } else {
03479 p = new((void*) gvp) TGeoPatternParaZ((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03480 }
03481 result7->obj.i = (long) p;
03482 result7->ref = (long) p;
03483 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ));
03484 return(1 || funcname || hash || result7 || libp) ;
03485 }
03486
03487 static int G__G__Geom2_179_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03488 {
03489 TGeoPatternParaZ* p = NULL;
03490 char* gvp = (char*) G__getgvp();
03491
03492 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03493 p = new TGeoPatternParaZ(
03494 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03495 , (Double_t) G__double(libp->para[2]));
03496 } else {
03497 p = new((void*) gvp) TGeoPatternParaZ(
03498 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03499 , (Double_t) G__double(libp->para[2]));
03500 }
03501 result7->obj.i = (long) p;
03502 result7->ref = (long) p;
03503 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ));
03504 return(1 || funcname || hash || result7 || libp) ;
03505 }
03506
03507 static int G__G__Geom2_179_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03508 {
03509 TGeoPatternParaZ* p = NULL;
03510 char* gvp = (char*) G__getgvp();
03511
03512 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03513 p = new TGeoPatternParaZ(
03514 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03515 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03516 } else {
03517 p = new((void*) gvp) TGeoPatternParaZ(
03518 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03519 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03520 }
03521 result7->obj.i = (long) p;
03522 result7->ref = (long) p;
03523 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ));
03524 return(1 || funcname || hash || result7 || libp) ;
03525 }
03526
03527 static int G__G__Geom2_179_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03528 {
03529 G__letint(result7, 85, (long) TGeoPatternParaZ::Class());
03530 return(1 || funcname || hash || result7 || libp) ;
03531 }
03532
03533 static int G__G__Geom2_179_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03534 {
03535 G__letint(result7, 67, (long) TGeoPatternParaZ::Class_Name());
03536 return(1 || funcname || hash || result7 || libp) ;
03537 }
03538
03539 static int G__G__Geom2_179_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03540 {
03541 G__letint(result7, 115, (long) TGeoPatternParaZ::Class_Version());
03542 return(1 || funcname || hash || result7 || libp) ;
03543 }
03544
03545 static int G__G__Geom2_179_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03546 {
03547 TGeoPatternParaZ::Dictionary();
03548 G__setnull(result7);
03549 return(1 || funcname || hash || result7 || libp) ;
03550 }
03551
03552 static int G__G__Geom2_179_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03553 {
03554 ((TGeoPatternParaZ*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03555 G__setnull(result7);
03556 return(1 || funcname || hash || result7 || libp) ;
03557 }
03558
03559 static int G__G__Geom2_179_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03560 {
03561 G__letint(result7, 67, (long) TGeoPatternParaZ::DeclFileName());
03562 return(1 || funcname || hash || result7 || libp) ;
03563 }
03564
03565 static int G__G__Geom2_179_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03566 {
03567 G__letint(result7, 105, (long) TGeoPatternParaZ::ImplFileLine());
03568 return(1 || funcname || hash || result7 || libp) ;
03569 }
03570
03571 static int G__G__Geom2_179_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03572 {
03573 G__letint(result7, 67, (long) TGeoPatternParaZ::ImplFileName());
03574 return(1 || funcname || hash || result7 || libp) ;
03575 }
03576
03577 static int G__G__Geom2_179_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03578 {
03579 G__letint(result7, 105, (long) TGeoPatternParaZ::DeclFileLine());
03580 return(1 || funcname || hash || result7 || libp) ;
03581 }
03582
03583
03584 static int G__G__Geom2_179_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03585
03586 {
03587 TGeoPatternParaZ* p;
03588 void* tmp = (void*) G__int(libp->para[0]);
03589 p = new TGeoPatternParaZ(*(TGeoPatternParaZ*) tmp);
03590 result7->obj.i = (long) p;
03591 result7->ref = (long) p;
03592 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ));
03593 return(1 || funcname || hash || result7 || libp) ;
03594 }
03595
03596
03597 typedef TGeoPatternParaZ G__TTGeoPatternParaZ;
03598 static int G__G__Geom2_179_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03599 {
03600 char* gvp = (char*) G__getgvp();
03601 long soff = G__getstructoffset();
03602 int n = G__getaryconstruct();
03603
03604
03605
03606
03607
03608 if (!soff) {
03609 return(1);
03610 }
03611 if (n) {
03612 if (gvp == (char*)G__PVOID) {
03613 delete[] (TGeoPatternParaZ*) soff;
03614 } else {
03615 G__setgvp((long) G__PVOID);
03616 for (int i = n - 1; i >= 0; --i) {
03617 ((TGeoPatternParaZ*) (soff+(sizeof(TGeoPatternParaZ)*i)))->~G__TTGeoPatternParaZ();
03618 }
03619 G__setgvp((long)gvp);
03620 }
03621 } else {
03622 if (gvp == (char*)G__PVOID) {
03623 delete (TGeoPatternParaZ*) soff;
03624 } else {
03625 G__setgvp((long) G__PVOID);
03626 ((TGeoPatternParaZ*) (soff))->~G__TTGeoPatternParaZ();
03627 G__setgvp((long)gvp);
03628 }
03629 }
03630 G__setnull(result7);
03631 return(1 || funcname || hash || result7 || libp) ;
03632 }
03633
03634
03635
03636 static int G__G__Geom2_180_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03637 {
03638 TGeoPatternTrapZ* p = NULL;
03639 char* gvp = (char*) G__getgvp();
03640 int n = G__getaryconstruct();
03641 if (n) {
03642 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03643 p = new TGeoPatternTrapZ[n];
03644 } else {
03645 p = new((void*) gvp) TGeoPatternTrapZ[n];
03646 }
03647 } else {
03648 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03649 p = new TGeoPatternTrapZ;
03650 } else {
03651 p = new((void*) gvp) TGeoPatternTrapZ;
03652 }
03653 }
03654 result7->obj.i = (long) p;
03655 result7->ref = (long) p;
03656 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ));
03657 return(1 || funcname || hash || result7 || libp) ;
03658 }
03659
03660 static int G__G__Geom2_180_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03661 {
03662 TGeoPatternTrapZ* p = NULL;
03663 char* gvp = (char*) G__getgvp();
03664
03665 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03666 p = new TGeoPatternTrapZ((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03667 } else {
03668 p = new((void*) gvp) TGeoPatternTrapZ((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03669 }
03670 result7->obj.i = (long) p;
03671 result7->ref = (long) p;
03672 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ));
03673 return(1 || funcname || hash || result7 || libp) ;
03674 }
03675
03676 static int G__G__Geom2_180_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03677 {
03678 TGeoPatternTrapZ* p = NULL;
03679 char* gvp = (char*) G__getgvp();
03680
03681 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03682 p = new TGeoPatternTrapZ(
03683 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03684 , (Double_t) G__double(libp->para[2]));
03685 } else {
03686 p = new((void*) gvp) TGeoPatternTrapZ(
03687 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03688 , (Double_t) G__double(libp->para[2]));
03689 }
03690 result7->obj.i = (long) p;
03691 result7->ref = (long) p;
03692 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ));
03693 return(1 || funcname || hash || result7 || libp) ;
03694 }
03695
03696 static int G__G__Geom2_180_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03697 {
03698 TGeoPatternTrapZ* p = NULL;
03699 char* gvp = (char*) G__getgvp();
03700
03701 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03702 p = new TGeoPatternTrapZ(
03703 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03704 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03705 } else {
03706 p = new((void*) gvp) TGeoPatternTrapZ(
03707 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03708 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03709 }
03710 result7->obj.i = (long) p;
03711 result7->ref = (long) p;
03712 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ));
03713 return(1 || funcname || hash || result7 || libp) ;
03714 }
03715
03716 static int G__G__Geom2_180_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03717 {
03718 G__letdouble(result7, 100, (double) ((const TGeoPatternTrapZ*) G__getstructoffset())->GetTxz());
03719 return(1 || funcname || hash || result7 || libp) ;
03720 }
03721
03722 static int G__G__Geom2_180_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03723 {
03724 G__letdouble(result7, 100, (double) ((const TGeoPatternTrapZ*) G__getstructoffset())->GetTyz());
03725 return(1 || funcname || hash || result7 || libp) ;
03726 }
03727
03728 static int G__G__Geom2_180_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03729 {
03730 G__letint(result7, 85, (long) TGeoPatternTrapZ::Class());
03731 return(1 || funcname || hash || result7 || libp) ;
03732 }
03733
03734 static int G__G__Geom2_180_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03735 {
03736 G__letint(result7, 67, (long) TGeoPatternTrapZ::Class_Name());
03737 return(1 || funcname || hash || result7 || libp) ;
03738 }
03739
03740 static int G__G__Geom2_180_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03741 {
03742 G__letint(result7, 115, (long) TGeoPatternTrapZ::Class_Version());
03743 return(1 || funcname || hash || result7 || libp) ;
03744 }
03745
03746 static int G__G__Geom2_180_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03747 {
03748 TGeoPatternTrapZ::Dictionary();
03749 G__setnull(result7);
03750 return(1 || funcname || hash || result7 || libp) ;
03751 }
03752
03753 static int G__G__Geom2_180_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03754 {
03755 ((TGeoPatternTrapZ*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03756 G__setnull(result7);
03757 return(1 || funcname || hash || result7 || libp) ;
03758 }
03759
03760 static int G__G__Geom2_180_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03761 {
03762 G__letint(result7, 67, (long) TGeoPatternTrapZ::DeclFileName());
03763 return(1 || funcname || hash || result7 || libp) ;
03764 }
03765
03766 static int G__G__Geom2_180_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03767 {
03768 G__letint(result7, 105, (long) TGeoPatternTrapZ::ImplFileLine());
03769 return(1 || funcname || hash || result7 || libp) ;
03770 }
03771
03772 static int G__G__Geom2_180_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03773 {
03774 G__letint(result7, 67, (long) TGeoPatternTrapZ::ImplFileName());
03775 return(1 || funcname || hash || result7 || libp) ;
03776 }
03777
03778 static int G__G__Geom2_180_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03779 {
03780 G__letint(result7, 105, (long) TGeoPatternTrapZ::DeclFileLine());
03781 return(1 || funcname || hash || result7 || libp) ;
03782 }
03783
03784
03785 static int G__G__Geom2_180_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03786
03787 {
03788 TGeoPatternTrapZ* p;
03789 void* tmp = (void*) G__int(libp->para[0]);
03790 p = new TGeoPatternTrapZ(*(TGeoPatternTrapZ*) tmp);
03791 result7->obj.i = (long) p;
03792 result7->ref = (long) p;
03793 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ));
03794 return(1 || funcname || hash || result7 || libp) ;
03795 }
03796
03797
03798 typedef TGeoPatternTrapZ G__TTGeoPatternTrapZ;
03799 static int G__G__Geom2_180_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03800 {
03801 char* gvp = (char*) G__getgvp();
03802 long soff = G__getstructoffset();
03803 int n = G__getaryconstruct();
03804
03805
03806
03807
03808
03809 if (!soff) {
03810 return(1);
03811 }
03812 if (n) {
03813 if (gvp == (char*)G__PVOID) {
03814 delete[] (TGeoPatternTrapZ*) soff;
03815 } else {
03816 G__setgvp((long) G__PVOID);
03817 for (int i = n - 1; i >= 0; --i) {
03818 ((TGeoPatternTrapZ*) (soff+(sizeof(TGeoPatternTrapZ)*i)))->~G__TTGeoPatternTrapZ();
03819 }
03820 G__setgvp((long)gvp);
03821 }
03822 } else {
03823 if (gvp == (char*)G__PVOID) {
03824 delete (TGeoPatternTrapZ*) soff;
03825 } else {
03826 G__setgvp((long) G__PVOID);
03827 ((TGeoPatternTrapZ*) (soff))->~G__TTGeoPatternTrapZ();
03828 G__setgvp((long)gvp);
03829 }
03830 }
03831 G__setnull(result7);
03832 return(1 || funcname || hash || result7 || libp) ;
03833 }
03834
03835
03836
03837 static int G__G__Geom2_181_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03838 {
03839 TGeoPatternCylR* p = NULL;
03840 char* gvp = (char*) G__getgvp();
03841 int n = G__getaryconstruct();
03842 if (n) {
03843 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03844 p = new TGeoPatternCylR[n];
03845 } else {
03846 p = new((void*) gvp) TGeoPatternCylR[n];
03847 }
03848 } else {
03849 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03850 p = new TGeoPatternCylR;
03851 } else {
03852 p = new((void*) gvp) TGeoPatternCylR;
03853 }
03854 }
03855 result7->obj.i = (long) p;
03856 result7->ref = (long) p;
03857 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR));
03858 return(1 || funcname || hash || result7 || libp) ;
03859 }
03860
03861 static int G__G__Geom2_181_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03862 {
03863 TGeoPatternCylR* p = NULL;
03864 char* gvp = (char*) G__getgvp();
03865
03866 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03867 p = new TGeoPatternCylR((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03868 } else {
03869 p = new((void*) gvp) TGeoPatternCylR((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
03870 }
03871 result7->obj.i = (long) p;
03872 result7->ref = (long) p;
03873 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR));
03874 return(1 || funcname || hash || result7 || libp) ;
03875 }
03876
03877 static int G__G__Geom2_181_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03878 {
03879 TGeoPatternCylR* p = NULL;
03880 char* gvp = (char*) G__getgvp();
03881
03882 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03883 p = new TGeoPatternCylR(
03884 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03885 , (Double_t) G__double(libp->para[2]));
03886 } else {
03887 p = new((void*) gvp) TGeoPatternCylR(
03888 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03889 , (Double_t) G__double(libp->para[2]));
03890 }
03891 result7->obj.i = (long) p;
03892 result7->ref = (long) p;
03893 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR));
03894 return(1 || funcname || hash || result7 || libp) ;
03895 }
03896
03897 static int G__G__Geom2_181_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03898 {
03899 TGeoPatternCylR* p = NULL;
03900 char* gvp = (char*) G__getgvp();
03901
03902 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03903 p = new TGeoPatternCylR(
03904 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03905 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03906 } else {
03907 p = new((void*) gvp) TGeoPatternCylR(
03908 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03909 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
03910 }
03911 result7->obj.i = (long) p;
03912 result7->ref = (long) p;
03913 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR));
03914 return(1 || funcname || hash || result7 || libp) ;
03915 }
03916
03917 static int G__G__Geom2_181_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03918 {
03919 G__letint(result7, 85, (long) TGeoPatternCylR::Class());
03920 return(1 || funcname || hash || result7 || libp) ;
03921 }
03922
03923 static int G__G__Geom2_181_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03924 {
03925 G__letint(result7, 67, (long) TGeoPatternCylR::Class_Name());
03926 return(1 || funcname || hash || result7 || libp) ;
03927 }
03928
03929 static int G__G__Geom2_181_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03930 {
03931 G__letint(result7, 115, (long) TGeoPatternCylR::Class_Version());
03932 return(1 || funcname || hash || result7 || libp) ;
03933 }
03934
03935 static int G__G__Geom2_181_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03936 {
03937 TGeoPatternCylR::Dictionary();
03938 G__setnull(result7);
03939 return(1 || funcname || hash || result7 || libp) ;
03940 }
03941
03942 static int G__G__Geom2_181_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03943 {
03944 ((TGeoPatternCylR*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03945 G__setnull(result7);
03946 return(1 || funcname || hash || result7 || libp) ;
03947 }
03948
03949 static int G__G__Geom2_181_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03950 {
03951 G__letint(result7, 67, (long) TGeoPatternCylR::DeclFileName());
03952 return(1 || funcname || hash || result7 || libp) ;
03953 }
03954
03955 static int G__G__Geom2_181_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03956 {
03957 G__letint(result7, 105, (long) TGeoPatternCylR::ImplFileLine());
03958 return(1 || funcname || hash || result7 || libp) ;
03959 }
03960
03961 static int G__G__Geom2_181_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03962 {
03963 G__letint(result7, 67, (long) TGeoPatternCylR::ImplFileName());
03964 return(1 || funcname || hash || result7 || libp) ;
03965 }
03966
03967 static int G__G__Geom2_181_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03968 {
03969 G__letint(result7, 105, (long) TGeoPatternCylR::DeclFileLine());
03970 return(1 || funcname || hash || result7 || libp) ;
03971 }
03972
03973
03974 static int G__G__Geom2_181_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03975
03976 {
03977 TGeoPatternCylR* p;
03978 void* tmp = (void*) G__int(libp->para[0]);
03979 p = new TGeoPatternCylR(*(TGeoPatternCylR*) tmp);
03980 result7->obj.i = (long) p;
03981 result7->ref = (long) p;
03982 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR));
03983 return(1 || funcname || hash || result7 || libp) ;
03984 }
03985
03986
03987 typedef TGeoPatternCylR G__TTGeoPatternCylR;
03988 static int G__G__Geom2_181_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03989 {
03990 char* gvp = (char*) G__getgvp();
03991 long soff = G__getstructoffset();
03992 int n = G__getaryconstruct();
03993
03994
03995
03996
03997
03998 if (!soff) {
03999 return(1);
04000 }
04001 if (n) {
04002 if (gvp == (char*)G__PVOID) {
04003 delete[] (TGeoPatternCylR*) soff;
04004 } else {
04005 G__setgvp((long) G__PVOID);
04006 for (int i = n - 1; i >= 0; --i) {
04007 ((TGeoPatternCylR*) (soff+(sizeof(TGeoPatternCylR)*i)))->~G__TTGeoPatternCylR();
04008 }
04009 G__setgvp((long)gvp);
04010 }
04011 } else {
04012 if (gvp == (char*)G__PVOID) {
04013 delete (TGeoPatternCylR*) soff;
04014 } else {
04015 G__setgvp((long) G__PVOID);
04016 ((TGeoPatternCylR*) (soff))->~G__TTGeoPatternCylR();
04017 G__setgvp((long)gvp);
04018 }
04019 }
04020 G__setnull(result7);
04021 return(1 || funcname || hash || result7 || libp) ;
04022 }
04023
04024
04025
04026 static int G__G__Geom2_182_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04027 {
04028 TGeoPatternCylPhi* p = NULL;
04029 char* gvp = (char*) G__getgvp();
04030 int n = G__getaryconstruct();
04031 if (n) {
04032 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04033 p = new TGeoPatternCylPhi[n];
04034 } else {
04035 p = new((void*) gvp) TGeoPatternCylPhi[n];
04036 }
04037 } else {
04038 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04039 p = new TGeoPatternCylPhi;
04040 } else {
04041 p = new((void*) gvp) TGeoPatternCylPhi;
04042 }
04043 }
04044 result7->obj.i = (long) p;
04045 result7->ref = (long) p;
04046 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi));
04047 return(1 || funcname || hash || result7 || libp) ;
04048 }
04049
04050 static int G__G__Geom2_182_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04051 {
04052 TGeoPatternCylPhi* p = NULL;
04053 char* gvp = (char*) G__getgvp();
04054
04055 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04056 p = new TGeoPatternCylPhi((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04057 } else {
04058 p = new((void*) gvp) TGeoPatternCylPhi((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04059 }
04060 result7->obj.i = (long) p;
04061 result7->ref = (long) p;
04062 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi));
04063 return(1 || funcname || hash || result7 || libp) ;
04064 }
04065
04066 static int G__G__Geom2_182_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04067 {
04068 TGeoPatternCylPhi* p = NULL;
04069 char* gvp = (char*) G__getgvp();
04070
04071 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04072 p = new TGeoPatternCylPhi(
04073 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04074 , (Double_t) G__double(libp->para[2]));
04075 } else {
04076 p = new((void*) gvp) TGeoPatternCylPhi(
04077 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04078 , (Double_t) G__double(libp->para[2]));
04079 }
04080 result7->obj.i = (long) p;
04081 result7->ref = (long) p;
04082 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi));
04083 return(1 || funcname || hash || result7 || libp) ;
04084 }
04085
04086 static int G__G__Geom2_182_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04087 {
04088 TGeoPatternCylPhi* p = NULL;
04089 char* gvp = (char*) G__getgvp();
04090
04091 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04092 p = new TGeoPatternCylPhi(
04093 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04094 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
04095 } else {
04096 p = new((void*) gvp) TGeoPatternCylPhi(
04097 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04098 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
04099 }
04100 result7->obj.i = (long) p;
04101 result7->ref = (long) p;
04102 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi));
04103 return(1 || funcname || hash || result7 || libp) ;
04104 }
04105
04106 static int G__G__Geom2_182_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04107 {
04108 G__letint(result7, 85, (long) TGeoPatternCylPhi::Class());
04109 return(1 || funcname || hash || result7 || libp) ;
04110 }
04111
04112 static int G__G__Geom2_182_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04113 {
04114 G__letint(result7, 67, (long) TGeoPatternCylPhi::Class_Name());
04115 return(1 || funcname || hash || result7 || libp) ;
04116 }
04117
04118 static int G__G__Geom2_182_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04119 {
04120 G__letint(result7, 115, (long) TGeoPatternCylPhi::Class_Version());
04121 return(1 || funcname || hash || result7 || libp) ;
04122 }
04123
04124 static int G__G__Geom2_182_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04125 {
04126 TGeoPatternCylPhi::Dictionary();
04127 G__setnull(result7);
04128 return(1 || funcname || hash || result7 || libp) ;
04129 }
04130
04131 static int G__G__Geom2_182_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04132 {
04133 ((TGeoPatternCylPhi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04134 G__setnull(result7);
04135 return(1 || funcname || hash || result7 || libp) ;
04136 }
04137
04138 static int G__G__Geom2_182_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04139 {
04140 G__letint(result7, 67, (long) TGeoPatternCylPhi::DeclFileName());
04141 return(1 || funcname || hash || result7 || libp) ;
04142 }
04143
04144 static int G__G__Geom2_182_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04145 {
04146 G__letint(result7, 105, (long) TGeoPatternCylPhi::ImplFileLine());
04147 return(1 || funcname || hash || result7 || libp) ;
04148 }
04149
04150 static int G__G__Geom2_182_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04151 {
04152 G__letint(result7, 67, (long) TGeoPatternCylPhi::ImplFileName());
04153 return(1 || funcname || hash || result7 || libp) ;
04154 }
04155
04156 static int G__G__Geom2_182_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04157 {
04158 G__letint(result7, 105, (long) TGeoPatternCylPhi::DeclFileLine());
04159 return(1 || funcname || hash || result7 || libp) ;
04160 }
04161
04162
04163 typedef TGeoPatternCylPhi G__TTGeoPatternCylPhi;
04164 static int G__G__Geom2_182_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04165 {
04166 char* gvp = (char*) G__getgvp();
04167 long soff = G__getstructoffset();
04168 int n = G__getaryconstruct();
04169
04170
04171
04172
04173
04174 if (!soff) {
04175 return(1);
04176 }
04177 if (n) {
04178 if (gvp == (char*)G__PVOID) {
04179 delete[] (TGeoPatternCylPhi*) soff;
04180 } else {
04181 G__setgvp((long) G__PVOID);
04182 for (int i = n - 1; i >= 0; --i) {
04183 ((TGeoPatternCylPhi*) (soff+(sizeof(TGeoPatternCylPhi)*i)))->~G__TTGeoPatternCylPhi();
04184 }
04185 G__setgvp((long)gvp);
04186 }
04187 } else {
04188 if (gvp == (char*)G__PVOID) {
04189 delete (TGeoPatternCylPhi*) soff;
04190 } else {
04191 G__setgvp((long) G__PVOID);
04192 ((TGeoPatternCylPhi*) (soff))->~G__TTGeoPatternCylPhi();
04193 G__setgvp((long)gvp);
04194 }
04195 }
04196 G__setnull(result7);
04197 return(1 || funcname || hash || result7 || libp) ;
04198 }
04199
04200
04201
04202 static int G__G__Geom2_183_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04203 {
04204 TGeoPatternSphR* p = NULL;
04205 char* gvp = (char*) G__getgvp();
04206 int n = G__getaryconstruct();
04207 if (n) {
04208 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04209 p = new TGeoPatternSphR[n];
04210 } else {
04211 p = new((void*) gvp) TGeoPatternSphR[n];
04212 }
04213 } else {
04214 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04215 p = new TGeoPatternSphR;
04216 } else {
04217 p = new((void*) gvp) TGeoPatternSphR;
04218 }
04219 }
04220 result7->obj.i = (long) p;
04221 result7->ref = (long) p;
04222 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR));
04223 return(1 || funcname || hash || result7 || libp) ;
04224 }
04225
04226 static int G__G__Geom2_183_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04227 {
04228 TGeoPatternSphR* p = NULL;
04229 char* gvp = (char*) G__getgvp();
04230
04231 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04232 p = new TGeoPatternSphR((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04233 } else {
04234 p = new((void*) gvp) TGeoPatternSphR((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04235 }
04236 result7->obj.i = (long) p;
04237 result7->ref = (long) p;
04238 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR));
04239 return(1 || funcname || hash || result7 || libp) ;
04240 }
04241
04242 static int G__G__Geom2_183_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04243 {
04244 TGeoPatternSphR* p = NULL;
04245 char* gvp = (char*) G__getgvp();
04246
04247 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04248 p = new TGeoPatternSphR(
04249 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04250 , (Double_t) G__double(libp->para[2]));
04251 } else {
04252 p = new((void*) gvp) TGeoPatternSphR(
04253 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04254 , (Double_t) G__double(libp->para[2]));
04255 }
04256 result7->obj.i = (long) p;
04257 result7->ref = (long) p;
04258 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR));
04259 return(1 || funcname || hash || result7 || libp) ;
04260 }
04261
04262 static int G__G__Geom2_183_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04263 {
04264 TGeoPatternSphR* p = NULL;
04265 char* gvp = (char*) G__getgvp();
04266
04267 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04268 p = new TGeoPatternSphR(
04269 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04270 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
04271 } else {
04272 p = new((void*) gvp) TGeoPatternSphR(
04273 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04274 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
04275 }
04276 result7->obj.i = (long) p;
04277 result7->ref = (long) p;
04278 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR));
04279 return(1 || funcname || hash || result7 || libp) ;
04280 }
04281
04282 static int G__G__Geom2_183_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04283 {
04284 G__letint(result7, 85, (long) TGeoPatternSphR::Class());
04285 return(1 || funcname || hash || result7 || libp) ;
04286 }
04287
04288 static int G__G__Geom2_183_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04289 {
04290 G__letint(result7, 67, (long) TGeoPatternSphR::Class_Name());
04291 return(1 || funcname || hash || result7 || libp) ;
04292 }
04293
04294 static int G__G__Geom2_183_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04295 {
04296 G__letint(result7, 115, (long) TGeoPatternSphR::Class_Version());
04297 return(1 || funcname || hash || result7 || libp) ;
04298 }
04299
04300 static int G__G__Geom2_183_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04301 {
04302 TGeoPatternSphR::Dictionary();
04303 G__setnull(result7);
04304 return(1 || funcname || hash || result7 || libp) ;
04305 }
04306
04307 static int G__G__Geom2_183_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04308 {
04309 ((TGeoPatternSphR*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04310 G__setnull(result7);
04311 return(1 || funcname || hash || result7 || libp) ;
04312 }
04313
04314 static int G__G__Geom2_183_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04315 {
04316 G__letint(result7, 67, (long) TGeoPatternSphR::DeclFileName());
04317 return(1 || funcname || hash || result7 || libp) ;
04318 }
04319
04320 static int G__G__Geom2_183_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04321 {
04322 G__letint(result7, 105, (long) TGeoPatternSphR::ImplFileLine());
04323 return(1 || funcname || hash || result7 || libp) ;
04324 }
04325
04326 static int G__G__Geom2_183_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04327 {
04328 G__letint(result7, 67, (long) TGeoPatternSphR::ImplFileName());
04329 return(1 || funcname || hash || result7 || libp) ;
04330 }
04331
04332 static int G__G__Geom2_183_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04333 {
04334 G__letint(result7, 105, (long) TGeoPatternSphR::DeclFileLine());
04335 return(1 || funcname || hash || result7 || libp) ;
04336 }
04337
04338
04339 static int G__G__Geom2_183_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04340
04341 {
04342 TGeoPatternSphR* p;
04343 void* tmp = (void*) G__int(libp->para[0]);
04344 p = new TGeoPatternSphR(*(TGeoPatternSphR*) tmp);
04345 result7->obj.i = (long) p;
04346 result7->ref = (long) p;
04347 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR));
04348 return(1 || funcname || hash || result7 || libp) ;
04349 }
04350
04351
04352 typedef TGeoPatternSphR G__TTGeoPatternSphR;
04353 static int G__G__Geom2_183_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04354 {
04355 char* gvp = (char*) G__getgvp();
04356 long soff = G__getstructoffset();
04357 int n = G__getaryconstruct();
04358
04359
04360
04361
04362
04363 if (!soff) {
04364 return(1);
04365 }
04366 if (n) {
04367 if (gvp == (char*)G__PVOID) {
04368 delete[] (TGeoPatternSphR*) soff;
04369 } else {
04370 G__setgvp((long) G__PVOID);
04371 for (int i = n - 1; i >= 0; --i) {
04372 ((TGeoPatternSphR*) (soff+(sizeof(TGeoPatternSphR)*i)))->~G__TTGeoPatternSphR();
04373 }
04374 G__setgvp((long)gvp);
04375 }
04376 } else {
04377 if (gvp == (char*)G__PVOID) {
04378 delete (TGeoPatternSphR*) soff;
04379 } else {
04380 G__setgvp((long) G__PVOID);
04381 ((TGeoPatternSphR*) (soff))->~G__TTGeoPatternSphR();
04382 G__setgvp((long)gvp);
04383 }
04384 }
04385 G__setnull(result7);
04386 return(1 || funcname || hash || result7 || libp) ;
04387 }
04388
04389
04390
04391 static int G__G__Geom2_184_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04392 {
04393 TGeoPatternSphTheta* p = NULL;
04394 char* gvp = (char*) G__getgvp();
04395 int n = G__getaryconstruct();
04396 if (n) {
04397 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04398 p = new TGeoPatternSphTheta[n];
04399 } else {
04400 p = new((void*) gvp) TGeoPatternSphTheta[n];
04401 }
04402 } else {
04403 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04404 p = new TGeoPatternSphTheta;
04405 } else {
04406 p = new((void*) gvp) TGeoPatternSphTheta;
04407 }
04408 }
04409 result7->obj.i = (long) p;
04410 result7->ref = (long) p;
04411 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta));
04412 return(1 || funcname || hash || result7 || libp) ;
04413 }
04414
04415 static int G__G__Geom2_184_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04416 {
04417 TGeoPatternSphTheta* p = NULL;
04418 char* gvp = (char*) G__getgvp();
04419
04420 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04421 p = new TGeoPatternSphTheta((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04422 } else {
04423 p = new((void*) gvp) TGeoPatternSphTheta((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04424 }
04425 result7->obj.i = (long) p;
04426 result7->ref = (long) p;
04427 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta));
04428 return(1 || funcname || hash || result7 || libp) ;
04429 }
04430
04431 static int G__G__Geom2_184_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04432 {
04433 TGeoPatternSphTheta* p = NULL;
04434 char* gvp = (char*) G__getgvp();
04435
04436 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04437 p = new TGeoPatternSphTheta(
04438 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04439 , (Double_t) G__double(libp->para[2]));
04440 } else {
04441 p = new((void*) gvp) TGeoPatternSphTheta(
04442 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04443 , (Double_t) G__double(libp->para[2]));
04444 }
04445 result7->obj.i = (long) p;
04446 result7->ref = (long) p;
04447 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta));
04448 return(1 || funcname || hash || result7 || libp) ;
04449 }
04450
04451 static int G__G__Geom2_184_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04452 {
04453 TGeoPatternSphTheta* p = NULL;
04454 char* gvp = (char*) G__getgvp();
04455
04456 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04457 p = new TGeoPatternSphTheta(
04458 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04459 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
04460 } else {
04461 p = new((void*) gvp) TGeoPatternSphTheta(
04462 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04463 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
04464 }
04465 result7->obj.i = (long) p;
04466 result7->ref = (long) p;
04467 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta));
04468 return(1 || funcname || hash || result7 || libp) ;
04469 }
04470
04471 static int G__G__Geom2_184_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04472 {
04473 G__letint(result7, 85, (long) TGeoPatternSphTheta::Class());
04474 return(1 || funcname || hash || result7 || libp) ;
04475 }
04476
04477 static int G__G__Geom2_184_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04478 {
04479 G__letint(result7, 67, (long) TGeoPatternSphTheta::Class_Name());
04480 return(1 || funcname || hash || result7 || libp) ;
04481 }
04482
04483 static int G__G__Geom2_184_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04484 {
04485 G__letint(result7, 115, (long) TGeoPatternSphTheta::Class_Version());
04486 return(1 || funcname || hash || result7 || libp) ;
04487 }
04488
04489 static int G__G__Geom2_184_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04490 {
04491 TGeoPatternSphTheta::Dictionary();
04492 G__setnull(result7);
04493 return(1 || funcname || hash || result7 || libp) ;
04494 }
04495
04496 static int G__G__Geom2_184_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04497 {
04498 ((TGeoPatternSphTheta*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04499 G__setnull(result7);
04500 return(1 || funcname || hash || result7 || libp) ;
04501 }
04502
04503 static int G__G__Geom2_184_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04504 {
04505 G__letint(result7, 67, (long) TGeoPatternSphTheta::DeclFileName());
04506 return(1 || funcname || hash || result7 || libp) ;
04507 }
04508
04509 static int G__G__Geom2_184_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04510 {
04511 G__letint(result7, 105, (long) TGeoPatternSphTheta::ImplFileLine());
04512 return(1 || funcname || hash || result7 || libp) ;
04513 }
04514
04515 static int G__G__Geom2_184_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04516 {
04517 G__letint(result7, 67, (long) TGeoPatternSphTheta::ImplFileName());
04518 return(1 || funcname || hash || result7 || libp) ;
04519 }
04520
04521 static int G__G__Geom2_184_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04522 {
04523 G__letint(result7, 105, (long) TGeoPatternSphTheta::DeclFileLine());
04524 return(1 || funcname || hash || result7 || libp) ;
04525 }
04526
04527
04528 static int G__G__Geom2_184_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04529
04530 {
04531 TGeoPatternSphTheta* p;
04532 void* tmp = (void*) G__int(libp->para[0]);
04533 p = new TGeoPatternSphTheta(*(TGeoPatternSphTheta*) tmp);
04534 result7->obj.i = (long) p;
04535 result7->ref = (long) p;
04536 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta));
04537 return(1 || funcname || hash || result7 || libp) ;
04538 }
04539
04540
04541 typedef TGeoPatternSphTheta G__TTGeoPatternSphTheta;
04542 static int G__G__Geom2_184_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04543 {
04544 char* gvp = (char*) G__getgvp();
04545 long soff = G__getstructoffset();
04546 int n = G__getaryconstruct();
04547
04548
04549
04550
04551
04552 if (!soff) {
04553 return(1);
04554 }
04555 if (n) {
04556 if (gvp == (char*)G__PVOID) {
04557 delete[] (TGeoPatternSphTheta*) soff;
04558 } else {
04559 G__setgvp((long) G__PVOID);
04560 for (int i = n - 1; i >= 0; --i) {
04561 ((TGeoPatternSphTheta*) (soff+(sizeof(TGeoPatternSphTheta)*i)))->~G__TTGeoPatternSphTheta();
04562 }
04563 G__setgvp((long)gvp);
04564 }
04565 } else {
04566 if (gvp == (char*)G__PVOID) {
04567 delete (TGeoPatternSphTheta*) soff;
04568 } else {
04569 G__setgvp((long) G__PVOID);
04570 ((TGeoPatternSphTheta*) (soff))->~G__TTGeoPatternSphTheta();
04571 G__setgvp((long)gvp);
04572 }
04573 }
04574 G__setnull(result7);
04575 return(1 || funcname || hash || result7 || libp) ;
04576 }
04577
04578
04579
04580 static int G__G__Geom2_185_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04581 {
04582 TGeoPatternSphPhi* p = NULL;
04583 char* gvp = (char*) G__getgvp();
04584 int n = G__getaryconstruct();
04585 if (n) {
04586 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04587 p = new TGeoPatternSphPhi[n];
04588 } else {
04589 p = new((void*) gvp) TGeoPatternSphPhi[n];
04590 }
04591 } else {
04592 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04593 p = new TGeoPatternSphPhi;
04594 } else {
04595 p = new((void*) gvp) TGeoPatternSphPhi;
04596 }
04597 }
04598 result7->obj.i = (long) p;
04599 result7->ref = (long) p;
04600 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi));
04601 return(1 || funcname || hash || result7 || libp) ;
04602 }
04603
04604 static int G__G__Geom2_185_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04605 {
04606 TGeoPatternSphPhi* p = NULL;
04607 char* gvp = (char*) G__getgvp();
04608
04609 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04610 p = new TGeoPatternSphPhi((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04611 } else {
04612 p = new((void*) gvp) TGeoPatternSphPhi((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04613 }
04614 result7->obj.i = (long) p;
04615 result7->ref = (long) p;
04616 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi));
04617 return(1 || funcname || hash || result7 || libp) ;
04618 }
04619
04620 static int G__G__Geom2_185_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04621 {
04622 TGeoPatternSphPhi* p = NULL;
04623 char* gvp = (char*) G__getgvp();
04624
04625 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04626 p = new TGeoPatternSphPhi(
04627 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04628 , (Double_t) G__double(libp->para[2]));
04629 } else {
04630 p = new((void*) gvp) TGeoPatternSphPhi(
04631 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04632 , (Double_t) G__double(libp->para[2]));
04633 }
04634 result7->obj.i = (long) p;
04635 result7->ref = (long) p;
04636 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi));
04637 return(1 || funcname || hash || result7 || libp) ;
04638 }
04639
04640 static int G__G__Geom2_185_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04641 {
04642 TGeoPatternSphPhi* p = NULL;
04643 char* gvp = (char*) G__getgvp();
04644
04645 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04646 p = new TGeoPatternSphPhi(
04647 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04648 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
04649 } else {
04650 p = new((void*) gvp) TGeoPatternSphPhi(
04651 (TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04652 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
04653 }
04654 result7->obj.i = (long) p;
04655 result7->ref = (long) p;
04656 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi));
04657 return(1 || funcname || hash || result7 || libp) ;
04658 }
04659
04660 static int G__G__Geom2_185_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04661 {
04662 G__letint(result7, 85, (long) TGeoPatternSphPhi::Class());
04663 return(1 || funcname || hash || result7 || libp) ;
04664 }
04665
04666 static int G__G__Geom2_185_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04667 {
04668 G__letint(result7, 67, (long) TGeoPatternSphPhi::Class_Name());
04669 return(1 || funcname || hash || result7 || libp) ;
04670 }
04671
04672 static int G__G__Geom2_185_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04673 {
04674 G__letint(result7, 115, (long) TGeoPatternSphPhi::Class_Version());
04675 return(1 || funcname || hash || result7 || libp) ;
04676 }
04677
04678 static int G__G__Geom2_185_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04679 {
04680 TGeoPatternSphPhi::Dictionary();
04681 G__setnull(result7);
04682 return(1 || funcname || hash || result7 || libp) ;
04683 }
04684
04685 static int G__G__Geom2_185_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04686 {
04687 ((TGeoPatternSphPhi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04688 G__setnull(result7);
04689 return(1 || funcname || hash || result7 || libp) ;
04690 }
04691
04692 static int G__G__Geom2_185_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04693 {
04694 G__letint(result7, 67, (long) TGeoPatternSphPhi::DeclFileName());
04695 return(1 || funcname || hash || result7 || libp) ;
04696 }
04697
04698 static int G__G__Geom2_185_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04699 {
04700 G__letint(result7, 105, (long) TGeoPatternSphPhi::ImplFileLine());
04701 return(1 || funcname || hash || result7 || libp) ;
04702 }
04703
04704 static int G__G__Geom2_185_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04705 {
04706 G__letint(result7, 67, (long) TGeoPatternSphPhi::ImplFileName());
04707 return(1 || funcname || hash || result7 || libp) ;
04708 }
04709
04710 static int G__G__Geom2_185_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04711 {
04712 G__letint(result7, 105, (long) TGeoPatternSphPhi::DeclFileLine());
04713 return(1 || funcname || hash || result7 || libp) ;
04714 }
04715
04716
04717 static int G__G__Geom2_185_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04718
04719 {
04720 TGeoPatternSphPhi* p;
04721 void* tmp = (void*) G__int(libp->para[0]);
04722 p = new TGeoPatternSphPhi(*(TGeoPatternSphPhi*) tmp);
04723 result7->obj.i = (long) p;
04724 result7->ref = (long) p;
04725 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi));
04726 return(1 || funcname || hash || result7 || libp) ;
04727 }
04728
04729
04730 typedef TGeoPatternSphPhi G__TTGeoPatternSphPhi;
04731 static int G__G__Geom2_185_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04732 {
04733 char* gvp = (char*) G__getgvp();
04734 long soff = G__getstructoffset();
04735 int n = G__getaryconstruct();
04736
04737
04738
04739
04740
04741 if (!soff) {
04742 return(1);
04743 }
04744 if (n) {
04745 if (gvp == (char*)G__PVOID) {
04746 delete[] (TGeoPatternSphPhi*) soff;
04747 } else {
04748 G__setgvp((long) G__PVOID);
04749 for (int i = n - 1; i >= 0; --i) {
04750 ((TGeoPatternSphPhi*) (soff+(sizeof(TGeoPatternSphPhi)*i)))->~G__TTGeoPatternSphPhi();
04751 }
04752 G__setgvp((long)gvp);
04753 }
04754 } else {
04755 if (gvp == (char*)G__PVOID) {
04756 delete (TGeoPatternSphPhi*) soff;
04757 } else {
04758 G__setgvp((long) G__PVOID);
04759 ((TGeoPatternSphPhi*) (soff))->~G__TTGeoPatternSphPhi();
04760 G__setgvp((long)gvp);
04761 }
04762 }
04763 G__setnull(result7);
04764 return(1 || funcname || hash || result7 || libp) ;
04765 }
04766
04767
04768
04769 static int G__G__Geom2_186_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04770 {
04771 TGeoPatternHoneycomb* p = NULL;
04772 char* gvp = (char*) G__getgvp();
04773 int n = G__getaryconstruct();
04774 if (n) {
04775 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04776 p = new TGeoPatternHoneycomb[n];
04777 } else {
04778 p = new((void*) gvp) TGeoPatternHoneycomb[n];
04779 }
04780 } else {
04781 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04782 p = new TGeoPatternHoneycomb;
04783 } else {
04784 p = new((void*) gvp) TGeoPatternHoneycomb;
04785 }
04786 }
04787 result7->obj.i = (long) p;
04788 result7->ref = (long) p;
04789 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb));
04790 return(1 || funcname || hash || result7 || libp) ;
04791 }
04792
04793 static int G__G__Geom2_186_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04794 {
04795 TGeoPatternHoneycomb* p = NULL;
04796 char* gvp = (char*) G__getgvp();
04797
04798 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04799 p = new TGeoPatternHoneycomb((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04800 } else {
04801 p = new((void*) gvp) TGeoPatternHoneycomb((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04802 }
04803 result7->obj.i = (long) p;
04804 result7->ref = (long) p;
04805 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb));
04806 return(1 || funcname || hash || result7 || libp) ;
04807 }
04808
04809 static int G__G__Geom2_186_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04810 {
04811 G__letint(result7, 85, (long) TGeoPatternHoneycomb::Class());
04812 return(1 || funcname || hash || result7 || libp) ;
04813 }
04814
04815 static int G__G__Geom2_186_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04816 {
04817 G__letint(result7, 67, (long) TGeoPatternHoneycomb::Class_Name());
04818 return(1 || funcname || hash || result7 || libp) ;
04819 }
04820
04821 static int G__G__Geom2_186_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04822 {
04823 G__letint(result7, 115, (long) TGeoPatternHoneycomb::Class_Version());
04824 return(1 || funcname || hash || result7 || libp) ;
04825 }
04826
04827 static int G__G__Geom2_186_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04828 {
04829 TGeoPatternHoneycomb::Dictionary();
04830 G__setnull(result7);
04831 return(1 || funcname || hash || result7 || libp) ;
04832 }
04833
04834 static int G__G__Geom2_186_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04835 {
04836 ((TGeoPatternHoneycomb*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04837 G__setnull(result7);
04838 return(1 || funcname || hash || result7 || libp) ;
04839 }
04840
04841 static int G__G__Geom2_186_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04842 {
04843 G__letint(result7, 67, (long) TGeoPatternHoneycomb::DeclFileName());
04844 return(1 || funcname || hash || result7 || libp) ;
04845 }
04846
04847 static int G__G__Geom2_186_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04848 {
04849 G__letint(result7, 105, (long) TGeoPatternHoneycomb::ImplFileLine());
04850 return(1 || funcname || hash || result7 || libp) ;
04851 }
04852
04853 static int G__G__Geom2_186_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04854 {
04855 G__letint(result7, 67, (long) TGeoPatternHoneycomb::ImplFileName());
04856 return(1 || funcname || hash || result7 || libp) ;
04857 }
04858
04859 static int G__G__Geom2_186_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04860 {
04861 G__letint(result7, 105, (long) TGeoPatternHoneycomb::DeclFileLine());
04862 return(1 || funcname || hash || result7 || libp) ;
04863 }
04864
04865
04866 typedef TGeoPatternHoneycomb G__TTGeoPatternHoneycomb;
04867 static int G__G__Geom2_186_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04868 {
04869 char* gvp = (char*) G__getgvp();
04870 long soff = G__getstructoffset();
04871 int n = G__getaryconstruct();
04872
04873
04874
04875
04876
04877 if (!soff) {
04878 return(1);
04879 }
04880 if (n) {
04881 if (gvp == (char*)G__PVOID) {
04882 delete[] (TGeoPatternHoneycomb*) soff;
04883 } else {
04884 G__setgvp((long) G__PVOID);
04885 for (int i = n - 1; i >= 0; --i) {
04886 ((TGeoPatternHoneycomb*) (soff+(sizeof(TGeoPatternHoneycomb)*i)))->~G__TTGeoPatternHoneycomb();
04887 }
04888 G__setgvp((long)gvp);
04889 }
04890 } else {
04891 if (gvp == (char*)G__PVOID) {
04892 delete (TGeoPatternHoneycomb*) soff;
04893 } else {
04894 G__setgvp((long) G__PVOID);
04895 ((TGeoPatternHoneycomb*) (soff))->~G__TTGeoPatternHoneycomb();
04896 G__setgvp((long)gvp);
04897 }
04898 }
04899 G__setnull(result7);
04900 return(1 || funcname || hash || result7 || libp) ;
04901 }
04902
04903
04904
04905 static int G__G__Geom2_192_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04906 {
04907 TGeoCacheState* p = NULL;
04908 char* gvp = (char*) G__getgvp();
04909 int n = G__getaryconstruct();
04910 if (n) {
04911 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04912 p = new TGeoCacheState[n];
04913 } else {
04914 p = new((void*) gvp) TGeoCacheState[n];
04915 }
04916 } else {
04917 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04918 p = new TGeoCacheState;
04919 } else {
04920 p = new((void*) gvp) TGeoCacheState;
04921 }
04922 }
04923 result7->obj.i = (long) p;
04924 result7->ref = (long) p;
04925 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState));
04926 return(1 || funcname || hash || result7 || libp) ;
04927 }
04928
04929 static int G__G__Geom2_192_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04930 {
04931 TGeoCacheState* p = NULL;
04932 char* gvp = (char*) G__getgvp();
04933
04934 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04935 p = new TGeoCacheState((Int_t) G__int(libp->para[0]));
04936 } else {
04937 p = new((void*) gvp) TGeoCacheState((Int_t) G__int(libp->para[0]));
04938 }
04939 result7->obj.i = (long) p;
04940 result7->ref = (long) p;
04941 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState));
04942 return(1 || funcname || hash || result7 || libp) ;
04943 }
04944
04945 static int G__G__Geom2_192_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04946 {
04947 switch (libp->paran) {
04948 case 5:
04949 ((TGeoCacheState*) G__getstructoffset())->SetState((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04950 , (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
04951 , (Double_t*) G__int(libp->para[4]));
04952 G__setnull(result7);
04953 break;
04954 case 4:
04955 ((TGeoCacheState*) G__getstructoffset())->SetState((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04956 , (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
04957 G__setnull(result7);
04958 break;
04959 }
04960 return(1 || funcname || hash || result7 || libp) ;
04961 }
04962
04963 static int G__G__Geom2_192_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04964 {
04965 G__letint(result7, 103, (long) ((const TGeoCacheState*) G__getstructoffset())->GetState(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
04966 , (Double_t*) G__int(libp->para[2])));
04967 return(1 || funcname || hash || result7 || libp) ;
04968 }
04969
04970 static int G__G__Geom2_192_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04971 {
04972 G__letint(result7, 85, (long) TGeoCacheState::Class());
04973 return(1 || funcname || hash || result7 || libp) ;
04974 }
04975
04976 static int G__G__Geom2_192_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04977 {
04978 G__letint(result7, 67, (long) TGeoCacheState::Class_Name());
04979 return(1 || funcname || hash || result7 || libp) ;
04980 }
04981
04982 static int G__G__Geom2_192_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04983 {
04984 G__letint(result7, 115, (long) TGeoCacheState::Class_Version());
04985 return(1 || funcname || hash || result7 || libp) ;
04986 }
04987
04988 static int G__G__Geom2_192_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04989 {
04990 TGeoCacheState::Dictionary();
04991 G__setnull(result7);
04992 return(1 || funcname || hash || result7 || libp) ;
04993 }
04994
04995 static int G__G__Geom2_192_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04996 {
04997 ((TGeoCacheState*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04998 G__setnull(result7);
04999 return(1 || funcname || hash || result7 || libp) ;
05000 }
05001
05002 static int G__G__Geom2_192_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05003 {
05004 G__letint(result7, 67, (long) TGeoCacheState::DeclFileName());
05005 return(1 || funcname || hash || result7 || libp) ;
05006 }
05007
05008 static int G__G__Geom2_192_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05009 {
05010 G__letint(result7, 105, (long) TGeoCacheState::ImplFileLine());
05011 return(1 || funcname || hash || result7 || libp) ;
05012 }
05013
05014 static int G__G__Geom2_192_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05015 {
05016 G__letint(result7, 67, (long) TGeoCacheState::ImplFileName());
05017 return(1 || funcname || hash || result7 || libp) ;
05018 }
05019
05020 static int G__G__Geom2_192_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05021 {
05022 G__letint(result7, 105, (long) TGeoCacheState::DeclFileLine());
05023 return(1 || funcname || hash || result7 || libp) ;
05024 }
05025
05026
05027 typedef TGeoCacheState G__TTGeoCacheState;
05028 static int G__G__Geom2_192_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05029 {
05030 char* gvp = (char*) G__getgvp();
05031 long soff = G__getstructoffset();
05032 int n = G__getaryconstruct();
05033
05034
05035
05036
05037
05038 if (!soff) {
05039 return(1);
05040 }
05041 if (n) {
05042 if (gvp == (char*)G__PVOID) {
05043 delete[] (TGeoCacheState*) soff;
05044 } else {
05045 G__setgvp((long) G__PVOID);
05046 for (int i = n - 1; i >= 0; --i) {
05047 ((TGeoCacheState*) (soff+(sizeof(TGeoCacheState)*i)))->~G__TTGeoCacheState();
05048 }
05049 G__setgvp((long)gvp);
05050 }
05051 } else {
05052 if (gvp == (char*)G__PVOID) {
05053 delete (TGeoCacheState*) soff;
05054 } else {
05055 G__setgvp((long) G__PVOID);
05056 ((TGeoCacheState*) (soff))->~G__TTGeoCacheState();
05057 G__setgvp((long)gvp);
05058 }
05059 }
05060 G__setnull(result7);
05061 return(1 || funcname || hash || result7 || libp) ;
05062 }
05063
05064
05065
05066 static int G__G__Geom2_193_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05067 {
05068 TGeoNodeCache* p = NULL;
05069 char* gvp = (char*) G__getgvp();
05070 int n = G__getaryconstruct();
05071 if (n) {
05072 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05073 p = new TGeoNodeCache[n];
05074 } else {
05075 p = new((void*) gvp) TGeoNodeCache[n];
05076 }
05077 } else {
05078 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05079 p = new TGeoNodeCache;
05080 } else {
05081 p = new((void*) gvp) TGeoNodeCache;
05082 }
05083 }
05084 result7->obj.i = (long) p;
05085 result7->ref = (long) p;
05086 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache));
05087 return(1 || funcname || hash || result7 || libp) ;
05088 }
05089
05090 static int G__G__Geom2_193_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05091 {
05092 TGeoNodeCache* p = NULL;
05093 char* gvp = (char*) G__getgvp();
05094 switch (libp->paran) {
05095 case 3:
05096
05097 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05098 p = new TGeoNodeCache(
05099 (TGeoNode*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05100 , (Int_t) G__int(libp->para[2]));
05101 } else {
05102 p = new((void*) gvp) TGeoNodeCache(
05103 (TGeoNode*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
05104 , (Int_t) G__int(libp->para[2]));
05105 }
05106 break;
05107 case 2:
05108
05109 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05110 p = new TGeoNodeCache((TGeoNode*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05111 } else {
05112 p = new((void*) gvp) TGeoNodeCache((TGeoNode*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05113 }
05114 break;
05115 case 1:
05116
05117 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05118 p = new TGeoNodeCache((TGeoNode*) G__int(libp->para[0]));
05119 } else {
05120 p = new((void*) gvp) TGeoNodeCache((TGeoNode*) G__int(libp->para[0]));
05121 }
05122 break;
05123 }
05124 result7->obj.i = (long) p;
05125 result7->ref = (long) p;
05126 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache));
05127 return(1 || funcname || hash || result7 || libp) ;
05128 }
05129
05130 static int G__G__Geom2_193_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05131 {
05132 ((TGeoNodeCache*) G__getstructoffset())->BuildIdArray();
05133 G__setnull(result7);
05134 return(1 || funcname || hash || result7 || libp) ;
05135 }
05136
05137 static int G__G__Geom2_193_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05138 {
05139 ((TGeoNodeCache*) G__getstructoffset())->CdNode((Int_t) G__int(libp->para[0]));
05140 G__setnull(result7);
05141 return(1 || funcname || hash || result7 || libp) ;
05142 }
05143
05144 static int G__G__Geom2_193_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05145 {
05146 G__letint(result7, 103, (long) ((TGeoNodeCache*) G__getstructoffset())->CdDown((Int_t) G__int(libp->para[0])));
05147 return(1 || funcname || hash || result7 || libp) ;
05148 }
05149
05150 static int G__G__Geom2_193_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05151 {
05152 ((TGeoNodeCache*) G__getstructoffset())->CdTop();
05153 G__setnull(result7);
05154 return(1 || funcname || hash || result7 || libp) ;
05155 }
05156
05157 static int G__G__Geom2_193_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05158 {
05159 ((TGeoNodeCache*) G__getstructoffset())->CdUp();
05160 G__setnull(result7);
05161 return(1 || funcname || hash || result7 || libp) ;
05162 }
05163
05164 static int G__G__Geom2_193_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05165 {
05166 switch (libp->paran) {
05167 case 2:
05168 ((TGeoNodeCache*) G__getstructoffset())->FillIdBranch((const Int_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05169 G__setnull(result7);
05170 break;
05171 case 1:
05172 ((TGeoNodeCache*) G__getstructoffset())->FillIdBranch((const Int_t*) G__int(libp->para[0]));
05173 G__setnull(result7);
05174 break;
05175 }
05176 return(1 || funcname || hash || result7 || libp) ;
05177 }
05178
05179 static int G__G__Geom2_193_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05180 {
05181 G__letint(result7, 73, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetIdBranch());
05182 return(1 || funcname || hash || result7 || libp) ;
05183 }
05184
05185 static int G__G__Geom2_193_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05186 {
05187 G__letint(result7, 89, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetBranch());
05188 return(1 || funcname || hash || result7 || libp) ;
05189 }
05190
05191 static int G__G__Geom2_193_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05192 {
05193 ((const TGeoNodeCache*) G__getstructoffset())->GetBranchNames((Int_t*) G__int(libp->para[0]));
05194 G__setnull(result7);
05195 return(1 || funcname || hash || result7 || libp) ;
05196 }
05197
05198 static int G__G__Geom2_193_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05199 {
05200 ((const TGeoNodeCache*) G__getstructoffset())->GetBranchNumbers((Int_t*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1]));
05201 G__setnull(result7);
05202 return(1 || funcname || hash || result7 || libp) ;
05203 }
05204
05205 static int G__G__Geom2_193_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05206 {
05207 ((const TGeoNodeCache*) G__getstructoffset())->GetBranchOnlys((Int_t*) G__int(libp->para[0]));
05208 G__setnull(result7);
05209 return(1 || funcname || hash || result7 || libp) ;
05210 }
05211
05212 static int G__G__Geom2_193_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05213 {
05214 G__letint(result7, 89, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetMatrices());
05215 return(1 || funcname || hash || result7 || libp) ;
05216 }
05217
05218 static int G__G__Geom2_193_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05219 {
05220 G__letint(result7, 85, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetCurrentMatrix());
05221 return(1 || funcname || hash || result7 || libp) ;
05222 }
05223
05224 static int G__G__Geom2_193_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05225 {
05226 G__letint(result7, 105, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetCurrentNodeId());
05227 return(1 || funcname || hash || result7 || libp) ;
05228 }
05229
05230 static int G__G__Geom2_193_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05231 {
05232 switch (libp->paran) {
05233 case 1:
05234 G__letint(result7, 85, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetMother((Int_t) G__int(libp->para[0])));
05235 break;
05236 case 0:
05237 G__letint(result7, 85, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetMother());
05238 break;
05239 }
05240 return(1 || funcname || hash || result7 || libp) ;
05241 }
05242
05243 static int G__G__Geom2_193_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05244 {
05245 switch (libp->paran) {
05246 case 1:
05247 G__letint(result7, 85, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetMotherMatrix((Int_t) G__int(libp->para[0])));
05248 break;
05249 case 0:
05250 G__letint(result7, 85, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetMotherMatrix());
05251 break;
05252 }
05253 return(1 || funcname || hash || result7 || libp) ;
05254 }
05255
05256 static int G__G__Geom2_193_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05257 {
05258 G__letint(result7, 85, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetNode());
05259 return(1 || funcname || hash || result7 || libp) ;
05260 }
05261
05262 static int G__G__Geom2_193_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05263 {
05264 G__letint(result7, 85, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetTopNode());
05265 return(1 || funcname || hash || result7 || libp) ;
05266 }
05267
05268 static int G__G__Geom2_193_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05269 {
05270 G__letint(result7, 105, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetLevel());
05271 return(1 || funcname || hash || result7 || libp) ;
05272 }
05273
05274 static int G__G__Geom2_193_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05275 {
05276 G__letint(result7, 67, (long) ((TGeoNodeCache*) G__getstructoffset())->GetPath());
05277 return(1 || funcname || hash || result7 || libp) ;
05278 }
05279
05280 static int G__G__Geom2_193_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05281 {
05282 G__letint(result7, 105, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetStackLevel());
05283 return(1 || funcname || hash || result7 || libp) ;
05284 }
05285
05286 static int G__G__Geom2_193_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05287 {
05288 G__letint(result7, 105, (long) ((const TGeoNodeCache*) G__getstructoffset())->GetNodeId());
05289 return(1 || funcname || hash || result7 || libp) ;
05290 }
05291
05292 static int G__G__Geom2_193_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05293 {
05294 G__letint(result7, 103, (long) ((const TGeoNodeCache*) G__getstructoffset())->HasIdArray());
05295 return(1 || funcname || hash || result7 || libp) ;
05296 }
05297
05298 static int G__G__Geom2_193_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05299 {
05300 G__letint(result7, 103, (long) ((const TGeoNodeCache*) G__getstructoffset())->IsDummy());
05301 return(1 || funcname || hash || result7 || libp) ;
05302 }
05303
05304 static int G__G__Geom2_193_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05305 {
05306 ((const TGeoNodeCache*) G__getstructoffset())->LocalToMaster((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
05307 G__setnull(result7);
05308 return(1 || funcname || hash || result7 || libp) ;
05309 }
05310
05311 static int G__G__Geom2_193_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05312 {
05313 ((const TGeoNodeCache*) G__getstructoffset())->MasterToLocal((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
05314 G__setnull(result7);
05315 return(1 || funcname || hash || result7 || libp) ;
05316 }
05317
05318 static int G__G__Geom2_193_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05319 {
05320 ((const TGeoNodeCache*) G__getstructoffset())->LocalToMasterVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
05321 G__setnull(result7);
05322 return(1 || funcname || hash || result7 || libp) ;
05323 }
05324
05325 static int G__G__Geom2_193_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05326 {
05327 ((const TGeoNodeCache*) G__getstructoffset())->MasterToLocalVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
05328 G__setnull(result7);
05329 return(1 || funcname || hash || result7 || libp) ;
05330 }
05331
05332 static int G__G__Geom2_193_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05333 {
05334 ((const TGeoNodeCache*) G__getstructoffset())->LocalToMasterBomb((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
05335 G__setnull(result7);
05336 return(1 || funcname || hash || result7 || libp) ;
05337 }
05338
05339 static int G__G__Geom2_193_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05340 {
05341 ((const TGeoNodeCache*) G__getstructoffset())->MasterToLocalBomb((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
05342 G__setnull(result7);
05343 return(1 || funcname || hash || result7 || libp) ;
05344 }
05345
05346 static int G__G__Geom2_193_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05347 {
05348 switch (libp->paran) {
05349 case 4:
05350 G__letint(result7, 105, (long) ((TGeoNodeCache*) G__getstructoffset())->PushState((Bool_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05351 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])));
05352 break;
05353 case 3:
05354 G__letint(result7, 105, (long) ((TGeoNodeCache*) G__getstructoffset())->PushState((Bool_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05355 , (Int_t) G__int(libp->para[2])));
05356 break;
05357 case 2:
05358 G__letint(result7, 105, (long) ((TGeoNodeCache*) G__getstructoffset())->PushState((Bool_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
05359 break;
05360 case 1:
05361 G__letint(result7, 105, (long) ((TGeoNodeCache*) G__getstructoffset())->PushState((Bool_t) G__int(libp->para[0])));
05362 break;
05363 }
05364 return(1 || funcname || hash || result7 || libp) ;
05365 }
05366
05367 static int G__G__Geom2_193_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05368 {
05369 switch (libp->paran) {
05370 case 2:
05371 G__letint(result7, 103, (long) ((TGeoNodeCache*) G__getstructoffset())->PopState(*(Int_t*) G__Intref(&libp->para[0]), (Double_t*) G__int(libp->para[1])));
05372 break;
05373 case 1:
05374 G__letint(result7, 103, (long) ((TGeoNodeCache*) G__getstructoffset())->PopState(*(Int_t*) G__Intref(&libp->para[0])));
05375 break;
05376 }
05377 return(1 || funcname || hash || result7 || libp) ;
05378 }
05379
05380 static int G__G__Geom2_193_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05381 {
05382 switch (libp->paran) {
05383 case 3:
05384 G__letint(result7, 103, (long) ((TGeoNodeCache*) G__getstructoffset())->PopState(*(Int_t*) G__Intref(&libp->para[0]), (Int_t) G__int(libp->para[1])
05385 , (Double_t*) G__int(libp->para[2])));
05386 break;
05387 case 2:
05388 G__letint(result7, 103, (long) ((TGeoNodeCache*) G__getstructoffset())->PopState(*(Int_t*) G__Intref(&libp->para[0]), (Int_t) G__int(libp->para[1])));
05389 break;
05390 }
05391 return(1 || funcname || hash || result7 || libp) ;
05392 }
05393
05394 static int G__G__Geom2_193_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05395 {
05396 switch (libp->paran) {
05397 case 1:
05398 ((TGeoNodeCache*) G__getstructoffset())->PopDummy((Int_t) G__int(libp->para[0]));
05399 G__setnull(result7);
05400 break;
05401 case 0:
05402 ((TGeoNodeCache*) G__getstructoffset())->PopDummy();
05403 G__setnull(result7);
05404 break;
05405 }
05406 return(1 || funcname || hash || result7 || libp) ;
05407 }
05408
05409 static int G__G__Geom2_193_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05410 {
05411 ((TGeoNodeCache*) G__getstructoffset())->Refresh();
05412 G__setnull(result7);
05413 return(1 || funcname || hash || result7 || libp) ;
05414 }
05415
05416 static int G__G__Geom2_193_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05417 {
05418 switch (libp->paran) {
05419 case 3:
05420 G__letint(result7, 103, (long) ((TGeoNodeCache*) G__getstructoffset())->RestoreState(*(Int_t*) G__Intref(&libp->para[0]), (TGeoCacheState*) G__int(libp->para[1])
05421 , (Double_t*) G__int(libp->para[2])));
05422 break;
05423 case 2:
05424 G__letint(result7, 103, (long) ((TGeoNodeCache*) G__getstructoffset())->RestoreState(*(Int_t*) G__Intref(&libp->para[0]), (TGeoCacheState*) G__int(libp->para[1])));
05425 break;
05426 }
05427 return(1 || funcname || hash || result7 || libp) ;
05428 }
05429
05430 static int G__G__Geom2_193_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05431 {
05432 G__letint(result7, 85, (long) TGeoNodeCache::Class());
05433 return(1 || funcname || hash || result7 || libp) ;
05434 }
05435
05436 static int G__G__Geom2_193_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05437 {
05438 G__letint(result7, 67, (long) TGeoNodeCache::Class_Name());
05439 return(1 || funcname || hash || result7 || libp) ;
05440 }
05441
05442 static int G__G__Geom2_193_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05443 {
05444 G__letint(result7, 115, (long) TGeoNodeCache::Class_Version());
05445 return(1 || funcname || hash || result7 || libp) ;
05446 }
05447
05448 static int G__G__Geom2_193_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05449 {
05450 TGeoNodeCache::Dictionary();
05451 G__setnull(result7);
05452 return(1 || funcname || hash || result7 || libp) ;
05453 }
05454
05455 static int G__G__Geom2_193_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05456 {
05457 ((TGeoNodeCache*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05458 G__setnull(result7);
05459 return(1 || funcname || hash || result7 || libp) ;
05460 }
05461
05462 static int G__G__Geom2_193_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05463 {
05464 G__letint(result7, 67, (long) TGeoNodeCache::DeclFileName());
05465 return(1 || funcname || hash || result7 || libp) ;
05466 }
05467
05468 static int G__G__Geom2_193_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05469 {
05470 G__letint(result7, 105, (long) TGeoNodeCache::ImplFileLine());
05471 return(1 || funcname || hash || result7 || libp) ;
05472 }
05473
05474 static int G__G__Geom2_193_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05475 {
05476 G__letint(result7, 67, (long) TGeoNodeCache::ImplFileName());
05477 return(1 || funcname || hash || result7 || libp) ;
05478 }
05479
05480 static int G__G__Geom2_193_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05481 {
05482 G__letint(result7, 105, (long) TGeoNodeCache::DeclFileLine());
05483 return(1 || funcname || hash || result7 || libp) ;
05484 }
05485
05486
05487 typedef TGeoNodeCache G__TTGeoNodeCache;
05488 static int G__G__Geom2_193_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05489 {
05490 char* gvp = (char*) G__getgvp();
05491 long soff = G__getstructoffset();
05492 int n = G__getaryconstruct();
05493
05494
05495
05496
05497
05498 if (!soff) {
05499 return(1);
05500 }
05501 if (n) {
05502 if (gvp == (char*)G__PVOID) {
05503 delete[] (TGeoNodeCache*) soff;
05504 } else {
05505 G__setgvp((long) G__PVOID);
05506 for (int i = n - 1; i >= 0; --i) {
05507 ((TGeoNodeCache*) (soff+(sizeof(TGeoNodeCache)*i)))->~G__TTGeoNodeCache();
05508 }
05509 G__setgvp((long)gvp);
05510 }
05511 } else {
05512 if (gvp == (char*)G__PVOID) {
05513 delete (TGeoNodeCache*) soff;
05514 } else {
05515 G__setgvp((long) G__PVOID);
05516 ((TGeoNodeCache*) (soff))->~G__TTGeoNodeCache();
05517 G__setgvp((long)gvp);
05518 }
05519 }
05520 G__setnull(result7);
05521 return(1 || funcname || hash || result7 || libp) ;
05522 }
05523
05524
05525
05526 static int G__G__Geom2_194_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05527 {
05528 ((TVirtualMagField*) G__getstructoffset())->Field((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
05529 G__setnull(result7);
05530 return(1 || funcname || hash || result7 || libp) ;
05531 }
05532
05533 static int G__G__Geom2_194_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05534 {
05535 G__letint(result7, 85, (long) TVirtualMagField::Class());
05536 return(1 || funcname || hash || result7 || libp) ;
05537 }
05538
05539 static int G__G__Geom2_194_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05540 {
05541 G__letint(result7, 67, (long) TVirtualMagField::Class_Name());
05542 return(1 || funcname || hash || result7 || libp) ;
05543 }
05544
05545 static int G__G__Geom2_194_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05546 {
05547 G__letint(result7, 115, (long) TVirtualMagField::Class_Version());
05548 return(1 || funcname || hash || result7 || libp) ;
05549 }
05550
05551 static int G__G__Geom2_194_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05552 {
05553 TVirtualMagField::Dictionary();
05554 G__setnull(result7);
05555 return(1 || funcname || hash || result7 || libp) ;
05556 }
05557
05558 static int G__G__Geom2_194_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05559 {
05560 ((TVirtualMagField*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05561 G__setnull(result7);
05562 return(1 || funcname || hash || result7 || libp) ;
05563 }
05564
05565 static int G__G__Geom2_194_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05566 {
05567 G__letint(result7, 67, (long) TVirtualMagField::DeclFileName());
05568 return(1 || funcname || hash || result7 || libp) ;
05569 }
05570
05571 static int G__G__Geom2_194_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05572 {
05573 G__letint(result7, 105, (long) TVirtualMagField::ImplFileLine());
05574 return(1 || funcname || hash || result7 || libp) ;
05575 }
05576
05577 static int G__G__Geom2_194_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05578 {
05579 G__letint(result7, 67, (long) TVirtualMagField::ImplFileName());
05580 return(1 || funcname || hash || result7 || libp) ;
05581 }
05582
05583 static int G__G__Geom2_194_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05584 {
05585 G__letint(result7, 105, (long) TVirtualMagField::DeclFileLine());
05586 return(1 || funcname || hash || result7 || libp) ;
05587 }
05588
05589
05590 typedef TVirtualMagField G__TTVirtualMagField;
05591 static int G__G__Geom2_194_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05592 {
05593 char* gvp = (char*) G__getgvp();
05594 long soff = G__getstructoffset();
05595 int n = G__getaryconstruct();
05596
05597
05598
05599
05600
05601 if (!soff) {
05602 return(1);
05603 }
05604 if (n) {
05605 if (gvp == (char*)G__PVOID) {
05606 delete[] (TVirtualMagField*) soff;
05607 } else {
05608 G__setgvp((long) G__PVOID);
05609 for (int i = n - 1; i >= 0; --i) {
05610 ((TVirtualMagField*) (soff+(sizeof(TVirtualMagField)*i)))->~G__TTVirtualMagField();
05611 }
05612 G__setgvp((long)gvp);
05613 }
05614 } else {
05615 if (gvp == (char*)G__PVOID) {
05616 delete (TVirtualMagField*) soff;
05617 } else {
05618 G__setgvp((long) G__PVOID);
05619 ((TVirtualMagField*) (soff))->~G__TTVirtualMagField();
05620 G__setgvp((long)gvp);
05621 }
05622 }
05623 G__setnull(result7);
05624 return(1 || funcname || hash || result7 || libp) ;
05625 }
05626
05627
05628 static int G__G__Geom2_194_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05629 {
05630 TVirtualMagField* dest = (TVirtualMagField*) G__getstructoffset();
05631 *dest = *(TVirtualMagField*) libp->para[0].ref;
05632 const TVirtualMagField& obj = *dest;
05633 result7->ref = (long) (&obj);
05634 result7->obj.i = (long) (&obj);
05635 return(1 || funcname || hash || result7 || libp) ;
05636 }
05637
05638
05639
05640 static int G__G__Geom2_195_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05641 {
05642 TGeoUniformMagField* p = NULL;
05643 char* gvp = (char*) G__getgvp();
05644 int n = G__getaryconstruct();
05645 if (n) {
05646 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05647 p = new TGeoUniformMagField[n];
05648 } else {
05649 p = new((void*) gvp) TGeoUniformMagField[n];
05650 }
05651 } else {
05652 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05653 p = new TGeoUniformMagField;
05654 } else {
05655 p = new((void*) gvp) TGeoUniformMagField;
05656 }
05657 }
05658 result7->obj.i = (long) p;
05659 result7->ref = (long) p;
05660 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField));
05661 return(1 || funcname || hash || result7 || libp) ;
05662 }
05663
05664 static int G__G__Geom2_195_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05665 {
05666 TGeoUniformMagField* p = NULL;
05667 char* gvp = (char*) G__getgvp();
05668
05669 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05670 p = new TGeoUniformMagField(
05671 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
05672 , (Double_t) G__double(libp->para[2]));
05673 } else {
05674 p = new((void*) gvp) TGeoUniformMagField(
05675 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
05676 , (Double_t) G__double(libp->para[2]));
05677 }
05678 result7->obj.i = (long) p;
05679 result7->ref = (long) p;
05680 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField));
05681 return(1 || funcname || hash || result7 || libp) ;
05682 }
05683
05684 static int G__G__Geom2_195_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05685 {
05686 G__letint(result7, 68, (long) ((const TGeoUniformMagField*) G__getstructoffset())->GetFieldValue());
05687 return(1 || funcname || hash || result7 || libp) ;
05688 }
05689
05690 static int G__G__Geom2_195_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05691 {
05692 ((TGeoUniformMagField*) G__getstructoffset())->SetFieldValue((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
05693 , (Double_t) G__double(libp->para[2]));
05694 G__setnull(result7);
05695 return(1 || funcname || hash || result7 || libp) ;
05696 }
05697
05698 static int G__G__Geom2_195_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05699 {
05700 G__letint(result7, 85, (long) TGeoUniformMagField::Class());
05701 return(1 || funcname || hash || result7 || libp) ;
05702 }
05703
05704 static int G__G__Geom2_195_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05705 {
05706 G__letint(result7, 67, (long) TGeoUniformMagField::Class_Name());
05707 return(1 || funcname || hash || result7 || libp) ;
05708 }
05709
05710 static int G__G__Geom2_195_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05711 {
05712 G__letint(result7, 115, (long) TGeoUniformMagField::Class_Version());
05713 return(1 || funcname || hash || result7 || libp) ;
05714 }
05715
05716 static int G__G__Geom2_195_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05717 {
05718 TGeoUniformMagField::Dictionary();
05719 G__setnull(result7);
05720 return(1 || funcname || hash || result7 || libp) ;
05721 }
05722
05723 static int G__G__Geom2_195_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05724 {
05725 ((TGeoUniformMagField*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05726 G__setnull(result7);
05727 return(1 || funcname || hash || result7 || libp) ;
05728 }
05729
05730 static int G__G__Geom2_195_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05731 {
05732 G__letint(result7, 67, (long) TGeoUniformMagField::DeclFileName());
05733 return(1 || funcname || hash || result7 || libp) ;
05734 }
05735
05736 static int G__G__Geom2_195_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05737 {
05738 G__letint(result7, 105, (long) TGeoUniformMagField::ImplFileLine());
05739 return(1 || funcname || hash || result7 || libp) ;
05740 }
05741
05742 static int G__G__Geom2_195_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05743 {
05744 G__letint(result7, 67, (long) TGeoUniformMagField::ImplFileName());
05745 return(1 || funcname || hash || result7 || libp) ;
05746 }
05747
05748 static int G__G__Geom2_195_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05749 {
05750 G__letint(result7, 105, (long) TGeoUniformMagField::DeclFileLine());
05751 return(1 || funcname || hash || result7 || libp) ;
05752 }
05753
05754
05755 typedef TGeoUniformMagField G__TTGeoUniformMagField;
05756 static int G__G__Geom2_195_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05757 {
05758 char* gvp = (char*) G__getgvp();
05759 long soff = G__getstructoffset();
05760 int n = G__getaryconstruct();
05761
05762
05763
05764
05765
05766 if (!soff) {
05767 return(1);
05768 }
05769 if (n) {
05770 if (gvp == (char*)G__PVOID) {
05771 delete[] (TGeoUniformMagField*) soff;
05772 } else {
05773 G__setgvp((long) G__PVOID);
05774 for (int i = n - 1; i >= 0; --i) {
05775 ((TGeoUniformMagField*) (soff+(sizeof(TGeoUniformMagField)*i)))->~G__TTGeoUniformMagField();
05776 }
05777 G__setgvp((long)gvp);
05778 }
05779 } else {
05780 if (gvp == (char*)G__PVOID) {
05781 delete (TGeoUniformMagField*) soff;
05782 } else {
05783 G__setgvp((long) G__PVOID);
05784 ((TGeoUniformMagField*) (soff))->~G__TTGeoUniformMagField();
05785 G__setgvp((long)gvp);
05786 }
05787 }
05788 G__setnull(result7);
05789 return(1 || funcname || hash || result7 || libp) ;
05790 }
05791
05792
05793
05794 static int G__G__Geom2_196_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05795 {
05796 TGeoGlobalMagField* p = NULL;
05797 char* gvp = (char*) G__getgvp();
05798 int n = G__getaryconstruct();
05799 if (n) {
05800 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05801 p = new TGeoGlobalMagField[n];
05802 } else {
05803 p = new((void*) gvp) TGeoGlobalMagField[n];
05804 }
05805 } else {
05806 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05807 p = new TGeoGlobalMagField;
05808 } else {
05809 p = new((void*) gvp) TGeoGlobalMagField;
05810 }
05811 }
05812 result7->obj.i = (long) p;
05813 result7->ref = (long) p;
05814 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField));
05815 return(1 || funcname || hash || result7 || libp) ;
05816 }
05817
05818 static int G__G__Geom2_196_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05819 {
05820 G__letint(result7, 85, (long) ((const TGeoGlobalMagField*) G__getstructoffset())->GetField());
05821 return(1 || funcname || hash || result7 || libp) ;
05822 }
05823
05824 static int G__G__Geom2_196_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05825 {
05826 ((TGeoGlobalMagField*) G__getstructoffset())->SetField((TVirtualMagField*) G__int(libp->para[0]));
05827 G__setnull(result7);
05828 return(1 || funcname || hash || result7 || libp) ;
05829 }
05830
05831 static int G__G__Geom2_196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05832 {
05833 G__letint(result7, 103, (long) ((TGeoGlobalMagField*) G__getstructoffset())->IsLocked());
05834 return(1 || funcname || hash || result7 || libp) ;
05835 }
05836
05837 static int G__G__Geom2_196_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05838 {
05839 ((TGeoGlobalMagField*) G__getstructoffset())->Lock();
05840 G__setnull(result7);
05841 return(1 || funcname || hash || result7 || libp) ;
05842 }
05843
05844 static int G__G__Geom2_196_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05845 {
05846 G__letint(result7, 85, (long) TGeoGlobalMagField::Instance());
05847 return(1 || funcname || hash || result7 || libp) ;
05848 }
05849
05850 static int G__G__Geom2_196_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05851 {
05852 ((TGeoGlobalMagField*) G__getstructoffset())->Field((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
05853 G__setnull(result7);
05854 return(1 || funcname || hash || result7 || libp) ;
05855 }
05856
05857 static int G__G__Geom2_196_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05858 {
05859 G__letint(result7, 85, (long) TGeoGlobalMagField::Class());
05860 return(1 || funcname || hash || result7 || libp) ;
05861 }
05862
05863 static int G__G__Geom2_196_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05864 {
05865 G__letint(result7, 67, (long) TGeoGlobalMagField::Class_Name());
05866 return(1 || funcname || hash || result7 || libp) ;
05867 }
05868
05869 static int G__G__Geom2_196_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05870 {
05871 G__letint(result7, 115, (long) TGeoGlobalMagField::Class_Version());
05872 return(1 || funcname || hash || result7 || libp) ;
05873 }
05874
05875 static int G__G__Geom2_196_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05876 {
05877 TGeoGlobalMagField::Dictionary();
05878 G__setnull(result7);
05879 return(1 || funcname || hash || result7 || libp) ;
05880 }
05881
05882 static int G__G__Geom2_196_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05883 {
05884 ((TGeoGlobalMagField*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05885 G__setnull(result7);
05886 return(1 || funcname || hash || result7 || libp) ;
05887 }
05888
05889 static int G__G__Geom2_196_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05890 {
05891 G__letint(result7, 67, (long) TGeoGlobalMagField::DeclFileName());
05892 return(1 || funcname || hash || result7 || libp) ;
05893 }
05894
05895 static int G__G__Geom2_196_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05896 {
05897 G__letint(result7, 105, (long) TGeoGlobalMagField::ImplFileLine());
05898 return(1 || funcname || hash || result7 || libp) ;
05899 }
05900
05901 static int G__G__Geom2_196_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05902 {
05903 G__letint(result7, 67, (long) TGeoGlobalMagField::ImplFileName());
05904 return(1 || funcname || hash || result7 || libp) ;
05905 }
05906
05907 static int G__G__Geom2_196_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05908 {
05909 G__letint(result7, 105, (long) TGeoGlobalMagField::DeclFileLine());
05910 return(1 || funcname || hash || result7 || libp) ;
05911 }
05912
05913
05914 typedef TGeoGlobalMagField G__TTGeoGlobalMagField;
05915 static int G__G__Geom2_196_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05916 {
05917 char* gvp = (char*) G__getgvp();
05918 long soff = G__getstructoffset();
05919 int n = G__getaryconstruct();
05920
05921
05922
05923
05924
05925 if (!soff) {
05926 return(1);
05927 }
05928 if (n) {
05929 if (gvp == (char*)G__PVOID) {
05930 delete[] (TGeoGlobalMagField*) soff;
05931 } else {
05932 G__setgvp((long) G__PVOID);
05933 for (int i = n - 1; i >= 0; --i) {
05934 ((TGeoGlobalMagField*) (soff+(sizeof(TGeoGlobalMagField)*i)))->~G__TTGeoGlobalMagField();
05935 }
05936 G__setgvp((long)gvp);
05937 }
05938 } else {
05939 if (gvp == (char*)G__PVOID) {
05940 delete (TGeoGlobalMagField*) soff;
05941 } else {
05942 G__setgvp((long) G__PVOID);
05943 ((TGeoGlobalMagField*) (soff))->~G__TTGeoGlobalMagField();
05944 G__setgvp((long)gvp);
05945 }
05946 }
05947 G__setnull(result7);
05948 return(1 || funcname || hash || result7 || libp) ;
05949 }
05950
05951
05952
05953
05954
05955
05956
05957
05958
05959
05960
05961
05962
05963
05964
05965
05966
05967
05968
05969
05970
05971
05972
05973
05974
05975
05976
05977
05978
05979
05980
05981
05982
05983
05984
05985
05986
05987
05988
05989
05990
05991
05992
05993
05994
05995
05996
05997
05998
05999
06000
06001
06002
06003 class G__Sizep2memfuncG__Geom2 {
06004 public:
06005 G__Sizep2memfuncG__Geom2(): p(&G__Sizep2memfuncG__Geom2::sizep2memfunc) {}
06006 size_t sizep2memfunc() { return(sizeof(p)); }
06007 private:
06008 size_t (G__Sizep2memfuncG__Geom2::*p)();
06009 };
06010
06011 size_t G__get_sizep2memfuncG__Geom2()
06012 {
06013 G__Sizep2memfuncG__Geom2 a;
06014 G__setsizep2memfunc((int)a.sizep2memfunc());
06015 return((size_t)a.sizep2memfunc());
06016 }
06017
06018
06019
06020
06021
06022
06023
06024
06025
06026
06027
06028 extern "C" void G__cpp_setup_inheritanceG__Geom2() {
06029
06030
06031 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder))) {
06032 TGeoPatternFinder *G__Lderived;
06033 G__Lderived=(TGeoPatternFinder*)0x1000;
06034 {
06035 TObject *G__Lpbase=(TObject*)G__Lderived;
06036 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
06037 }
06038 }
06039 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX))) {
06040 TGeoPatternX *G__Lderived;
06041 G__Lderived=(TGeoPatternX*)0x1000;
06042 {
06043 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06044 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06045 }
06046 {
06047 TObject *G__Lpbase=(TObject*)G__Lderived;
06048 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06049 }
06050 }
06051 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY))) {
06052 TGeoPatternY *G__Lderived;
06053 G__Lderived=(TGeoPatternY*)0x1000;
06054 {
06055 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06056 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06057 }
06058 {
06059 TObject *G__Lpbase=(TObject*)G__Lderived;
06060 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06061 }
06062 }
06063 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ))) {
06064 TGeoPatternZ *G__Lderived;
06065 G__Lderived=(TGeoPatternZ*)0x1000;
06066 {
06067 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06068 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06069 }
06070 {
06071 TObject *G__Lpbase=(TObject*)G__Lderived;
06072 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06073 }
06074 }
06075 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX))) {
06076 TGeoPatternParaX *G__Lderived;
06077 G__Lderived=(TGeoPatternParaX*)0x1000;
06078 {
06079 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06080 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06081 }
06082 {
06083 TObject *G__Lpbase=(TObject*)G__Lderived;
06084 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06085 }
06086 }
06087 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY))) {
06088 TGeoPatternParaY *G__Lderived;
06089 G__Lderived=(TGeoPatternParaY*)0x1000;
06090 {
06091 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06092 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06093 }
06094 {
06095 TObject *G__Lpbase=(TObject*)G__Lderived;
06096 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06097 }
06098 }
06099 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ))) {
06100 TGeoPatternParaZ *G__Lderived;
06101 G__Lderived=(TGeoPatternParaZ*)0x1000;
06102 {
06103 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06104 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06105 }
06106 {
06107 TObject *G__Lpbase=(TObject*)G__Lderived;
06108 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06109 }
06110 }
06111 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ))) {
06112 TGeoPatternTrapZ *G__Lderived;
06113 G__Lderived=(TGeoPatternTrapZ*)0x1000;
06114 {
06115 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06116 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06117 }
06118 {
06119 TObject *G__Lpbase=(TObject*)G__Lderived;
06120 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06121 }
06122 }
06123 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR))) {
06124 TGeoPatternCylR *G__Lderived;
06125 G__Lderived=(TGeoPatternCylR*)0x1000;
06126 {
06127 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06128 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06129 }
06130 {
06131 TObject *G__Lpbase=(TObject*)G__Lderived;
06132 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06133 }
06134 }
06135 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi))) {
06136 TGeoPatternCylPhi *G__Lderived;
06137 G__Lderived=(TGeoPatternCylPhi*)0x1000;
06138 {
06139 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06140 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06141 }
06142 {
06143 TObject *G__Lpbase=(TObject*)G__Lderived;
06144 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06145 }
06146 }
06147 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR))) {
06148 TGeoPatternSphR *G__Lderived;
06149 G__Lderived=(TGeoPatternSphR*)0x1000;
06150 {
06151 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06152 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06153 }
06154 {
06155 TObject *G__Lpbase=(TObject*)G__Lderived;
06156 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06157 }
06158 }
06159 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta))) {
06160 TGeoPatternSphTheta *G__Lderived;
06161 G__Lderived=(TGeoPatternSphTheta*)0x1000;
06162 {
06163 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06164 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06165 }
06166 {
06167 TObject *G__Lpbase=(TObject*)G__Lderived;
06168 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06169 }
06170 }
06171 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi))) {
06172 TGeoPatternSphPhi *G__Lderived;
06173 G__Lderived=(TGeoPatternSphPhi*)0x1000;
06174 {
06175 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06176 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06177 }
06178 {
06179 TObject *G__Lpbase=(TObject*)G__Lderived;
06180 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06181 }
06182 }
06183 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb))) {
06184 TGeoPatternHoneycomb *G__Lderived;
06185 G__Lderived=(TGeoPatternHoneycomb*)0x1000;
06186 {
06187 TGeoPatternFinder *G__Lpbase=(TGeoPatternFinder*)G__Lderived;
06188 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb),G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
06189 }
06190 {
06191 TObject *G__Lpbase=(TObject*)G__Lderived;
06192 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06193 }
06194 }
06195 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState))) {
06196 TGeoCacheState *G__Lderived;
06197 G__Lderived=(TGeoCacheState*)0x1000;
06198 {
06199 TObject *G__Lpbase=(TObject*)G__Lderived;
06200 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
06201 }
06202 }
06203 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache))) {
06204 TGeoNodeCache *G__Lderived;
06205 G__Lderived=(TGeoNodeCache*)0x1000;
06206 {
06207 TObject *G__Lpbase=(TObject*)G__Lderived;
06208 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
06209 }
06210 }
06211 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TVirtualMagField))) {
06212 TVirtualMagField *G__Lderived;
06213 G__Lderived=(TVirtualMagField*)0x1000;
06214 {
06215 TNamed *G__Lpbase=(TNamed*)G__Lderived;
06216 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TVirtualMagField),G__get_linked_tagnum(&G__G__Geom2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
06217 }
06218 {
06219 TObject *G__Lpbase=(TObject*)G__Lderived;
06220 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TVirtualMagField),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06221 }
06222 }
06223 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField))) {
06224 TGeoUniformMagField *G__Lderived;
06225 G__Lderived=(TGeoUniformMagField*)0x1000;
06226 {
06227 TVirtualMagField *G__Lpbase=(TVirtualMagField*)G__Lderived;
06228 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField),G__get_linked_tagnum(&G__G__Geom2LN_TVirtualMagField),(long)G__Lpbase-(long)G__Lderived,1,1);
06229 }
06230 {
06231 TNamed *G__Lpbase=(TNamed*)G__Lderived;
06232 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField),G__get_linked_tagnum(&G__G__Geom2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
06233 }
06234 {
06235 TObject *G__Lpbase=(TObject*)G__Lderived;
06236 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06237 }
06238 }
06239 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField))) {
06240 TGeoGlobalMagField *G__Lderived;
06241 G__Lderived=(TGeoGlobalMagField*)0x1000;
06242 {
06243 TObject *G__Lpbase=(TObject*)G__Lderived;
06244 G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField),G__get_linked_tagnum(&G__G__Geom2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
06245 }
06246 }
06247 }
06248
06249
06250
06251
06252 extern "C" void G__cpp_setup_typetableG__Geom2() {
06253
06254
06255 G__search_typename2("Int_t",105,-1,0,-1);
06256 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
06257 G__search_typename2("Double_t",100,-1,0,-1);
06258 G__setnewtype(-1,"Double 8 bytes",0);
06259 G__search_typename2("Bool_t",103,-1,0,-1);
06260 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
06261 G__search_typename2("Version_t",115,-1,0,-1);
06262 G__setnewtype(-1,"Class version identifier (short)",0);
06263 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__Geom2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
06264 G__setnewtype(-1,NULL,0);
06265 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Geom2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
06266 G__setnewtype(-1,NULL,0);
06267 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Geom2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
06268 G__setnewtype(-1,NULL,0);
06269 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Geom2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
06270 G__setnewtype(-1,NULL,0);
06271 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Geom2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
06272 G__setnewtype(-1,NULL,0);
06273 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Geom2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
06274 G__setnewtype(-1,NULL,0);
06275 G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__Geom2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
06276 G__setnewtype(-1,NULL,0);
06277 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__Geom2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
06278 G__setnewtype(-1,NULL,0);
06279 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__Geom2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
06280 G__setnewtype(-1,NULL,0);
06281 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__Geom2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
06282 G__setnewtype(-1,NULL,0);
06283 G__search_typename2("map<Int_t,TGeoElementRN*>",117,G__get_linked_tagnum(&G__G__Geom2LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
06284 G__setnewtype(-1,NULL,0);
06285 G__search_typename2("map<int,TGeoElementRN*>",117,G__get_linked_tagnum(&G__G__Geom2LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
06286 G__setnewtype(-1,NULL,0);
06287 G__search_typename2("map<int,TGeoElementRN*,less<int> >",117,G__get_linked_tagnum(&G__G__Geom2LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
06288 G__setnewtype(-1,NULL,0);
06289 }
06290
06291
06292
06293
06294
06295
06296
06297
06298 static void G__setup_memvarTGeoPatternFinder(void) {
06299 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder));
06300 { TGeoPatternFinder *p; p=(TGeoPatternFinder*)0x1000; if (p) { }
06301 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFindercLcLEGeoPatternFlags),-1,-2,2,"kPatternReflected=16384LL",0,(char*)NULL);
06302 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStep=",0,"division step length");
06303 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStart=",0,"starting point on divided axis");
06304 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEnd=",0,"ending point");
06305 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCurrent=",0,"current division element");
06306 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdivisions=",0,"number of divisions");
06307 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDivIndex=",0,"index of first div. node");
06308 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoMatrix),-1,-1,2,"fMatrix=",0,"generic matrix");
06309 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoVolume),-1,-1,2,"fVolume=",0,"volume to which applies");
06310 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNextIndex=",0,"! index of next node");
06311 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06312 }
06313 G__tag_memvar_reset();
06314 }
06315
06316
06317
06318 static void G__setup_memvarTGeoPatternX(void) {
06319 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX));
06320 { TGeoPatternX *p; p=(TGeoPatternX*)0x1000; if (p) { }
06321 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06322 }
06323 G__tag_memvar_reset();
06324 }
06325
06326
06327
06328 static void G__setup_memvarTGeoPatternY(void) {
06329 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY));
06330 { TGeoPatternY *p; p=(TGeoPatternY*)0x1000; if (p) { }
06331 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06332 }
06333 G__tag_memvar_reset();
06334 }
06335
06336
06337
06338 static void G__setup_memvarTGeoPatternZ(void) {
06339 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ));
06340 { TGeoPatternZ *p; p=(TGeoPatternZ*)0x1000; if (p) { }
06341 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06342 }
06343 G__tag_memvar_reset();
06344 }
06345
06346
06347
06348 static void G__setup_memvarTGeoPatternParaX(void) {
06349 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX));
06350 { TGeoPatternParaX *p; p=(TGeoPatternParaX*)0x1000; if (p) { }
06351 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06352 }
06353 G__tag_memvar_reset();
06354 }
06355
06356
06357
06358 static void G__setup_memvarTGeoPatternParaY(void) {
06359 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY));
06360 { TGeoPatternParaY *p; p=(TGeoPatternParaY*)0x1000; if (p) { }
06361 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTxy=",0,"tangent of alpha");
06362 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06363 }
06364 G__tag_memvar_reset();
06365 }
06366
06367
06368
06369 static void G__setup_memvarTGeoPatternParaZ(void) {
06370 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ));
06371 { TGeoPatternParaZ *p; p=(TGeoPatternParaZ*)0x1000; if (p) { }
06372 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTxz=",0,"tangent of alpha xz");
06373 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTyz=",0,"tangent of alpha yz");
06374 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06375 }
06376 G__tag_memvar_reset();
06377 }
06378
06379
06380
06381 static void G__setup_memvarTGeoPatternTrapZ(void) {
06382 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ));
06383 { TGeoPatternTrapZ *p; p=(TGeoPatternTrapZ*)0x1000; if (p) { }
06384 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTxz=",0,"tangent of alpha xz");
06385 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTyz=",0,"tangent of alpha yz");
06386 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06387 }
06388 G__tag_memvar_reset();
06389 }
06390
06391
06392
06393 static void G__setup_memvarTGeoPatternCylR(void) {
06394 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR));
06395 { TGeoPatternCylR *p; p=(TGeoPatternCylR*)0x1000; if (p) { }
06396 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06397 }
06398 G__tag_memvar_reset();
06399 }
06400
06401
06402
06403 static void G__setup_memvarTGeoPatternCylPhi(void) {
06404 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi));
06405 { TGeoPatternCylPhi *p; p=(TGeoPatternCylPhi*)0x1000; if (p) { }
06406 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSinCos=",0,"![2*fNdivisions] table of sines/cosines");
06407 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06408 }
06409 G__tag_memvar_reset();
06410 }
06411
06412
06413
06414 static void G__setup_memvarTGeoPatternSphR(void) {
06415 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR));
06416 { TGeoPatternSphR *p; p=(TGeoPatternSphR*)0x1000; if (p) { }
06417 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06418 }
06419 G__tag_memvar_reset();
06420 }
06421
06422
06423
06424 static void G__setup_memvarTGeoPatternSphTheta(void) {
06425 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta));
06426 { TGeoPatternSphTheta *p; p=(TGeoPatternSphTheta*)0x1000; if (p) { }
06427 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06428 }
06429 G__tag_memvar_reset();
06430 }
06431
06432
06433
06434 static void G__setup_memvarTGeoPatternSphPhi(void) {
06435 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi));
06436 { TGeoPatternSphPhi *p; p=(TGeoPatternSphPhi*)0x1000; if (p) { }
06437 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06438 }
06439 G__tag_memvar_reset();
06440 }
06441
06442
06443
06444 static void G__setup_memvarTGeoPatternHoneycomb(void) {
06445 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb));
06446 { TGeoPatternHoneycomb *p; p=(TGeoPatternHoneycomb*)0x1000; if (p) { }
06447 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNrows=",0,"number of rows");
06448 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAxisOnRows=",0,"axis along each row");
06449 G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdivisions=",0,"[fNrows] number of divisions for each row");
06450 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStart=",0,"[fNrows] starting points for each row");
06451 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06452 }
06453 G__tag_memvar_reset();
06454 }
06455
06456
06457
06458 static void G__setup_memvarTGeoCacheState(void) {
06459 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState));
06460 { TGeoCacheState *p; p=(TGeoCacheState*)0x1000; if (p) { }
06461 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCapacity=",0,"maximum level stored");
06462 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLevel=",0,"level in the current branch");
06463 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNmany=",0,"number of overlapping nodes on current branch");
06464 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStart=",0,"start level");
06465 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIdBranch[30]=",0,"ID branch");
06466 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPoint[3]=",0,"last point in master frame");
06467 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOverlapping=",0,"overlap flag");
06468 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode),-1,-1,2,"fNodeBranch=",0,"last node branch stored");
06469 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoHMatrix),-1,-1,2,"fMatrixBranch=",0,"global matrices for last branch");
06470 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoHMatrix),-1,-1,2,"fMatPtr=",0,"array of matrix pointers");
06471 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06472 }
06473 G__tag_memvar_reset();
06474 }
06475
06476
06477
06478 static void G__setup_memvarTGeoNodeCache(void) {
06479 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache));
06480 { TGeoNodeCache *p; p=(TGeoNodeCache*)0x1000; if (p) { }
06481 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGeoCacheMaxLevels=",0,"maximum supported number of levels");
06482 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGeoCacheStackSize=",0,"maximum size of the stack");
06483 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLevel=",0,"level in the current branch");
06484 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStackLevel=",0,"current level in the stack");
06485 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurrentID=",0,"unique ID of current node");
06486 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIndex=",0,"index in array of ID's");
06487 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIdBranch[100]=",0,"current branch of indices");
06488 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TString),-1,-1,4,"fPath=",0,"path for current branch");
06489 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode),-1,-1,4,"fTop=",0,"top node");
06490 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode),-1,-1,4,"fNode=",0,"! current node");
06491 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoHMatrix),-1,-1,4,"fMatrix=",0,"! current matrix");
06492 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TObjArray),-1,-1,4,"fStack=",0,"stack of cache states");
06493 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoHMatrix),-1,-1,4,"fMatrixBranch=",0,"current branch of global matrices");
06494 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoHMatrix),-1,-1,4,"fMPB=",0,"pre-built matrices");
06495 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode),-1,-1,4,"fNodeBranch=",0,"current branch of nodes");
06496 G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNodeIdArray=",0,"! array of node id's");
06497 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06498 }
06499 G__tag_memvar_reset();
06500 }
06501
06502
06503
06504 static void G__setup_memvarTVirtualMagField(void) {
06505 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TVirtualMagField));
06506 { TVirtualMagField *p; p=(TVirtualMagField*)0x1000; if (p) { }
06507 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06508 }
06509 G__tag_memvar_reset();
06510 }
06511
06512
06513
06514 static void G__setup_memvarTGeoUniformMagField(void) {
06515 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField));
06516 { TGeoUniformMagField *p; p=(TGeoUniformMagField*)0x1000; if (p) { }
06517 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fB[3]=",0,"Magnetic field vector");
06518 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06519 }
06520 G__tag_memvar_reset();
06521 }
06522
06523
06524
06525 static void G__setup_memvarTGeoGlobalMagField(void) {
06526 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField));
06527 { TGeoGlobalMagField *p; p=(TGeoGlobalMagField*)0x1000; if (p) { }
06528 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField),-1,-2,4,"fgInstance=",0,"Static pointer to the field manager;");
06529 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TVirtualMagField),-1,-1,4,"fField=",0,"Magnetic field");
06530 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLock=",0,"Lock flag for global field.");
06531 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
06532 }
06533 G__tag_memvar_reset();
06534 }
06535
06536 extern "C" void G__cpp_setup_memvarG__Geom2() {
06537 }
06538
06539
06540
06541
06542
06543
06544
06545
06546
06547
06548
06549
06550 static void G__setup_memfuncTGeoPatternFinder(void) {
06551
06552 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder));
06553 G__memfunc_setup("TGeoPatternFinder",1701,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 2, 0, "u 'TGeoPatternFinder' - 11 - -", (char*)NULL, (void*) NULL, 0);
06554 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 1, 1, 1, 2, 0, "u 'TGeoPatternFinder' - 11 - -", (char*)NULL, (void*) NULL, 0);
06555 G__memfunc_setup("TGeoPatternFinder",1701,G__G__Geom2_166_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06556 G__memfunc_setup("TGeoPatternFinder",1701,G__G__Geom2_166_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 2, 1, 1, 0,
06557 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndiv", (char*)NULL, (void*) NULL, 0);
06558 G__memfunc_setup("cd",199,G__G__Geom2_166_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
06559 G__memfunc_setup("CdNext",582,G__G__Geom2_166_0_6, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06560 G__memfunc_setup("FindNode",775,G__G__Geom2_166_0_7, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06561 "D - 'Double_t' 0 - - D - 'Double_t' 10 '0' -", (char*)NULL, (void*) NULL, 1);
06562 G__memfunc_setup("GetByteCount",1213,G__G__Geom2_166_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06563 G__memfunc_setup("GetCurrent",1027,G__G__Geom2_166_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06564 G__memfunc_setup("GetDivIndex",1083,G__G__Geom2_166_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06565 G__memfunc_setup("GetDivAxis",984,G__G__Geom2_166_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06566 G__memfunc_setup("GetMatrix",917,G__G__Geom2_166_0_12, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoMatrix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06567 G__memfunc_setup("GetNdiv",689,G__G__Geom2_166_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06568 G__memfunc_setup("GetNext",703,G__G__Geom2_166_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06569 G__memfunc_setup("GetNodeOffset",1293,G__G__Geom2_166_0_15, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 0);
06570 G__memfunc_setup("GetStart",814,G__G__Geom2_166_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06571 G__memfunc_setup("GetStep",700,G__G__Geom2_166_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06572 G__memfunc_setup("GetEnd",567,G__G__Geom2_166_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06573 G__memfunc_setup("GetVolume",920,G__G__Geom2_166_0_19, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06574 G__memfunc_setup("IsOnBoundary",1213,G__G__Geom2_166_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 1);
06575 G__memfunc_setup("IsReflected",1098,G__G__Geom2_166_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06576 G__memfunc_setup("MakeCopy",793,G__G__Geom2_166_0_22, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06577 G__memfunc_setup("Reflect",709,G__G__Geom2_166_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
06578 G__memfunc_setup("SetDivIndex",1095,G__G__Geom2_166_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
06579 G__memfunc_setup("SetNext",715,G__G__Geom2_166_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
06580 G__memfunc_setup("SetVolume",932,G__G__Geom2_166_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
06581 G__memfunc_setup("Class",502,G__G__Geom2_166_0_27, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternFinder::Class) ), 0);
06582 G__memfunc_setup("Class_Name",982,G__G__Geom2_166_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternFinder::Class_Name) ), 0);
06583 G__memfunc_setup("Class_Version",1339,G__G__Geom2_166_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternFinder::Class_Version) ), 0);
06584 G__memfunc_setup("Dictionary",1046,G__G__Geom2_166_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternFinder::Dictionary) ), 0);
06585 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06586 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06587 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06588 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_166_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06589 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_166_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternFinder::DeclFileName) ), 0);
06590 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_166_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternFinder::ImplFileLine) ), 0);
06591 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_166_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternFinder::ImplFileName) ), 0);
06592 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_166_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternFinder::DeclFileLine) ), 0);
06593
06594 G__memfunc_setup("~TGeoPatternFinder", 1827, G__G__Geom2_166_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06595 G__tag_memfunc_reset();
06596 }
06597
06598 static void G__setup_memfuncTGeoPatternX(void) {
06599
06600 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX));
06601 G__memfunc_setup("TGeoPatternX",1189,G__G__Geom2_174_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06602 G__memfunc_setup("TGeoPatternX",1189,G__G__Geom2_174_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX), -1, 0, 2, 1, 1, 0,
06603 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06604 G__memfunc_setup("TGeoPatternX",1189,G__G__Geom2_174_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX), -1, 0, 3, 1, 1, 0,
06605 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06606 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06607 G__memfunc_setup("TGeoPatternX",1189,G__G__Geom2_174_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX), -1, 0, 4, 1, 1, 0,
06608 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06609 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06610 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06611 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06612 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06613 G__memfunc_setup("FindNextBoundary",1636,G__G__Geom2_174_0_7, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0,
06614 "D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
06615 "i - 'Int_t' 1 - indnext", (char*)NULL, (void*) NULL, 1);
06616 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06617 G__memfunc_setup("IsOnBoundary",1213,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 1);
06618 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06619 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06620 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06621 G__memfunc_setup("Class",502,G__G__Geom2_174_0_12, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternX::Class) ), 0);
06622 G__memfunc_setup("Class_Name",982,G__G__Geom2_174_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternX::Class_Name) ), 0);
06623 G__memfunc_setup("Class_Version",1339,G__G__Geom2_174_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternX::Class_Version) ), 0);
06624 G__memfunc_setup("Dictionary",1046,G__G__Geom2_174_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternX::Dictionary) ), 0);
06625 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06626 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06627 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06628 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_174_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06629 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_174_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternX::DeclFileName) ), 0);
06630 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_174_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternX::ImplFileLine) ), 0);
06631 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_174_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternX::ImplFileName) ), 0);
06632 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_174_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternX::DeclFileLine) ), 0);
06633
06634 G__memfunc_setup("TGeoPatternX", 1189, G__G__Geom2_174_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternX), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternX' - 11 - -", (char*) NULL, (void*) NULL, 0);
06635
06636 G__memfunc_setup("~TGeoPatternX", 1315, G__G__Geom2_174_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06637 G__tag_memfunc_reset();
06638 }
06639
06640 static void G__setup_memfuncTGeoPatternY(void) {
06641
06642 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY));
06643 G__memfunc_setup("TGeoPatternY",1190,G__G__Geom2_175_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06644 G__memfunc_setup("TGeoPatternY",1190,G__G__Geom2_175_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY), -1, 0, 2, 1, 1, 0,
06645 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06646 G__memfunc_setup("TGeoPatternY",1190,G__G__Geom2_175_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY), -1, 0, 3, 1, 1, 0,
06647 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06648 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06649 G__memfunc_setup("TGeoPatternY",1190,G__G__Geom2_175_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY), -1, 0, 4, 1, 1, 0,
06650 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06651 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06652 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06653 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06654 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06655 G__memfunc_setup("FindNextBoundary",1636,G__G__Geom2_175_0_7, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0,
06656 "D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
06657 "i - 'Int_t' 1 - indnext", (char*)NULL, (void*) NULL, 1);
06658 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06659 G__memfunc_setup("IsOnBoundary",1213,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 1);
06660 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06661 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06662 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06663 G__memfunc_setup("Class",502,G__G__Geom2_175_0_12, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternY::Class) ), 0);
06664 G__memfunc_setup("Class_Name",982,G__G__Geom2_175_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternY::Class_Name) ), 0);
06665 G__memfunc_setup("Class_Version",1339,G__G__Geom2_175_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternY::Class_Version) ), 0);
06666 G__memfunc_setup("Dictionary",1046,G__G__Geom2_175_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternY::Dictionary) ), 0);
06667 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06668 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06669 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06670 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_175_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06671 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_175_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternY::DeclFileName) ), 0);
06672 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_175_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternY::ImplFileLine) ), 0);
06673 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_175_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternY::ImplFileName) ), 0);
06674 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_175_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternY::DeclFileLine) ), 0);
06675
06676 G__memfunc_setup("TGeoPatternY", 1190, G__G__Geom2_175_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternY), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternY' - 11 - -", (char*) NULL, (void*) NULL, 0);
06677
06678 G__memfunc_setup("~TGeoPatternY", 1316, G__G__Geom2_175_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06679 G__tag_memfunc_reset();
06680 }
06681
06682 static void G__setup_memfuncTGeoPatternZ(void) {
06683
06684 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ));
06685 G__memfunc_setup("TGeoPatternZ",1191,G__G__Geom2_176_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06686 G__memfunc_setup("TGeoPatternZ",1191,G__G__Geom2_176_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ), -1, 0, 2, 1, 1, 0,
06687 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06688 G__memfunc_setup("TGeoPatternZ",1191,G__G__Geom2_176_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ), -1, 0, 3, 1, 1, 0,
06689 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06690 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06691 G__memfunc_setup("TGeoPatternZ",1191,G__G__Geom2_176_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ), -1, 0, 4, 1, 1, 0,
06692 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06693 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06694 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06695 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06696 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06697 G__memfunc_setup("FindNextBoundary",1636,G__G__Geom2_176_0_7, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0,
06698 "D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
06699 "i - 'Int_t' 1 - indnext", (char*)NULL, (void*) NULL, 1);
06700 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06701 G__memfunc_setup("IsOnBoundary",1213,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 1);
06702 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06703 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06704 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06705 G__memfunc_setup("Class",502,G__G__Geom2_176_0_12, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternZ::Class) ), 0);
06706 G__memfunc_setup("Class_Name",982,G__G__Geom2_176_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternZ::Class_Name) ), 0);
06707 G__memfunc_setup("Class_Version",1339,G__G__Geom2_176_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternZ::Class_Version) ), 0);
06708 G__memfunc_setup("Dictionary",1046,G__G__Geom2_176_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternZ::Dictionary) ), 0);
06709 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06710 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06711 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06712 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_176_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06713 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_176_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternZ::DeclFileName) ), 0);
06714 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_176_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternZ::ImplFileLine) ), 0);
06715 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_176_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternZ::ImplFileName) ), 0);
06716 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_176_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternZ::DeclFileLine) ), 0);
06717
06718 G__memfunc_setup("TGeoPatternZ", 1191, G__G__Geom2_176_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternZ), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternZ' - 11 - -", (char*) NULL, (void*) NULL, 0);
06719
06720 G__memfunc_setup("~TGeoPatternZ", 1317, G__G__Geom2_176_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06721 G__tag_memfunc_reset();
06722 }
06723
06724 static void G__setup_memfuncTGeoPatternParaX(void) {
06725
06726 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX));
06727 G__memfunc_setup("TGeoPatternParaX",1577,G__G__Geom2_177_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06728 G__memfunc_setup("TGeoPatternParaX",1577,G__G__Geom2_177_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX), -1, 0, 2, 1, 1, 0,
06729 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06730 G__memfunc_setup("TGeoPatternParaX",1577,G__G__Geom2_177_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX), -1, 0, 3, 1, 1, 0,
06731 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06732 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06733 G__memfunc_setup("TGeoPatternParaX",1577,G__G__Geom2_177_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX), -1, 0, 4, 1, 1, 0,
06734 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06735 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06736 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06737 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06738 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06739 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06740 G__memfunc_setup("IsOnBoundary",1213,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 1);
06741 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06742 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06743 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06744 G__memfunc_setup("Class",502,G__G__Geom2_177_0_11, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternParaX::Class) ), 0);
06745 G__memfunc_setup("Class_Name",982,G__G__Geom2_177_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternParaX::Class_Name) ), 0);
06746 G__memfunc_setup("Class_Version",1339,G__G__Geom2_177_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternParaX::Class_Version) ), 0);
06747 G__memfunc_setup("Dictionary",1046,G__G__Geom2_177_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternParaX::Dictionary) ), 0);
06748 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06749 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06750 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06751 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_177_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06752 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_177_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternParaX::DeclFileName) ), 0);
06753 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_177_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternParaX::ImplFileLine) ), 0);
06754 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_177_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternParaX::ImplFileName) ), 0);
06755 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_177_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternParaX::DeclFileLine) ), 0);
06756
06757 G__memfunc_setup("TGeoPatternParaX", 1577, G__G__Geom2_177_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaX), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternParaX' - 11 - -", (char*) NULL, (void*) NULL, 0);
06758
06759 G__memfunc_setup("~TGeoPatternParaX", 1703, G__G__Geom2_177_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06760 G__tag_memfunc_reset();
06761 }
06762
06763 static void G__setup_memfuncTGeoPatternParaY(void) {
06764
06765 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY));
06766 G__memfunc_setup("TGeoPatternParaY",1578,G__G__Geom2_178_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06767 G__memfunc_setup("TGeoPatternParaY",1578,G__G__Geom2_178_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY), -1, 0, 2, 1, 1, 0,
06768 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06769 G__memfunc_setup("TGeoPatternParaY",1578,G__G__Geom2_178_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY), -1, 0, 3, 1, 1, 0,
06770 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06771 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06772 G__memfunc_setup("TGeoPatternParaY",1578,G__G__Geom2_178_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY), -1, 0, 4, 1, 1, 0,
06773 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06774 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06775 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06776 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06777 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06778 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06779 G__memfunc_setup("IsOnBoundary",1213,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 1);
06780 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06781 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06782 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06783 G__memfunc_setup("Class",502,G__G__Geom2_178_0_11, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternParaY::Class) ), 0);
06784 G__memfunc_setup("Class_Name",982,G__G__Geom2_178_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternParaY::Class_Name) ), 0);
06785 G__memfunc_setup("Class_Version",1339,G__G__Geom2_178_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternParaY::Class_Version) ), 0);
06786 G__memfunc_setup("Dictionary",1046,G__G__Geom2_178_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternParaY::Dictionary) ), 0);
06787 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06788 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06789 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06790 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_178_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06791 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_178_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternParaY::DeclFileName) ), 0);
06792 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_178_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternParaY::ImplFileLine) ), 0);
06793 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_178_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternParaY::ImplFileName) ), 0);
06794 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_178_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternParaY::DeclFileLine) ), 0);
06795
06796 G__memfunc_setup("TGeoPatternParaY", 1578, G__G__Geom2_178_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaY), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternParaY' - 11 - -", (char*) NULL, (void*) NULL, 0);
06797
06798 G__memfunc_setup("~TGeoPatternParaY", 1704, G__G__Geom2_178_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06799 G__tag_memfunc_reset();
06800 }
06801
06802 static void G__setup_memfuncTGeoPatternParaZ(void) {
06803
06804 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ));
06805 G__memfunc_setup("TGeoPatternParaZ",1579,G__G__Geom2_179_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06806 G__memfunc_setup("TGeoPatternParaZ",1579,G__G__Geom2_179_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ), -1, 0, 2, 1, 1, 0,
06807 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06808 G__memfunc_setup("TGeoPatternParaZ",1579,G__G__Geom2_179_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ), -1, 0, 3, 1, 1, 0,
06809 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06810 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06811 G__memfunc_setup("TGeoPatternParaZ",1579,G__G__Geom2_179_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ), -1, 0, 4, 1, 1, 0,
06812 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06813 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06814 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06815 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06816 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06817 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06818 G__memfunc_setup("IsOnBoundary",1213,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 1);
06819 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06820 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06821 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06822 G__memfunc_setup("Class",502,G__G__Geom2_179_0_11, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternParaZ::Class) ), 0);
06823 G__memfunc_setup("Class_Name",982,G__G__Geom2_179_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternParaZ::Class_Name) ), 0);
06824 G__memfunc_setup("Class_Version",1339,G__G__Geom2_179_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternParaZ::Class_Version) ), 0);
06825 G__memfunc_setup("Dictionary",1046,G__G__Geom2_179_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternParaZ::Dictionary) ), 0);
06826 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06827 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06828 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06829 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_179_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06830 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_179_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternParaZ::DeclFileName) ), 0);
06831 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_179_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternParaZ::ImplFileLine) ), 0);
06832 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_179_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternParaZ::ImplFileName) ), 0);
06833 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_179_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternParaZ::DeclFileLine) ), 0);
06834
06835 G__memfunc_setup("TGeoPatternParaZ", 1579, G__G__Geom2_179_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternParaZ), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternParaZ' - 11 - -", (char*) NULL, (void*) NULL, 0);
06836
06837 G__memfunc_setup("~TGeoPatternParaZ", 1705, G__G__Geom2_179_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06838 G__tag_memfunc_reset();
06839 }
06840
06841 static void G__setup_memfuncTGeoPatternTrapZ(void) {
06842
06843 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ));
06844 G__memfunc_setup("TGeoPatternTrapZ",1598,G__G__Geom2_180_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06845 G__memfunc_setup("TGeoPatternTrapZ",1598,G__G__Geom2_180_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ), -1, 0, 2, 1, 1, 0,
06846 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06847 G__memfunc_setup("TGeoPatternTrapZ",1598,G__G__Geom2_180_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ), -1, 0, 3, 1, 1, 0,
06848 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06849 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06850 G__memfunc_setup("TGeoPatternTrapZ",1598,G__G__Geom2_180_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ), -1, 0, 4, 1, 1, 0,
06851 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06852 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06853 G__memfunc_setup("GetTxz",614,G__G__Geom2_180_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06854 G__memfunc_setup("GetTyz",615,G__G__Geom2_180_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06855 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06856 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06857 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06858 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06859 G__memfunc_setup("IsOnBoundary",1213,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 1);
06860 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06861 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06862 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06863 G__memfunc_setup("Class",502,G__G__Geom2_180_0_13, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternTrapZ::Class) ), 0);
06864 G__memfunc_setup("Class_Name",982,G__G__Geom2_180_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternTrapZ::Class_Name) ), 0);
06865 G__memfunc_setup("Class_Version",1339,G__G__Geom2_180_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternTrapZ::Class_Version) ), 0);
06866 G__memfunc_setup("Dictionary",1046,G__G__Geom2_180_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternTrapZ::Dictionary) ), 0);
06867 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06868 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06869 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06870 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_180_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06871 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_180_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternTrapZ::DeclFileName) ), 0);
06872 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_180_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternTrapZ::ImplFileLine) ), 0);
06873 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_180_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternTrapZ::ImplFileName) ), 0);
06874 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_180_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternTrapZ::DeclFileLine) ), 0);
06875
06876 G__memfunc_setup("TGeoPatternTrapZ", 1598, G__G__Geom2_180_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternTrapZ), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternTrapZ' - 11 - -", (char*) NULL, (void*) NULL, 0);
06877
06878 G__memfunc_setup("~TGeoPatternTrapZ", 1724, G__G__Geom2_180_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06879 G__tag_memfunc_reset();
06880 }
06881
06882 static void G__setup_memfuncTGeoPatternCylR(void) {
06883
06884 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR));
06885 G__memfunc_setup("TGeoPatternCylR",1479,G__G__Geom2_181_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06886 G__memfunc_setup("TGeoPatternCylR",1479,G__G__Geom2_181_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR), -1, 0, 2, 1, 1, 0,
06887 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06888 G__memfunc_setup("TGeoPatternCylR",1479,G__G__Geom2_181_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR), -1, 0, 3, 1, 1, 0,
06889 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06890 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06891 G__memfunc_setup("TGeoPatternCylR",1479,G__G__Geom2_181_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR), -1, 0, 4, 1, 1, 0,
06892 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06893 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06894 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06895 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06896 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06897 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06898 G__memfunc_setup("IsOnBoundary",1213,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 1);
06899 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06900 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06901 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06902 G__memfunc_setup("Class",502,G__G__Geom2_181_0_11, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternCylR::Class) ), 0);
06903 G__memfunc_setup("Class_Name",982,G__G__Geom2_181_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternCylR::Class_Name) ), 0);
06904 G__memfunc_setup("Class_Version",1339,G__G__Geom2_181_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternCylR::Class_Version) ), 0);
06905 G__memfunc_setup("Dictionary",1046,G__G__Geom2_181_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternCylR::Dictionary) ), 0);
06906 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06907 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06908 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06909 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_181_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06910 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_181_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternCylR::DeclFileName) ), 0);
06911 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_181_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternCylR::ImplFileLine) ), 0);
06912 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_181_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternCylR::ImplFileName) ), 0);
06913 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_181_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternCylR::DeclFileLine) ), 0);
06914
06915 G__memfunc_setup("TGeoPatternCylR", 1479, G__G__Geom2_181_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylR), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternCylR' - 11 - -", (char*) NULL, (void*) NULL, 0);
06916
06917 G__memfunc_setup("~TGeoPatternCylR", 1605, G__G__Geom2_181_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06918 G__tag_memfunc_reset();
06919 }
06920
06921 static void G__setup_memfuncTGeoPatternCylPhi(void) {
06922
06923 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi));
06924 G__memfunc_setup("TGeoPatternCylPhi",1686,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi), -1, 0, 1, 1, 2, 0, "u 'TGeoPatternCylPhi' - 11 - pfc", (char*)NULL, (void*) NULL, 0);
06925 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi), -1, 1, 1, 1, 2, 0, "u 'TGeoPatternCylPhi' - 11 - pfc", (char*)NULL, (void*) NULL, 0);
06926 G__memfunc_setup("TGeoPatternCylPhi",1686,G__G__Geom2_182_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06927 G__memfunc_setup("TGeoPatternCylPhi",1686,G__G__Geom2_182_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi), -1, 0, 2, 1, 1, 0,
06928 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06929 G__memfunc_setup("TGeoPatternCylPhi",1686,G__G__Geom2_182_0_5, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi), -1, 0, 3, 1, 1, 0,
06930 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06931 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06932 G__memfunc_setup("TGeoPatternCylPhi",1686,G__G__Geom2_182_0_6, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternCylPhi), -1, 0, 4, 1, 1, 0,
06933 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06934 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06935 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06936 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06937 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06938 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06939 G__memfunc_setup("IsOnBoundary",1213,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 1);
06940 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06941 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06942 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06943 G__memfunc_setup("Class",502,G__G__Geom2_182_0_13, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternCylPhi::Class) ), 0);
06944 G__memfunc_setup("Class_Name",982,G__G__Geom2_182_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternCylPhi::Class_Name) ), 0);
06945 G__memfunc_setup("Class_Version",1339,G__G__Geom2_182_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternCylPhi::Class_Version) ), 0);
06946 G__memfunc_setup("Dictionary",1046,G__G__Geom2_182_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternCylPhi::Dictionary) ), 0);
06947 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06948 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06949 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06950 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_182_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06951 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_182_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternCylPhi::DeclFileName) ), 0);
06952 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_182_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternCylPhi::ImplFileLine) ), 0);
06953 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_182_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternCylPhi::ImplFileName) ), 0);
06954 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_182_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternCylPhi::DeclFileLine) ), 0);
06955
06956 G__memfunc_setup("~TGeoPatternCylPhi", 1812, G__G__Geom2_182_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06957 G__tag_memfunc_reset();
06958 }
06959
06960 static void G__setup_memfuncTGeoPatternSphR(void) {
06961
06962 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR));
06963 G__memfunc_setup("TGeoPatternSphR",1482,G__G__Geom2_183_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06964 G__memfunc_setup("TGeoPatternSphR",1482,G__G__Geom2_183_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR), -1, 0, 2, 1, 1, 0,
06965 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
06966 G__memfunc_setup("TGeoPatternSphR",1482,G__G__Geom2_183_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR), -1, 0, 3, 1, 1, 0,
06967 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06968 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
06969 G__memfunc_setup("TGeoPatternSphR",1482,G__G__Geom2_183_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR), -1, 0, 4, 1, 1, 0,
06970 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
06971 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
06972 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
06973 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
06974 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
06975 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
06976 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
06977 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
06978 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
06979 G__memfunc_setup("Class",502,G__G__Geom2_183_0_10, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternSphR::Class) ), 0);
06980 G__memfunc_setup("Class_Name",982,G__G__Geom2_183_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternSphR::Class_Name) ), 0);
06981 G__memfunc_setup("Class_Version",1339,G__G__Geom2_183_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternSphR::Class_Version) ), 0);
06982 G__memfunc_setup("Dictionary",1046,G__G__Geom2_183_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternSphR::Dictionary) ), 0);
06983 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06984 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
06985 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
06986 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_183_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
06987 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_183_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternSphR::DeclFileName) ), 0);
06988 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_183_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternSphR::ImplFileLine) ), 0);
06989 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_183_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternSphR::ImplFileName) ), 0);
06990 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_183_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternSphR::DeclFileLine) ), 0);
06991
06992 G__memfunc_setup("TGeoPatternSphR", 1482, G__G__Geom2_183_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphR), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternSphR' - 11 - -", (char*) NULL, (void*) NULL, 0);
06993
06994 G__memfunc_setup("~TGeoPatternSphR", 1608, G__G__Geom2_183_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06995 G__tag_memfunc_reset();
06996 }
06997
06998 static void G__setup_memfuncTGeoPatternSphTheta(void) {
06999
07000 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta));
07001 G__memfunc_setup("TGeoPatternSphTheta",1902,G__G__Geom2_184_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07002 G__memfunc_setup("TGeoPatternSphTheta",1902,G__G__Geom2_184_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta), -1, 0, 2, 1, 1, 0,
07003 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
07004 G__memfunc_setup("TGeoPatternSphTheta",1902,G__G__Geom2_184_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta), -1, 0, 3, 1, 1, 0,
07005 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
07006 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
07007 G__memfunc_setup("TGeoPatternSphTheta",1902,G__G__Geom2_184_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta), -1, 0, 4, 1, 1, 0,
07008 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
07009 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
07010 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
07011 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
07012 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
07013 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07014 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
07015 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
07016 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
07017 G__memfunc_setup("Class",502,G__G__Geom2_184_0_10, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternSphTheta::Class) ), 0);
07018 G__memfunc_setup("Class_Name",982,G__G__Geom2_184_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternSphTheta::Class_Name) ), 0);
07019 G__memfunc_setup("Class_Version",1339,G__G__Geom2_184_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternSphTheta::Class_Version) ), 0);
07020 G__memfunc_setup("Dictionary",1046,G__G__Geom2_184_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternSphTheta::Dictionary) ), 0);
07021 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07022 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
07023 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
07024 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_184_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07025 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_184_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternSphTheta::DeclFileName) ), 0);
07026 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_184_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternSphTheta::ImplFileLine) ), 0);
07027 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_184_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternSphTheta::ImplFileName) ), 0);
07028 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_184_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternSphTheta::DeclFileLine) ), 0);
07029
07030 G__memfunc_setup("TGeoPatternSphTheta", 1902, G__G__Geom2_184_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphTheta), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternSphTheta' - 11 - -", (char*) NULL, (void*) NULL, 0);
07031
07032 G__memfunc_setup("~TGeoPatternSphTheta", 2028, G__G__Geom2_184_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07033 G__tag_memfunc_reset();
07034 }
07035
07036 static void G__setup_memfuncTGeoPatternSphPhi(void) {
07037
07038 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi));
07039 G__memfunc_setup("TGeoPatternSphPhi",1689,G__G__Geom2_185_0_1, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07040 G__memfunc_setup("TGeoPatternSphPhi",1689,G__G__Geom2_185_0_2, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi), -1, 0, 2, 1, 1, 0,
07041 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions", (char*)NULL, (void*) NULL, 0);
07042 G__memfunc_setup("TGeoPatternSphPhi",1689,G__G__Geom2_185_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi), -1, 0, 3, 1, 1, 0,
07043 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
07044 "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
07045 G__memfunc_setup("TGeoPatternSphPhi",1689,G__G__Geom2_185_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi), -1, 0, 4, 1, 1, 0,
07046 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - ndivisions "
07047 "d - 'Double_t' 0 - start d - 'Double_t' 0 - end", (char*)NULL, (void*) NULL, 0);
07048 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
07049 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
07050 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
07051 G__memfunc_setup("GetDivAxis",984,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07052 G__memfunc_setup("MakeCopy",793,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternFinder), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' reflect", (char*)NULL, (void*) NULL, 1);
07053 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
07054 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
07055 G__memfunc_setup("Class",502,G__G__Geom2_185_0_10, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternSphPhi::Class) ), 0);
07056 G__memfunc_setup("Class_Name",982,G__G__Geom2_185_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternSphPhi::Class_Name) ), 0);
07057 G__memfunc_setup("Class_Version",1339,G__G__Geom2_185_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternSphPhi::Class_Version) ), 0);
07058 G__memfunc_setup("Dictionary",1046,G__G__Geom2_185_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternSphPhi::Dictionary) ), 0);
07059 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07060 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
07061 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
07062 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_185_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07063 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_185_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternSphPhi::DeclFileName) ), 0);
07064 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_185_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternSphPhi::ImplFileLine) ), 0);
07065 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_185_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternSphPhi::ImplFileName) ), 0);
07066 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_185_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternSphPhi::DeclFileLine) ), 0);
07067
07068 G__memfunc_setup("TGeoPatternSphPhi", 1689, G__G__Geom2_185_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternSphPhi), -1, 0, 1, 1, 1, 0, "u 'TGeoPatternSphPhi' - 11 - -", (char*) NULL, (void*) NULL, 0);
07069
07070 G__memfunc_setup("~TGeoPatternSphPhi", 1815, G__G__Geom2_185_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07071 G__tag_memfunc_reset();
07072 }
07073
07074 static void G__setup_memfuncTGeoPatternHoneycomb(void) {
07075
07076 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb));
07077 G__memfunc_setup("TGeoPatternHoneycomb",2033,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb), -1, 0, 1, 1, 2, 0, "u 'TGeoPatternHoneycomb' - 11 - -", (char*)NULL, (void*) NULL, 0);
07078 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb), -1, 1, 1, 1, 2, 0, "u 'TGeoPatternHoneycomb' - 11 - -", (char*)NULL, (void*) NULL, 0);
07079 G__memfunc_setup("TGeoPatternHoneycomb",2033,G__G__Geom2_186_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07080 G__memfunc_setup("TGeoPatternHoneycomb",2033,G__G__Geom2_186_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoPatternHoneycomb), -1, 0, 2, 1, 1, 0,
07081 "U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - nrows", (char*)NULL, (void*) NULL, 0);
07082 G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idiv", (char*)NULL, (void*) NULL, 1);
07083 G__memfunc_setup("FindNode",775,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 2, 1, 1, 0,
07084 "D - 'Double_t' 0 - point D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 1);
07085 G__memfunc_setup("Class",502,G__G__Geom2_186_0_7, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPatternHoneycomb::Class) ), 0);
07086 G__memfunc_setup("Class_Name",982,G__G__Geom2_186_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternHoneycomb::Class_Name) ), 0);
07087 G__memfunc_setup("Class_Version",1339,G__G__Geom2_186_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPatternHoneycomb::Class_Version) ), 0);
07088 G__memfunc_setup("Dictionary",1046,G__G__Geom2_186_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPatternHoneycomb::Dictionary) ), 0);
07089 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07090 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
07091 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
07092 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_186_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07093 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_186_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternHoneycomb::DeclFileName) ), 0);
07094 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_186_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternHoneycomb::ImplFileLine) ), 0);
07095 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_186_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPatternHoneycomb::ImplFileName) ), 0);
07096 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_186_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPatternHoneycomb::DeclFileLine) ), 0);
07097
07098 G__memfunc_setup("~TGeoPatternHoneycomb", 2159, G__G__Geom2_186_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07099 G__tag_memfunc_reset();
07100 }
07101
07102 static void G__setup_memfuncTGeoCacheState(void) {
07103
07104 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState));
07105 G__memfunc_setup("TGeoCacheState",1348,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState), -1, 0, 1, 1, 2, 0, "u 'TGeoCacheState' - 11 - -", (char*)NULL, (void*) NULL, 0);
07106 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState), -1, 1, 1, 1, 2, 0, "u 'TGeoCacheState' - 11 - -", (char*)NULL, (void*) NULL, 0);
07107 G__memfunc_setup("TGeoCacheState",1348,G__G__Geom2_192_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07108 G__memfunc_setup("TGeoCacheState",1348,G__G__Geom2_192_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoCacheState), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - capacity", (char*)NULL, (void*) NULL, 0);
07109 G__memfunc_setup("SetState",813,G__G__Geom2_192_0_5, 121, -1, -1, 0, 5, 1, 1, 0,
07110 "i - 'Int_t' 0 - level i - 'Int_t' 0 - startlevel "
07111 "i - 'Int_t' 0 - nmany g - 'Bool_t' 0 - ovlp "
07112 "D - 'Double_t' 0 '0' point", (char*)NULL, (void*) NULL, 0);
07113 G__memfunc_setup("GetState",801,G__G__Geom2_192_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8,
07114 "i - 'Int_t' 1 - level i - 'Int_t' 1 - nmany "
07115 "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 0);
07116 G__memfunc_setup("Class",502,G__G__Geom2_192_0_7, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoCacheState::Class) ), 0);
07117 G__memfunc_setup("Class_Name",982,G__G__Geom2_192_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCacheState::Class_Name) ), 0);
07118 G__memfunc_setup("Class_Version",1339,G__G__Geom2_192_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoCacheState::Class_Version) ), 0);
07119 G__memfunc_setup("Dictionary",1046,G__G__Geom2_192_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoCacheState::Dictionary) ), 0);
07120 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07121 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
07122 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
07123 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_192_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07124 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_192_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCacheState::DeclFileName) ), 0);
07125 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_192_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCacheState::ImplFileLine) ), 0);
07126 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_192_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCacheState::ImplFileName) ), 0);
07127 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_192_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCacheState::DeclFileLine) ), 0);
07128
07129 G__memfunc_setup("~TGeoCacheState", 1474, G__G__Geom2_192_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07130 G__tag_memfunc_reset();
07131 }
07132
07133 static void G__setup_memfuncTGeoNodeCache(void) {
07134
07135 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache));
07136 G__memfunc_setup("TGeoNodeCache",1225,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache), -1, 0, 1, 1, 2, 0, "u 'TGeoNodeCache' - 11 - -", "Not implemented", (void*) NULL, 0);
07137 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache), -1, 1, 1, 1, 2, 0, "u 'TGeoNodeCache' - 11 - -", "Not implemented", (void*) NULL, 0);
07138 G__memfunc_setup("TGeoNodeCache",1225,G__G__Geom2_193_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07139 G__memfunc_setup("TGeoNodeCache",1225,G__G__Geom2_193_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNodeCache), -1, 0, 3, 1, 1, 0,
07140 "U 'TGeoNode' - 0 - top g - 'Bool_t' 0 'kFALSE' nodeid "
07141 "i - 'Int_t' 0 '30' capacity", (char*)NULL, (void*) NULL, 0);
07142 G__memfunc_setup("BuildIdArray",1180,G__G__Geom2_193_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07143 G__memfunc_setup("CdNode",557,G__G__Geom2_193_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nodeid", (char*)NULL, (void*) NULL, 0);
07144 G__memfunc_setup("CdDown",575,G__G__Geom2_193_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
07145 G__memfunc_setup("CdTop",474,G__G__Geom2_193_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07146 G__memfunc_setup("CdUp",364,G__G__Geom2_193_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07147 G__memfunc_setup("FillIdBranch",1154,G__G__Geom2_193_0_10, 121, -1, -1, 0, 2, 1, 1, 0,
07148 "I - 'Int_t' 10 - br i - 'Int_t' 0 '0' startlevel", (char*)NULL, (void*) NULL, 0);
07149 G__memfunc_setup("GetIdBranch",1051,G__G__Geom2_193_0_11, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
07150 G__memfunc_setup("GetBranch",878,G__G__Geom2_193_0_12, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07151 G__memfunc_setup("GetBranchNames",1378,G__G__Geom2_193_0_13, 121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - names", (char*)NULL, (void*) NULL, 0);
07152 G__memfunc_setup("GetBranchNumbers",1610,G__G__Geom2_193_0_14, 121, -1, -1, 0, 2, 1, 1, 8,
07153 "I - 'Int_t' 0 - copyNumbers I - 'Int_t' 0 - volumeNumbers", (char*)NULL, (void*) NULL, 0);
07154 G__memfunc_setup("GetBranchOnlys",1411,G__G__Geom2_193_0_15, 121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - isonly", (char*)NULL, (void*) NULL, 0);
07155 G__memfunc_setup("GetMatrices",1112,G__G__Geom2_193_0_16, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07156 G__memfunc_setup("GetCurrentMatrix",1656,G__G__Geom2_193_0_17, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoHMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07157 G__memfunc_setup("GetCurrentNodeId",1590,G__G__Geom2_193_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07158 G__memfunc_setup("GetMother",911,G__G__Geom2_193_0_19, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' up", (char*)NULL, (void*) NULL, 0);
07159 G__memfunc_setup("GetMotherMatrix",1540,G__G__Geom2_193_0_20, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoHMatrix), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' up", (char*)NULL, (void*) NULL, 0);
07160 G__memfunc_setup("GetNode",678,G__G__Geom2_193_0_21, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07161 G__memfunc_setup("GetTopNode",985,G__G__Geom2_193_0_22, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07162 G__memfunc_setup("GetLevel",792,G__G__Geom2_193_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07163 G__memfunc_setup("GetPath",685,G__G__Geom2_193_0_24, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
07164 G__memfunc_setup("GetStackLevel",1294,G__G__Geom2_193_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07165 G__memfunc_setup("GetNodeId",851,G__G__Geom2_193_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07166 G__memfunc_setup("HasIdArray",968,G__G__Geom2_193_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07167 G__memfunc_setup("IsDummy",712,G__G__Geom2_193_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07168 G__memfunc_setup("LocalToMaster",1306,G__G__Geom2_193_0_29, 121, -1, -1, 0, 2, 1, 1, 8,
07169 "D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
07170 G__memfunc_setup("MasterToLocal",1306,G__G__Geom2_193_0_30, 121, -1, -1, 0, 2, 1, 1, 8,
07171 "D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 0);
07172 G__memfunc_setup("LocalToMasterVect",1708,G__G__Geom2_193_0_31, 121, -1, -1, 0, 2, 1, 1, 8,
07173 "D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
07174 G__memfunc_setup("MasterToLocalVect",1708,G__G__Geom2_193_0_32, 121, -1, -1, 0, 2, 1, 1, 8,
07175 "D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 0);
07176 G__memfunc_setup("LocalToMasterBomb",1690,G__G__Geom2_193_0_33, 121, -1, -1, 0, 2, 1, 1, 8,
07177 "D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
07178 G__memfunc_setup("MasterToLocalBomb",1690,G__G__Geom2_193_0_34, 121, -1, -1, 0, 2, 1, 1, 8,
07179 "D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 0);
07180 G__memfunc_setup("PushState",929,G__G__Geom2_193_0_35, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0,
07181 "g - 'Bool_t' 0 - ovlp i - 'Int_t' 0 '0' ntmany "
07182 "i - 'Int_t' 0 '0' startlevel D - 'Double_t' 0 '0' point", (char*)NULL, (void*) NULL, 0);
07183 G__memfunc_setup("PopState",816,G__G__Geom2_193_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
07184 "i - 'Int_t' 1 - nmany D - 'Double_t' 0 '0' point", (char*)NULL, (void*) NULL, 0);
07185 G__memfunc_setup("PopState",816,G__G__Geom2_193_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
07186 "i - 'Int_t' 1 - nmany i - 'Int_t' 0 - level "
07187 "D - 'Double_t' 0 '0' point", (char*)NULL, (void*) NULL, 0);
07188 G__memfunc_setup("PopDummy",827,G__G__Geom2_193_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '9999' ipop", (char*)NULL, (void*) NULL, 0);
07189 G__memfunc_setup("Refresh",719,G__G__Geom2_193_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07190 G__memfunc_setup("RestoreState",1253,G__G__Geom2_193_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
07191 "i - 'Int_t' 1 - nmany U 'TGeoCacheState' - 0 - state "
07192 "D - 'Double_t' 0 '0' point", (char*)NULL, (void*) NULL, 0);
07193 G__memfunc_setup("Class",502,G__G__Geom2_193_0_41, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoNodeCache::Class) ), 0);
07194 G__memfunc_setup("Class_Name",982,G__G__Geom2_193_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeCache::Class_Name) ), 0);
07195 G__memfunc_setup("Class_Version",1339,G__G__Geom2_193_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoNodeCache::Class_Version) ), 0);
07196 G__memfunc_setup("Dictionary",1046,G__G__Geom2_193_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoNodeCache::Dictionary) ), 0);
07197 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07198 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
07199 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
07200 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_193_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07201 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_193_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeCache::DeclFileName) ), 0);
07202 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_193_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeCache::ImplFileLine) ), 0);
07203 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_193_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeCache::ImplFileName) ), 0);
07204 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_193_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeCache::DeclFileLine) ), 0);
07205
07206 G__memfunc_setup("~TGeoNodeCache", 1351, G__G__Geom2_193_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07207 G__tag_memfunc_reset();
07208 }
07209
07210 static void G__setup_memfuncTVirtualMagField(void) {
07211
07212 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TVirtualMagField));
07213 G__memfunc_setup("Field",484,G__G__Geom2_194_0_3, 121, -1, -1, 0, 2, 1, 1, 0,
07214 "D - 'Double_t' 10 - x D - 'Double_t' 0 - B", (char*)NULL, (void*) NULL, 3);
07215 G__memfunc_setup("Class",502,G__G__Geom2_194_0_4, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualMagField::Class) ), 0);
07216 G__memfunc_setup("Class_Name",982,G__G__Geom2_194_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualMagField::Class_Name) ), 0);
07217 G__memfunc_setup("Class_Version",1339,G__G__Geom2_194_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualMagField::Class_Version) ), 0);
07218 G__memfunc_setup("Dictionary",1046,G__G__Geom2_194_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualMagField::Dictionary) ), 0);
07219 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07220 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
07221 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
07222 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_194_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07223 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_194_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualMagField::DeclFileName) ), 0);
07224 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_194_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualMagField::ImplFileLine) ), 0);
07225 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_194_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualMagField::ImplFileName) ), 0);
07226 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_194_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualMagField::DeclFileLine) ), 0);
07227
07228 G__memfunc_setup("~TVirtualMagField", 1714, G__G__Geom2_194_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07229
07230 G__memfunc_setup("operator=", 937, G__G__Geom2_194_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Geom2LN_TVirtualMagField), -1, 1, 1, 1, 1, 0, "u 'TVirtualMagField' - 11 - -", (char*) NULL, (void*) NULL, 0);
07231 G__tag_memfunc_reset();
07232 }
07233
07234 static void G__setup_memfuncTGeoUniformMagField(void) {
07235
07236 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField));
07237 G__memfunc_setup("TGeoUniformMagField",1864,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField), -1, 0, 1, 1, 2, 0, "u 'TGeoUniformMagField' - 11 - -", (char*)NULL, (void*) NULL, 0);
07238 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField), -1, 1, 1, 1, 2, 0, "u 'TGeoUniformMagField' - 11 - -", (char*)NULL, (void*) NULL, 0);
07239 G__memfunc_setup("TGeoUniformMagField",1864,G__G__Geom2_195_0_3, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07240 G__memfunc_setup("TGeoUniformMagField",1864,G__G__Geom2_195_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoUniformMagField), -1, 0, 3, 1, 1, 0,
07241 "d - 'Double_t' 0 - Bx d - 'Double_t' 0 - By "
07242 "d - 'Double_t' 0 - Bz", (char*)NULL, (void*) NULL, 0);
07243 G__memfunc_setup("Field",484,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
07244 "D - 'Double_t' 10 - - D - 'Double_t' 0 - B", (char*)NULL, (void*) NULL, 1);
07245 G__memfunc_setup("GetFieldValue",1281,G__G__Geom2_195_0_6, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
07246 G__memfunc_setup("SetFieldValue",1293,G__G__Geom2_195_0_7, 121, -1, -1, 0, 3, 1, 1, 0,
07247 "d - 'Double_t' 0 - Bx d - 'Double_t' 0 - By "
07248 "d - 'Double_t' 0 - Bz", (char*)NULL, (void*) NULL, 0);
07249 G__memfunc_setup("Class",502,G__G__Geom2_195_0_8, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoUniformMagField::Class) ), 0);
07250 G__memfunc_setup("Class_Name",982,G__G__Geom2_195_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoUniformMagField::Class_Name) ), 0);
07251 G__memfunc_setup("Class_Version",1339,G__G__Geom2_195_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoUniformMagField::Class_Version) ), 0);
07252 G__memfunc_setup("Dictionary",1046,G__G__Geom2_195_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoUniformMagField::Dictionary) ), 0);
07253 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07254 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
07255 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
07256 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_195_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07257 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_195_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoUniformMagField::DeclFileName) ), 0);
07258 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_195_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoUniformMagField::ImplFileLine) ), 0);
07259 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_195_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoUniformMagField::ImplFileName) ), 0);
07260 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_195_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoUniformMagField::DeclFileLine) ), 0);
07261
07262 G__memfunc_setup("~TGeoUniformMagField", 1990, G__G__Geom2_195_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07263 G__tag_memfunc_reset();
07264 }
07265
07266 static void G__setup_memfuncTGeoGlobalMagField(void) {
07267
07268 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField));
07269 G__memfunc_setup("TGeoGlobalMagField",1721,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField), -1, 0, 1, 1, 2, 0, "u 'TGeoGlobalMagField' - 11 - -", (char*)NULL, (void*) NULL, 0);
07270 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField), -1, 1, 1, 1, 2, 0, "u 'TGeoGlobalMagField' - 11 - -", (char*)NULL, (void*) NULL, 0);
07271 G__memfunc_setup("Unlock",620,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
07272 G__memfunc_setup("TGeoGlobalMagField",1721,G__G__Geom2_196_0_4, 105, G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07273 G__memfunc_setup("GetField",772,G__G__Geom2_196_0_5, 85, G__get_linked_tagnum(&G__G__Geom2LN_TVirtualMagField), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07274 G__memfunc_setup("SetField",784,G__G__Geom2_196_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualMagField' - 0 - field", (char*)NULL, (void*) NULL, 0);
07275 G__memfunc_setup("IsLocked",782,G__G__Geom2_196_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07276 G__memfunc_setup("Lock",393,G__G__Geom2_196_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07277 G__memfunc_setup("Instance",821,G__G__Geom2_196_0_9, 85, G__get_linked_tagnum(&G__G__Geom2LN_TGeoGlobalMagField), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGeoGlobalMagField* (*)())(&TGeoGlobalMagField::Instance) ), 0);
07278 G__memfunc_setup("Field",484,G__G__Geom2_196_0_10, 121, -1, -1, 0, 2, 1, 1, 0,
07279 "D - 'Double_t' 10 - x D - 'Double_t' 0 - B", (char*)NULL, (void*) NULL, 0);
07280 G__memfunc_setup("Class",502,G__G__Geom2_196_0_11, 85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoGlobalMagField::Class) ), 0);
07281 G__memfunc_setup("Class_Name",982,G__G__Geom2_196_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGlobalMagField::Class_Name) ), 0);
07282 G__memfunc_setup("Class_Version",1339,G__G__Geom2_196_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoGlobalMagField::Class_Version) ), 0);
07283 G__memfunc_setup("Dictionary",1046,G__G__Geom2_196_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoGlobalMagField::Dictionary) ), 0);
07284 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07285 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
07286 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
07287 G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom2_196_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07288 G__memfunc_setup("DeclFileName",1145,G__G__Geom2_196_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGlobalMagField::DeclFileName) ), 0);
07289 G__memfunc_setup("ImplFileLine",1178,G__G__Geom2_196_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGlobalMagField::ImplFileLine) ), 0);
07290 G__memfunc_setup("ImplFileName",1171,G__G__Geom2_196_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGlobalMagField::ImplFileName) ), 0);
07291 G__memfunc_setup("DeclFileLine",1152,G__G__Geom2_196_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGlobalMagField::DeclFileLine) ), 0);
07292
07293 G__memfunc_setup("~TGeoGlobalMagField", 1847, G__G__Geom2_196_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07294 G__tag_memfunc_reset();
07295 }
07296
07297
07298
07299
07300
07301 extern "C" void G__cpp_setup_memfuncG__Geom2() {
07302 }
07303
07304
07305
07306
07307 static void G__cpp_setup_global0() {
07308
07309
07310 G__resetplocal();
07311
07312 }
07313
07314 static void G__cpp_setup_global1() {
07315 }
07316
07317 static void G__cpp_setup_global2() {
07318
07319 G__resetglobalenv();
07320 }
07321 extern "C" void G__cpp_setup_globalG__Geom2() {
07322 G__cpp_setup_global0();
07323 G__cpp_setup_global1();
07324 G__cpp_setup_global2();
07325 }
07326
07327
07328
07329
07330 static void G__cpp_setup_func0() {
07331 G__lastifuncposition();
07332
07333 }
07334
07335 static void G__cpp_setup_func1() {
07336 }
07337
07338 static void G__cpp_setup_func2() {
07339 }
07340
07341 static void G__cpp_setup_func3() {
07342
07343 G__resetifuncposition();
07344 }
07345
07346 extern "C" void G__cpp_setup_funcG__Geom2() {
07347 G__cpp_setup_func0();
07348 G__cpp_setup_func1();
07349 G__cpp_setup_func2();
07350 G__cpp_setup_func3();
07351 }
07352
07353
07354
07355
07356
07357 G__linked_taginfo G__G__Geom2LN_TClass = { "TClass" , 99 , -1 };
07358 G__linked_taginfo G__G__Geom2LN_TBuffer = { "TBuffer" , 99 , -1 };
07359 G__linked_taginfo G__G__Geom2LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
07360 G__linked_taginfo G__G__Geom2LN_TObject = { "TObject" , 99 , -1 };
07361 G__linked_taginfo G__G__Geom2LN_TNamed = { "TNamed" , 99 , -1 };
07362 G__linked_taginfo G__G__Geom2LN_TString = { "TString" , 99 , -1 };
07363 G__linked_taginfo G__G__Geom2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
07364 G__linked_taginfo G__G__Geom2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
07365 G__linked_taginfo G__G__Geom2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
07366 G__linked_taginfo G__G__Geom2LN_TObjArray = { "TObjArray" , 99 , -1 };
07367 G__linked_taginfo G__G__Geom2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
07368 G__linked_taginfo G__G__Geom2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
07369 G__linked_taginfo G__G__Geom2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
07370 G__linked_taginfo G__G__Geom2LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR = { "map<int,TGeoElementRN*,less<int>,allocator<pair<const int,TGeoElementRN*> > >" , 99 , -1 };
07371 G__linked_taginfo G__G__Geom2LN_TGeoMatrix = { "TGeoMatrix" , 99 , -1 };
07372 G__linked_taginfo G__G__Geom2LN_TGeoHMatrix = { "TGeoHMatrix" , 99 , -1 };
07373 G__linked_taginfo G__G__Geom2LN_TGeoVolume = { "TGeoVolume" , 99 , -1 };
07374 G__linked_taginfo G__G__Geom2LN_TGeoNode = { "TGeoNode" , 99 , -1 };
07375 G__linked_taginfo G__G__Geom2LN_TGeoPatternFinder = { "TGeoPatternFinder" , 99 , -1 };
07376 G__linked_taginfo G__G__Geom2LN_TGeoPatternFindercLcLEGeoPatternFlags = { "TGeoPatternFinder::EGeoPatternFlags" , 101 , -1 };
07377 G__linked_taginfo G__G__Geom2LN_TGeoPatternX = { "TGeoPatternX" , 99 , -1 };
07378 G__linked_taginfo G__G__Geom2LN_TGeoPatternY = { "TGeoPatternY" , 99 , -1 };
07379 G__linked_taginfo G__G__Geom2LN_TGeoPatternZ = { "TGeoPatternZ" , 99 , -1 };
07380 G__linked_taginfo G__G__Geom2LN_TGeoPatternParaX = { "TGeoPatternParaX" , 99 , -1 };
07381 G__linked_taginfo G__G__Geom2LN_TGeoPatternParaY = { "TGeoPatternParaY" , 99 , -1 };
07382 G__linked_taginfo G__G__Geom2LN_TGeoPatternParaZ = { "TGeoPatternParaZ" , 99 , -1 };
07383 G__linked_taginfo G__G__Geom2LN_TGeoPatternTrapZ = { "TGeoPatternTrapZ" , 99 , -1 };
07384 G__linked_taginfo G__G__Geom2LN_TGeoPatternCylR = { "TGeoPatternCylR" , 99 , -1 };
07385 G__linked_taginfo G__G__Geom2LN_TGeoPatternCylPhi = { "TGeoPatternCylPhi" , 99 , -1 };
07386 G__linked_taginfo G__G__Geom2LN_TGeoPatternSphR = { "TGeoPatternSphR" , 99 , -1 };
07387 G__linked_taginfo G__G__Geom2LN_TGeoPatternSphTheta = { "TGeoPatternSphTheta" , 99 , -1 };
07388 G__linked_taginfo G__G__Geom2LN_TGeoPatternSphPhi = { "TGeoPatternSphPhi" , 99 , -1 };
07389 G__linked_taginfo G__G__Geom2LN_TGeoPatternHoneycomb = { "TGeoPatternHoneycomb" , 99 , -1 };
07390 G__linked_taginfo G__G__Geom2LN_TGeoCacheState = { "TGeoCacheState" , 99 , -1 };
07391 G__linked_taginfo G__G__Geom2LN_TGeoNodeCache = { "TGeoNodeCache" , 99 , -1 };
07392 G__linked_taginfo G__G__Geom2LN_TVirtualMagField = { "TVirtualMagField" , 99 , -1 };
07393 G__linked_taginfo G__G__Geom2LN_TGeoUniformMagField = { "TGeoUniformMagField" , 99 , -1 };
07394 G__linked_taginfo G__G__Geom2LN_TGeoGlobalMagField = { "TGeoGlobalMagField" , 99 , -1 };
07395
07396
07397 extern "C" void G__cpp_reset_tagtableG__Geom2() {
07398 G__G__Geom2LN_TClass.tagnum = -1 ;
07399 G__G__Geom2LN_TBuffer.tagnum = -1 ;
07400 G__G__Geom2LN_TMemberInspector.tagnum = -1 ;
07401 G__G__Geom2LN_TObject.tagnum = -1 ;
07402 G__G__Geom2LN_TNamed.tagnum = -1 ;
07403 G__G__Geom2LN_TString.tagnum = -1 ;
07404 G__G__Geom2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
07405 G__G__Geom2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
07406 G__G__Geom2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
07407 G__G__Geom2LN_TObjArray.tagnum = -1 ;
07408 G__G__Geom2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
07409 G__G__Geom2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
07410 G__G__Geom2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
07411 G__G__Geom2LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR.tagnum = -1 ;
07412 G__G__Geom2LN_TGeoMatrix.tagnum = -1 ;
07413 G__G__Geom2LN_TGeoHMatrix.tagnum = -1 ;
07414 G__G__Geom2LN_TGeoVolume.tagnum = -1 ;
07415 G__G__Geom2LN_TGeoNode.tagnum = -1 ;
07416 G__G__Geom2LN_TGeoPatternFinder.tagnum = -1 ;
07417 G__G__Geom2LN_TGeoPatternFindercLcLEGeoPatternFlags.tagnum = -1 ;
07418 G__G__Geom2LN_TGeoPatternX.tagnum = -1 ;
07419 G__G__Geom2LN_TGeoPatternY.tagnum = -1 ;
07420 G__G__Geom2LN_TGeoPatternZ.tagnum = -1 ;
07421 G__G__Geom2LN_TGeoPatternParaX.tagnum = -1 ;
07422 G__G__Geom2LN_TGeoPatternParaY.tagnum = -1 ;
07423 G__G__Geom2LN_TGeoPatternParaZ.tagnum = -1 ;
07424 G__G__Geom2LN_TGeoPatternTrapZ.tagnum = -1 ;
07425 G__G__Geom2LN_TGeoPatternCylR.tagnum = -1 ;
07426 G__G__Geom2LN_TGeoPatternCylPhi.tagnum = -1 ;
07427 G__G__Geom2LN_TGeoPatternSphR.tagnum = -1 ;
07428 G__G__Geom2LN_TGeoPatternSphTheta.tagnum = -1 ;
07429 G__G__Geom2LN_TGeoPatternSphPhi.tagnum = -1 ;
07430 G__G__Geom2LN_TGeoPatternHoneycomb.tagnum = -1 ;
07431 G__G__Geom2LN_TGeoCacheState.tagnum = -1 ;
07432 G__G__Geom2LN_TGeoNodeCache.tagnum = -1 ;
07433 G__G__Geom2LN_TVirtualMagField.tagnum = -1 ;
07434 G__G__Geom2LN_TGeoUniformMagField.tagnum = -1 ;
07435 G__G__Geom2LN_TGeoGlobalMagField.tagnum = -1 ;
07436 }
07437
07438
07439 extern "C" void G__cpp_setup_tagtableG__Geom2() {
07440
07441
07442 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TClass);
07443 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TBuffer);
07444 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TMemberInspector);
07445 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TObject);
07446 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TNamed);
07447 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TString);
07448 G__get_linked_tagnum_fwd(&G__G__Geom2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
07449 G__get_linked_tagnum_fwd(&G__G__Geom2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
07450 G__get_linked_tagnum_fwd(&G__G__Geom2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
07451 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TObjArray);
07452 G__get_linked_tagnum_fwd(&G__G__Geom2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
07453 G__get_linked_tagnum_fwd(&G__G__Geom2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
07454 G__get_linked_tagnum_fwd(&G__G__Geom2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
07455 G__get_linked_tagnum_fwd(&G__G__Geom2LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR);
07456 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoMatrix);
07457 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoHMatrix);
07458 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoVolume);
07459 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoNode);
07460 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternFinder),sizeof(TGeoPatternFinder),-1,327424,"patterns to divide volumes",G__setup_memvarTGeoPatternFinder,G__setup_memfuncTGeoPatternFinder);
07461 G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternFindercLcLEGeoPatternFlags);
07462 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternX),sizeof(TGeoPatternX),-1,324864,"X division pattern",G__setup_memvarTGeoPatternX,G__setup_memfuncTGeoPatternX);
07463 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternY),sizeof(TGeoPatternY),-1,324864,"Y division pattern",G__setup_memvarTGeoPatternY,G__setup_memfuncTGeoPatternY);
07464 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternZ),sizeof(TGeoPatternZ),-1,324864,"Z division pattern",G__setup_memvarTGeoPatternZ,G__setup_memfuncTGeoPatternZ);
07465 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternParaX),sizeof(TGeoPatternParaX),-1,324864,"Para X division pattern",G__setup_memvarTGeoPatternParaX,G__setup_memfuncTGeoPatternParaX);
07466 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternParaY),sizeof(TGeoPatternParaY),-1,324864,"Para Y division pattern",G__setup_memvarTGeoPatternParaY,G__setup_memfuncTGeoPatternParaY);
07467 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternParaZ),sizeof(TGeoPatternParaZ),-1,324864,"Para Z division pattern",G__setup_memvarTGeoPatternParaZ,G__setup_memfuncTGeoPatternParaZ);
07468 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternTrapZ),sizeof(TGeoPatternTrapZ),-1,324864,"Trap od Gtra Z division pattern",G__setup_memvarTGeoPatternTrapZ,G__setup_memfuncTGeoPatternTrapZ);
07469 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternCylR),sizeof(TGeoPatternCylR),-1,324864,"Cylindrical R division pattern",G__setup_memvarTGeoPatternCylR,G__setup_memfuncTGeoPatternCylR);
07470 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternCylPhi),sizeof(TGeoPatternCylPhi),-1,327424,"Cylindrical phi division pattern",G__setup_memvarTGeoPatternCylPhi,G__setup_memfuncTGeoPatternCylPhi);
07471 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternSphR),sizeof(TGeoPatternSphR),-1,324864,"spherical R division pattern",G__setup_memvarTGeoPatternSphR,G__setup_memfuncTGeoPatternSphR);
07472 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternSphTheta),sizeof(TGeoPatternSphTheta),-1,324864,"spherical theta division pattern",G__setup_memvarTGeoPatternSphTheta,G__setup_memfuncTGeoPatternSphTheta);
07473 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternSphPhi),sizeof(TGeoPatternSphPhi),-1,324864,"Spherical phi division pattern",G__setup_memvarTGeoPatternSphPhi,G__setup_memfuncTGeoPatternSphPhi);
07474 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoPatternHoneycomb),sizeof(TGeoPatternHoneycomb),-1,327424,"pattern for honeycomb divisions",G__setup_memvarTGeoPatternHoneycomb,G__setup_memfuncTGeoPatternHoneycomb);
07475 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoCacheState),sizeof(TGeoCacheState),-1,327424,"class storing the cache state",G__setup_memvarTGeoCacheState,G__setup_memfuncTGeoCacheState);
07476 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoNodeCache),sizeof(TGeoNodeCache),-1,327424,"cache of reusable physical nodes",G__setup_memvarTGeoNodeCache,G__setup_memfuncTGeoNodeCache);
07477 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TVirtualMagField),sizeof(TVirtualMagField),-1,324865,"Abstract base field class",G__setup_memvarTVirtualMagField,G__setup_memfuncTVirtualMagField);
07478 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoUniformMagField),sizeof(TGeoUniformMagField),-1,327424,"Uniform magnetic field ",G__setup_memvarTGeoUniformMagField,G__setup_memfuncTGeoUniformMagField);
07479 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom2LN_TGeoGlobalMagField),sizeof(TGeoGlobalMagField),-1,32512,"Global field manager",G__setup_memvarTGeoGlobalMagField,G__setup_memfuncTGeoGlobalMagField);
07480 }
07481 extern "C" void G__cpp_setupG__Geom2(void) {
07482 G__check_setup_version(30051515,"G__cpp_setupG__Geom2()");
07483 G__set_cpp_environmentG__Geom2();
07484 G__cpp_setup_tagtableG__Geom2();
07485
07486 G__cpp_setup_inheritanceG__Geom2();
07487
07488 G__cpp_setup_typetableG__Geom2();
07489
07490 G__cpp_setup_memvarG__Geom2();
07491
07492 G__cpp_setup_memfuncG__Geom2();
07493 G__cpp_setup_globalG__Geom2();
07494 G__cpp_setup_funcG__Geom2();
07495
07496 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Geom2();
07497 return;
07498 }
07499 class G__cpp_setup_initG__Geom2 {
07500 public:
07501 G__cpp_setup_initG__Geom2() { G__add_setup_func("G__Geom2",(G__incsetup)(&G__cpp_setupG__Geom2)); G__call_setup_funcs(); }
07502 ~G__cpp_setup_initG__Geom2() { G__remove_setup_func("G__Geom2"); }
07503 };
07504 G__cpp_setup_initG__Geom2 G__cpp_setup_initializerG__Geom2;
07505