Adding my own class

ROOT
1

Hi,
I’m trying to create a class that I can use in conjunction with ROOT so that I can write it to branches etc. The files attached show the class, EventCluster, along with the Linkdef.h. The class makes fine, along with the other classes in the library, but when I try to use

EventCluster *theCluster = new EventCluster();
TTree *tree=0;
tree->Branch(“cluster”,“EventCluster”,&theCluster);
I get the error:

Warning in TClass::TClass: no dictionary for class EventCluster is available
Error in TTree::Bronch: Cannot find dictionary for class: EventCluster

The class is being found OK by my program, but ROOT is having problems recongnising it - how am I linking or defining the class incorrectly?

Thanks
Matt
LinkDef.h (331 Bytes)
EventCluster.h (2.3 KB)
EventCluster.cxx (1.97 KB)

2

It looks like although you have a LinkDef.h file, you did not produce a dictionary (via rootcint) for your class. I suggest teh following simple recipee:

root > .L EventCluster.cxx+ root > //create your file and tree header root > EventCluster *theCluster = new EventCluster(); root > tree->Branch("cluster","EventCluster",&theCluster);
Rene

3

I thought that the following Makefile would produce the dictionary (correlatorDict):

include Makefile.arch

#Site Specific  Flags
SYSINCLUDES	= -I/sw/include
SYSLIBS         = -L/sw/lib

ifdef ANITA_UTIL_INSTALL_DIR
ANITA_UTIL_LIB_DIR=${ANITA_UTIL_INSTALL_DIR}/lib
ANITA_UTIL_INC_DIR=${ANITA_UTIL_INSTALL_DIR}/include
LD_ANITA_UTIL=-L$(ANITA_UTIL_LIB_DIR) -lAnitaEvent 
INC_ANITA_UTIL=-I$(ANITA_UTIL_INC_DIR)
else
ANITA_UTIL_LIB_DIR=/usr/local/lib
ANITA_UTIL_INC_DIR=/usr/local/include
ifdef EVENT_READER_DIR
LD_ANITA_UTIL=-L$(EVENT_READER_DIR)
INC_ANITA_UTIL=-I$(EVENT_READER_DIR)
endif
endif



#Toggles the FFT functions on and off
USE_FFT_TOOLS=1

ifdef USE_FFT_TOOLS
FFTLIBS = -lRootFftwWrapper -lfftw3
FFTFLAG = -DUSE_FFT_TOOLS
else
FFTLIBS =
FFTFLAG =
endif

export USE_GOOGLE_PROFILER=1
ifdef USE_GOOGLE_PROFILER
SYSINCLUDES += -I/unix/anita1/software/install/include/google
SYSLIBS +=-L/unix/anita1/software/install/lib/
endif

#Generic and Site Specific Flags
CXXFLAGS     += $(ROOTCFLAGS) $(FFTFLAG) $(SYSINCLUDES) $(INC_ANITA_UTIL)
LDFLAGS      += -g $(ROOTLDFLAGS) 

LIBS          = $(ROOTLIBS) -lMathMore -lMinuit $(SYSLIBS) $(LD_ANITA_UTIL) $(FFTLIBS) 
GLIBS         = $(ROOTGLIBS) $(SYSLIBS)

#Now the bits we're actually compiling


#ROOT stuff

ROOT_LIBRARY = libAnitaEventRelocator.${DLLSUF}
LIB_OBJS = CrossCorrelatorGeometry.o CrossCorrelator.o CorrelatorTools.o EventCluster.o FlightAndTraverse.o correlatorDict.o 
CLASS_HEADERS =  CrossCorrelatorGeometry.h CrossCorrelator.h CorrelatorTools.h EventCluster.h FlightAndTraverse.h correlationDefs.h 

all : $(ROOT_LIBRARY) 


#The library
$(ROOT_LIBRARY) : $(LIB_OBJS) 
	@echo "Linking $@ ..."
ifeq ($(PLATFORM),macosx)
# We need to make both the .dylib and the .so
	$(LD)   $(SOFLAGS) $^ $(OutPutOpt) $@
ifeq ($(MACOSX_MINOR),4)
	ln -sf $@ $(subst .$(DLLSUF),.so,$@)
else
	$(LD) -bundle -undefined $(UNDEFOPT)  $(LDFLAGS) $^ \
	 $(OutPutOpt) $(subst .$(DLLSUF),.so,$@)
endif
else
	$(LD) $(SOFLAGS) $(LDFLAGS) $(LIBS) $(LIB_OBJS) -o $@
endif

%.$(OBJSUF) : %.$(SRCSUF)
	@echo "<**Compiling**> "$<
	$(CXX) $(CXXFLAGS) -c $< -o  $@

%.$(OBJSUF) : %.C
	@echo "<**Compiling**> "$<
	$(CXX) $(CXXFLAGS) $ -c $< -o  $@



correlatorDict.C: $(CLASS_HEADERS)
	@echo "Generating dictionary ..."
	@ rm -f *Dict* 
	rootcint $@ -c $(CXXFLAGS) $(CLASS_HEADERS) LinkDef.h


install: $(ROOT_LIBRARY)
ifeq ($(PLATFORM),macosx)
	install -c -m 755 $(ROOT_LIBRARY) $(subst .$(DLLSUF),.so,$(ROOT_LIBRARY)) $(ANITA_UTIL_LIB_DIR)
else
	install -c -m 755 $(ROOT_LIBRARY) $(ANITA_UTIL_LIB_DIR)
endif
	install -c -m 644  $(CLASS_HEADERS) $(ANITA_UTIL_INC_DIR)

clean:
	@rm -f *Dict*
	@rm -f *.${OBJSUF}
	@rm -f $(LIBRARY)
	@rm -f $(ROOT_LIBRARY)
	@rm -f $(subst .$(DLLSUF),.so,$(ROOT_LIBRARY))	
	@rm -f $(TEST)
4

Hi,

looks good - can you remove all the silencing ‘@’ from your Makefile, run it from scratch (i.e. with all .o and Dict removed!) and post the output?

Cheers, Axel

5 
<**Compiling**> CrossCorrelatorGeometry.cxx
g++  -g -Wall -fPIC -pthread -m64 -I/unix/anita1/anita/software/root/include -DUSE_FFT_TOOLS -I/sw/include -I/unix/anita1/software/install/include/google -I/home/mottram/work/install/include -c CrossCorrelatorGeometry.cxx -o  CrossCorrelatorGeometry.o
<**Compiling**> CrossCorrelator.cxx
g++  -g -Wall -fPIC -pthread -m64 -I/unix/anita1/anita/software/root/include -DUSE_FFT_TOOLS -I/sw/include -I/unix/anita1/software/install/include/google -I/home/mottram/work/install/include -c CrossCorrelator.cxx -o  CrossCorrelator.o
CrossCorrelator.cxx: In member function `void CrossCorrelator::coherentlySummedWaveformFiltered(CrossCorrelatorGeometry*)':CrossCorrelator.cxx:1854: warning: unused variable 'cosFineMidTheta'
CrossCorrelator.cxx:1855: warning: unused variable 'cosFineMidPhi'
CrossCorrelator.cxx:1856: warning: unused variable 'sinFineMidTheta'
CrossCorrelator.cxx:1857: warning: unused variable 'sinFineMidPhi'
CrossCorrelator.cxx: In member function `TGraph* CrossCorrelator::getSummedWaveform(CrossCorrelatorGeometry*)':
CrossCorrelator.cxx:3158: warning: deleting array `TGraph*grFinalAdjust[13]'
CrossCorrelator.cxx: In member function `double CrossCorrelator::getHilbertMax(TGraph*)':
CrossCorrelator.cxx:3168: warning: unused variable 'tArrayHil'
<**Compiling**> CorrelatorTools.cxx
g++  -g -Wall -fPIC -pthread -m64 -I/unix/anita1/anita/software/root/include -DUSE_FFT_TOOLS -I/sw/include -I/unix/anita1/software/install/include/google -I/home/mottram/work/install/include -c CorrelatorTools.cxx -o  CorrelatorTools.o
<**Compiling**> EventCluster.cxx
g++  -g -Wall -fPIC -pthread -m64 -I/unix/anita1/anita/software/root/include -DUSE_FFT_TOOLS -I/sw/include -I/unix/anita1/software/install/include/google -I/home/mottram/work/install/include -c EventCluster.cxx -o  EventCluster.o
<**Compiling**> FlightAndTraverse.cxx
g++  -g -Wall -fPIC -pthread -m64 -I/unix/anita1/anita/software/root/include -DUSE_FFT_TOOLS -I/sw/include -I/unix/anita1/software/install/include/google -I/home/mottram/work/install/include -c FlightAndTraverse.cxx -o  FlightAndTraverse.o
Generating dictionary ...
rm -f *Dict*
rootcint correlatorDict.C -c  -g -Wall -fPIC -pthread -m64 -I/unix/anita1/anita/software/root/include -DUSE_FFT_TOOLS -I/sw/include -I/unix/anita1/software/install/include/google -I/home/mottram/work/install/include CrossCorrelatorGeometry.h CrossCorrelator.h CorrelatorTools.h EventCluster.h FlightAndTraverse.h correlationDefs.h  LinkDef.h
In file included from /unix/anita1/anita/software/root/include/Rtypes.h:24,
                 from /unix/anita1/anita/software/root/include/TObject.h:31,
                 from /tmp/cff3p5_cint.cxx:1:
/unix/anita1/anita/software/root/include/RConfig.h:215:1: warning: "R__B64" redefined
<command line>:14:1: warning: this is the location of the previous definition
In file included from /unix/anita1/anita/software/root/include/Rtypes.h:24,
                 from /unix/anita1/anita/software/root/include/TObject.h:31,
                 from /unix/anita1/anita/software/root/include/TMemberInspector.h:27,
                 from /tmp/sLVK0o_cint.cxx:1:
/unix/anita1/anita/software/root/include/RConfig.h:215:1: warning: "R__B64" redefined
<command line>:14:1: warning: this is the location of the previous definition
In file included from /unix/anita1/anita/software/root/include/Rtypes.h:24,
                 from /home/mottram/work/install/include/AnitaConventions.h:54,
                 from ./CrossCorrelatorGeometry.h:17,
                 from /tmp/Aj5GxJ_cint.cxx:1:
/unix/anita1/anita/software/root/include/RConfig.h:215:1: warning: "R__B64" redefined
<command line>:14:1: warning: this is the location of the previous definition
In file included from /unix/anita1/anita/software/root/include/Rtypes.h:24,
                 from /home/mottram/work/install/include/AnitaConventions.h:54,
                 from ./CrossCorrelator.h:14,
                 from /tmp/OmNSX6_cint.cxx:1:
/unix/anita1/anita/software/root/include/RConfig.h:215:1: warning: "R__B64" redefined
<command line>:14:1: warning: this is the location of the previous definition
In file included from /unix/anita1/anita/software/root/include/Rtypes.h:24,
                 from /home/mottram/work/install/include/AnitaConventions.h:54,
                 from ./CorrelatorTools.h:14,
                 from /tmp/aTPXDd_cint.cxx:1:
/unix/anita1/anita/software/root/include/RConfig.h:215:1: warning: "R__B64" redefined
<command line>:14:1: warning: this is the location of the previous definition
In file included from /unix/anita1/anita/software/root/include/Rtypes.h:24,
                 from /unix/anita1/anita/software/root/include/TObject.h:31,
                 from ./EventCluster.h:14,
                 from /tmp/48qW2o_cint.cxx:1:
/unix/anita1/anita/software/root/include/RConfig.h:215:1: warning: "R__B64" redefined
<command line>:14:1: warning: this is the location of the previous definition
In file included from /unix/anita1/anita/software/root/include/Rtypes.h:24,
                 from /unix/anita1/anita/software/root/include/TObject.h:31,
                 from /unix/anita1/anita/software/root/include/TNamed.h:26,
                 from /unix/anita1/anita/software/root/include/TDirectory.h:25,
                 from /unix/anita1/anita/software/root/include/TDirectoryFile.h:25,
                 from /unix/anita1/anita/software/root/include/TFile.h:25,
                 from ./FlightAndTraverse.h:13,
                 from /tmp/wGUFKE_cint.cxx:1:
/unix/anita1/anita/software/root/include/RConfig.h:215:1: warning: "R__B64" redefined
<command line>:14:1: warning: this is the location of the previous definition
<**Compiling**> correlatorDict.C
g++  -g -Wall -fPIC -pthread -m64 -I/unix/anita1/anita/software/root/include -DUSE_FFT_TOOLS -I/sw/include -I/unix/anita1/software/install/include/google -I/home/mottram/work/install/include -c correlatorDict.C -o  correlatorDict.o
Linking libAnitaEventRelocator.so ...
g++ -shared  -g -g -m64  -L/unix/anita1/anita/software/root/lib -lCore -lCint -lRIO -lNet -lHist -lGraf -lGraf3d -lGpad -lTree -lRint -lPostscript -lMatrix -lPhysics -lMathCore -lThread -pthread -lm -ldl -rdynamic -lMathMore -lMinuit -L/sw/lib -L/unix/anita1/software/install/lib/ -L/home/mottram/work/install/lib -lAnitaEvent  -lRootFftwWrapper -lfftw3  CrossCorrelatorGeometry.o CrossCorrelator.o CorrelatorTools.o EventCluster.o FlightAndTraverse.o correlatorDict.o  -o libAnitaEventRelocator.so

… I’m pretty sure the dictionary is generated, but still no joy in writing the EventCluster class to a root branch/tree structure

6

Hi,

weird. Can you post the generated dictionary (just the .C file).

Cheers, Axel.

7

Here is the dictionary correlatorDict.C (posted in 3 parts because it’s too long for one post!!)…:

[code]
//
// File generated by rootcint at Wed Oct 21 14:30:58 2009

// Do NOT change. Changes will be lost next time file is generated
//

#include “RConfig.h” //rootcint 4834
#if !defined(R__ACCESS_IN_SYMBOL)
//Break the privacy of classes – Disabled for the moment
#define private public
#define protected public
#endif

// Since CINT ignores the std namespace, we need to do so in this file.
namespace std {} using namespace std;
#include “correlatorDict.h”

#include “TCollectionProxyInfo.h”
#include “TClass.h”
#include “TBuffer.h”
#include “TMemberInspector.h”
#include “TError.h”

#ifndef G__ROOT
#define G__ROOT
#endif

#include “RtypesImp.h”
#include “TIsAProxy.h”

// START OF SHADOWS

namespace ROOT {
namespace Shadow {
#if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
typedef ::CorrelatorTools CorrelatorTools;
#else
class CorrelatorTools {
public:
//friend XX;
};
#endif

  #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
  typedef ::FlightAndTraverse FlightAndTraverse;
  #else
  class FlightAndTraverse  {
     public:
     //friend XX;
     ::TFile* flightFiles[7][71]; //
     ::TTree* flightTrees[7][71]; //
     unsigned int flightTime[7][71]; //
     double flightLat[7][71]; //
     double flightLon[7][71]; //
     double flightAlt[7][71]; //
     int flightEntry[7][71][3]; //
     unsigned int flightTimes[7][71][3]; //
     unsigned int numFlightsInData[7]; //
  };
  #endif

} // of namespace Shadow
} // of namespace ROOT
// END OF SHADOWS

namespace ROOT {
void CrossCorrelatorGeometry_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
static void *new_CrossCorrelatorGeometry(void *p = 0);
static void *newArray_CrossCorrelatorGeometry(Long_t size, void *p);
static void delete_CrossCorrelatorGeometry(void *p);
static void deleteArray_CrossCorrelatorGeometry(void *p);
static void destruct_CrossCorrelatorGeometry(void *p);

// Function generating the singleton type initializer
static TGenericClassInfo GenerateInitInstanceLocal(const ::CrossCorrelatorGeometry)
{
::CrossCorrelatorGeometry ptr = 0;
static ::TVirtualIsAProxy isa_proxy = new ::TInstrumentedIsAProxy< ::CrossCorrelatorGeometry >(0);
static ::ROOT::TGenericClassInfo
instance(“CrossCorrelatorGeometry”, ::CrossCorrelatorGeometry::Class_Version(), “CrossCorrelatorGeometry.h”, 25,
typeid(::CrossCorrelatorGeometry), DefineBehavior(ptr, ptr),
&::CrossCorrelatorGeometry::Dictionary, isa_proxy, 4,
sizeof(::CrossCorrelatorGeometry) );
instance.SetNew(&new_CrossCorrelatorGeometry);
instance.SetNewArray(&newArray_CrossCorrelatorGeometry);
instance.SetDelete(&delete_CrossCorrelatorGeometry);
instance.SetDeleteArray(&deleteArray_CrossCorrelatorGeometry);
instance.SetDestructor(&destruct_CrossCorrelatorGeometry);
return &instance;
}
TGenericClassInfo GenerateInitInstance(const ::CrossCorrelatorGeometry)
{
return GenerateInitInstanceLocal((::CrossCorrelatorGeometry*)0);
}
// Static variable to force the class initialization
static ::ROOT::TGenericClassInfo R__UNIQUE(Init) = GenerateInitInstanceLocal((const ::CrossCorrelatorGeometry)0x0); R__UseDummy(R__UNIQUE(Init));
} // end of namespace ROOT

namespace ROOT {
void CrossCorrelator_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
static void *new_CrossCorrelator(void *p = 0);
static void *newArray_CrossCorrelator(Long_t size, void *p);
static void delete_CrossCorrelator(void *p);
static void deleteArray_CrossCorrelator(void *p);
static void destruct_CrossCorrelator(void *p);

// Function generating the singleton type initializer
static TGenericClassInfo GenerateInitInstanceLocal(const ::CrossCorrelator)
{
::CrossCorrelator ptr = 0;
static ::TVirtualIsAProxy isa_proxy = new ::TInstrumentedIsAProxy< ::CrossCorrelator >(0);
static ::ROOT::TGenericClassInfo
instance(“CrossCorrelator”, ::CrossCorrelator::Class_Version(), “CrossCorrelator.h”, 25,
typeid(::CrossCorrelator), DefineBehavior(ptr, ptr),
&::CrossCorrelator::Dictionary, isa_proxy, 4,
sizeof(::CrossCorrelator) );
instance.SetNew(&new_CrossCorrelator);
instance.SetNewArray(&newArray_CrossCorrelator);
instance.SetDelete(&delete_CrossCorrelator);
instance.SetDeleteArray(&deleteArray_CrossCorrelator);
instance.SetDestructor(&destruct_CrossCorrelator);
return &instance;
}
TGenericClassInfo GenerateInitInstance(const ::CrossCorrelator)
{
return GenerateInitInstanceLocal((::CrossCorrelator*)0);
}
// Static variable to force the class initialization
static ::ROOT::TGenericClassInfo R__UNIQUE(Init) = GenerateInitInstanceLocal((const ::CrossCorrelator)0x0); R__UseDummy(R__UNIQUE(Init));
} // end of namespace ROOT

namespace ROOT {
void CorrelatorTools_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
static void CorrelatorTools_Dictionary();
static void *new_CorrelatorTools(void *p = 0);
static void *newArray_CorrelatorTools(Long_t size, void *p);
static void delete_CorrelatorTools(void *p);
static void deleteArray_CorrelatorTools(void *p);
static void destruct_CorrelatorTools(void *p);

// Function generating the singleton type initializer
static TGenericClassInfo GenerateInitInstanceLocal(const ::CorrelatorTools)
{
// Make sure the shadow class has the right sizeof
R__ASSERT(sizeof(::CorrelatorTools) == sizeof(::ROOT::Shadow::CorrelatorTools));
::CorrelatorTools ptr = 0;
static ::TVirtualIsAProxy isa_proxy = new ::TIsAProxy(typeid(::CorrelatorTools),0);
static ::ROOT::TGenericClassInfo
instance(“CorrelatorTools”, “CorrelatorTools.h”, 27,
typeid(::CorrelatorTools), DefineBehavior(ptr, ptr),
(void*)&CorrelatorTools_ShowMembers, &CorrelatorTools_Dictionary, isa_proxy, 4,
sizeof(::CorrelatorTools) );
instance.SetNew(&new_CorrelatorTools);
instance.SetNewArray(&newArray_CorrelatorTools);
instance.SetDelete(&delete_CorrelatorTools);
instance.SetDeleteArray(&deleteArray_CorrelatorTools);
instance.SetDestructor(&destruct_CorrelatorTools);
return &instance;
}
TGenericClassInfo GenerateInitInstance(const ::CorrelatorTools)
{
return GenerateInitInstanceLocal((::CorrelatorTools*)0);
}
// Static variable to force the class initialization
static ::ROOT::TGenericClassInfo R__UNIQUE(Init) = GenerateInitInstanceLocal((const ::CorrelatorTools)0x0); R__UseDummy(R__UNIQUE(Init));

// Dictionary for non-ClassDef classes
static void CorrelatorTools_Dictionary() {
::ROOT::GenerateInitInstanceLocal((const ::CorrelatorTools*)0x0)->GetClass();
}

} // end of namespace ROOT

namespace ROOT {
void EventCluster_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
static void *new_EventCluster(void *p = 0);
static void *newArray_EventCluster(Long_t size, void *p);
static void delete_EventCluster(void *p);
static void deleteArray_EventCluster(void *p);
static void destruct_EventCluster(void *p);

// Function generating the singleton type initializer
static TGenericClassInfo GenerateInitInstanceLocal(const ::EventCluster)
{
::EventCluster ptr = 0;
static ::TVirtualIsAProxy isa_proxy = new ::TInstrumentedIsAProxy< ::EventCluster >(0);
static ::ROOT::TGenericClassInfo
instance(“EventCluster”, ::EventCluster::Class_Version(), “EventCluster.h”, 18,
typeid(::EventCluster), DefineBehavior(ptr, ptr),
&::EventCluster::Dictionary, isa_proxy, 4,
sizeof(::EventCluster) );
instance.SetNew(&new_EventCluster);
instance.SetNewArray(&newArray_EventCluster);
instance.SetDelete(&delete_EventCluster);
instance.SetDeleteArray(&deleteArray_EventCluster);
instance.SetDestructor(&destruct_EventCluster);
return &instance;
}
TGenericClassInfo GenerateInitInstance(const ::EventCluster)
{
return GenerateInitInstanceLocal((::EventCluster*)0);
}
// Static variable to force the class initialization
static ::ROOT::TGenericClassInfo R__UNIQUE(Init) = GenerateInitInstanceLocal((const ::EventCluster)0x0); R__UseDummy(R__UNIQUE(Init));
} // end of namespace ROOT

namespace ROOT {
void FlightAndTraverse_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
static void FlightAndTraverse_Dictionary();
static void *new_FlightAndTraverse(void *p = 0);
static void *newArray_FlightAndTraverse(Long_t size, void *p);
static void delete_FlightAndTraverse(void *p);
static void deleteArray_FlightAndTraverse(void *p);
static void destruct_FlightAndTraverse(void *p);

// Function generating the singleton type initializer
static TGenericClassInfo GenerateInitInstanceLocal(const ::FlightAndTraverse)
{
// Make sure the shadow class has the right sizeof
R__ASSERT(sizeof(::FlightAndTraverse) == sizeof(::ROOT::Shadow::FlightAndTraverse));
::FlightAndTraverse ptr = 0;
static ::TVirtualIsAProxy isa_proxy = new ::TIsAProxy(typeid(::FlightAndTraverse),0);
static ::ROOT::TGenericClassInfo
instance(“FlightAndTraverse”, “FlightAndTraverse.h”, 19,
typeid(::FlightAndTraverse), DefineBehavior(ptr, ptr),
(void*)&FlightAndTraverse_ShowMembers, &FlightAndTraverse_Dictionary, isa_proxy, 4,
sizeof(::FlightAndTraverse) );
instance.SetNew(&new_FlightAndTraverse);
instance.SetNewArray(&newArray_FlightAndTraverse);
instance.SetDelete(&delete_FlightAndTraverse);
instance.SetDeleteArray(&deleteArray_FlightAndTraverse);
instance.SetDestructor(&destruct_FlightAndTraverse);
return &instance;
}
TGenericClassInfo GenerateInitInstance(const ::FlightAndTraverse)
{
return GenerateInitInstanceLocal((::FlightAndTraverse*)0);
}
// Static variable to force the class initialization
static ::ROOT::TGenericClassInfo R__UNIQUE(Init) = GenerateInitInstanceLocal((const ::FlightAndTraverse)0x0); R__UseDummy(R__UNIQUE(Init));

// Dictionary for non-ClassDef classes
static void FlightAndTraverse_Dictionary() {
::ROOT::GenerateInitInstanceLocal((const ::FlightAndTraverse*)0x0)->GetClass();
}

} // end of namespace ROOT

//______________________________________________________________________________
TClass *CrossCorrelatorGeometry::fgIsA = 0; // static to hold class pointer

//______________________________________________________________________________
const char *CrossCorrelatorGeometry::Class_Name()
{
return “CrossCorrelatorGeometry”;
}

//______________________________________________________________________________
const char CrossCorrelatorGeometry::ImplFileName()
{
return ::ROOT::GenerateInitInstanceLocal((const ::CrossCorrelatorGeometry)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int CrossCorrelatorGeometry::ImplFileLine()
{
return ::ROOT::GenerateInitInstanceLocal((const ::CrossCorrelatorGeometry*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void CrossCorrelatorGeometry::Dictionary()
{
fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CrossCorrelatorGeometry*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass CrossCorrelatorGeometry::Class()
{
if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CrossCorrelatorGeometry)0x0)->GetClass();
return fgIsA;
}

//______________________________________________________________________________
TClass *CrossCorrelator::fgIsA = 0; // static to hold class pointer

//______________________________________________________________________________
const char *CrossCorrelator::Class_Name()
{
return “CrossCorrelator”;
}

//______________________________________________________________________________
const char CrossCorrelator::ImplFileName()
{
return ::ROOT::GenerateInitInstanceLocal((const ::CrossCorrelator)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int CrossCorrelator::ImplFileLine()
{
return ::ROOT::GenerateInitInstanceLocal((const ::CrossCorrelator*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void CrossCorrelator::Dictionary()
{
fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CrossCorrelator*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass CrossCorrelator::Class()
{
if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CrossCorrelator)0x0)->GetClass();
return fgIsA;
}

//______________________________________________________________________________
TClass *EventCluster::fgIsA = 0; // static to hold class pointer

//______________________________________________________________________________
const char *EventCluster::Class_Name()
{
return “EventCluster”;
}

//______________________________________________________________________________
const char EventCluster::ImplFileName()
{
return ::ROOT::GenerateInitInstanceLocal((const ::EventCluster)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int EventCluster::ImplFileLine()
{
return ::ROOT::GenerateInitInstanceLocal((const ::EventCluster*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void EventCluster::Dictionary()
{
fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventCluster*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass EventCluster::Class()
{
if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventCluster)0x0)->GetClass();
return fgIsA;
}

//______________________________________________________________________________
void CrossCorrelatorGeometry::Streamer(TBuffer &R__b)
{
// Stream an object of class CrossCorrelatorGeometry.

if (R__b.IsReading()) {
R__b.ReadClassBuffer(CrossCorrelatorGeometry::Class(),this);
} else {
R__b.WriteClassBuffer(CrossCorrelatorGeometry::Class(),this);
}
}

//______________________________________________________________________________
void CrossCorrelatorGeometry::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
// Inspect the data members of an object of class CrossCorrelatorGeometry.
TClass *R__cl = ::CrossCorrelatorGeometry::IsA();
Int_t R__ncp = strlen(R__parent);
if (R__ncp || R__cl || R__insp.IsA()) { }
R__insp.Inspect(R__cl, R__parent, “phiArray[180]”, phiArray);
R__insp.Inspect(R__cl, R__parent, “thetaArray[90]”, thetaArray);
R__insp.Inspect(R__cl, R__parent, “cosPhiArray[180]”, cosPhiArray);
R__insp.Inspect(R__cl, R__parent, “cosThetaArray[90]”, cosThetaArray);
R__insp.Inspect(R__cl, R__parent, “sinPhiArray[180]”, sinPhiArray);
R__insp.Inspect(R__cl, R__parent, “sinThetaArray[90]”, sinThetaArray);
R__insp.Inspect(R__cl, R__parent, “deltaTArray[40][15][180][90]”, deltaTArray);
R__insp.Inspect(R__cl, R__parent, “finePhiArray[120]”, finePhiArray);
R__insp.Inspect(R__cl, R__parent, “fineThetaArray[60]”, fineThetaArray);
R__insp.Inspect(R__cl, R__parent, “cosFinePhiArray[120]”, cosFinePhiArray);
R__insp.Inspect(R__cl, R__parent, “cosFineThetaArray[60]”, cosFineThetaArray);
R__insp.Inspect(R__cl, R__parent, “sinFinePhiArray[120]”, sinFinePhiArray);
R__insp.Inspect(R__cl, R__parent, “sinFineThetaArray[60]”, sinFineThetaArray);
R__insp.Inspect(R__cl, R__parent, “fineDeltaTArray[40][15][120][60]”, fineDeltaTArray);
R__insp.Inspect(R__cl, R__parent, “fAntPhi[40]”, fAntPhi);
R__insp.Inspect(R__cl, R__parent, “fSinAntPhi[40]”, fSinAntPhi);
R__insp.Inspect(R__cl, R__parent, “fCosAntPhi[40]”, fCosAntPhi);
R__insp.Inspect(R__cl, R__parent, “fAntR[40]”, fAntR);
R__insp.Inspect(R__cl, R__parent, “fAntZ[40]”, fAntZ);
R__insp.Inspect(R__cl, R__parent, “within12dB[40][180][90]”, within12dB);
R__insp.Inspect(R__cl, R__parent, “numAntennas12dB[180][90]”, numAntennas12dB);
R__insp.Inspect(R__cl, R__parent, “phiGainData[2][180]”, phiGainData);
R__insp.Inspect(R__cl, R__parent, “thetaGainData[2][180]”, thetaGainData);
R__insp.Inspect(R__cl, R__parent, “*baseline”, &baseline);
R__insp.Inspect(R__cl, R__parent, “*baselinedB”, &baselinedB);
R__insp.Inspect(R__cl, R__parent, “fitProbSigma[40][125]”, fitProbSigma);
R__insp.Inspect(R__cl, R__parent, “*boreholeFile”, &boreholeFile);
R__insp.Inspect(R__cl, R__parent, “*seaveyVFile”, &seaveyVFile);
R__insp.Inspect(R__cl, R__parent, “*seaveyHFile”, &seaveyHFile);
R__insp.Inspect(R__cl, R__parent, “*seavey45File”, &seavey45File);
R__insp.Inspect(R__cl, R__parent, “*boreholeChain”, &boreholeChain);
R__insp.Inspect(R__cl, R__parent, “*seaveyVChain”, &seaveyVChain);
R__insp.Inspect(R__cl, R__parent, “*seaveyHChain”, &seaveyHChain);
R__insp.Inspect(R__cl, R__parent, “*seavey45Chain”, &seavey45Chain);
R__insp.Inspect(R__cl, R__parent, “boreholeEntry”, &boreholeEntry);
R__insp.Inspect(R__cl, R__parent, “seaveyVEntry”, &seaveyVEntry);
R__insp.Inspect(R__cl, R__parent, “seaveyHEntry”, &seaveyHEntry);
R__insp.Inspect(R__cl, R__parent, “seavey45Entry”, &seavey45Entry);
R__insp.Inspect(R__cl, R__parent, “aboveBaselineFilter”, &aboveBaselineFilter);
R__insp.Inspect(R__cl, R__parent, “peakyFilterDrop”, &peakyFilterDrop);
R__insp.Inspect(R__cl, R__parent, “numRoundsAdaptiveFiltering”, &numRoundsAdaptiveFiltering);
R__insp.Inspect(R__cl, R__parent, “setSimpleFilterAdaptive”, &setSimpleFilterAdaptive);
R__insp.Inspect(R__cl, R__parent, “setSimpleFilterSatellite”, &setSimpleFilterSatellite);
R__insp.Inspect(R__cl, R__parent, “satelliteLowerBound”, &satelliteLowerBound);
R__insp.Inspect(R__cl, R__parent, “satelliteUpperBound”, &satelliteUpperBound);
R__insp.Inspect(R__cl, R__parent, “setFilterNorthSatellite”, &setFilterNorthSatellite);
R__insp.Inspect(R__cl, R__parent, “normBeforeFilter”, &normBeforeFilter);
R__insp.Inspect(R__cl, R__parent, “adaptiveWithFixedFilterStage”, &adaptiveWithFixedFilterStage);
R__insp.Inspect(R__cl, R__parent, “useWhiteNoiseFilter”, &useWhiteNoiseFilter);
R__insp.Inspect(R__cl, R__parent, “coherentWaveformFilter”, &coherentWaveformFilter);
R__insp.Inspect(R__cl, R__parent, “aboveCoherentBaselineFilter”, &aboveCoherentBaselineFilter);
R__insp.Inspect(R__cl, R__parent, “ignoreNonRF”, &ignoreNonRF);
R__insp.Inspect(R__cl, R__parent, “ignorePulsing”, &ignorePulsing);
R__insp.Inspect(R__cl, R__parent, “requireGps”, &requireGps);
R__insp.Inspect(R__cl, R__parent, “cutPayloadBlasts”, &cutPayloadBlasts);
R__insp.Inspect(R__cl, R__parent, “useHeaderChecks”, &useHeaderChecks);
R__insp.Inspect(R__cl, R__parent, “useEventChecks”, &useEventChecks);
R__insp.Inspect(R__cl, R__parent, “useCorrelationChecks”, &useCorrelationChecks);
R__insp.Inspect(R__cl, R__parent, “rotationFactor”, &rotationFactor);
R__insp.Inspect(R__cl, R__parent, “rotatedCorrelationCut”, &rotatedCorrelationCut);
R__insp.Inspect(R__cl, R__parent, “*rand”, &rand);
R__insp.Inspect(R__cl, R__parent, “fThetaWave”, &fThetaWave);
R__insp.Inspect(R__cl, R__parent, “fPhiWave”, &fPhiWave);
TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
// Wrappers around operator new
static void *new_CrossCorrelatorGeometry(void *p) {
return p ? new§ ::CrossCorrelatorGeometry : new ::CrossCorrelatorGeometry;
}
static void *newArray_CrossCorrelatorGeometry(Long_t nElements, void *p) {
return p ? new§ ::CrossCorrelatorGeometry[nElements] : new ::CrossCorrelatorGeometry[nElements];
}
// Wrapper around operator delete
static void delete_CrossCorrelatorGeometry(void p) {
delete ((::CrossCorrelatorGeometry)p);
}
static void deleteArray_CrossCorrelatorGeometry(void p) {
delete [] ((::CrossCorrelatorGeometry)p);
}
static void destruct_CrossCorrelatorGeometry(void p) {
typedef ::CrossCorrelatorGeometry current_t;
((current_t)p)->~current_t();
}
} // end of namespace ROOT for class ::CrossCorrelatorGeometry

//______________________________________________________________________________
void CrossCorrelator::Streamer(TBuffer &R__b)
{
// Stream an object of class CrossCorrelator.

if (R__b.IsReading()) {
R__b.ReadClassBuffer(CrossCorrelator::Class(),this);
} else {
R__b.WriteClassBuffer(CrossCorrelator::Class(),this);
}
}

//______________________________________________________________________________
void CrossCorrelator::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
// Inspect the data members of an object of class CrossCorrelator.
TClass *R__cl = ::CrossCorrelator::IsA();
Int_t R__ncp = strlen(R__parent);
if (R__ncp || R__cl || R__insp.IsA()) { }
R__insp.Inspect(R__cl, R__parent, “correlationArray[180][90]”, correlationArray);
R__insp.Inspect(R__cl, R__parent, “fineCorrelationArray[120][60]”, fineCorrelationArray);
R__insp.Inspect(R__cl, R__parent, “numCrossCorrelationsArray[180][90]”, numCrossCorrelationsArray);
R__insp.Inspect(R__cl, R__parent, “numCrossCorrelations”, &numCrossCorrelations);
R__insp.Inspect(R__cl, R__parent, “triggeredPhi[16]”, triggeredPhi);
R__insp.Inspect(R__cl, R__parent, “triggeredAnt[40]”, triggeredAnt);
R__insp.Inspect(R__cl, R__parent, “fineTriggeredPhi[16]”, fineTriggeredPhi);
R__insp.Inspect(R__cl, R__parent, “fineTriggeredAnt[40]”, fineTriggeredAnt);
R__insp.Inspect(R__cl, R__parent, “numFineTriggeredAnt”, &numFineTriggeredAnt);
R__insp.Inspect(R__cl, R__parent, “midPhi”, &midPhi);
R__insp.Inspect(R__cl, R__parent, “midTheta”, &midTheta);
R__insp.Inspect(R__cl, R__parent, “midPhiBin”, &midPhiBin);
R__insp.Inspect(R__cl, R__parent, “midThetaBin”, &midThetaBin);
R__insp.Inspect(R__cl, R__parent, “fineMidPhi”, &fineMidPhi);
R__insp.Inspect(R__cl, R__parent, “fineMidTheta”, &fineMidTheta);
R__insp.Inspect(R__cl, R__parent, “fineMidPhiBin”, &fineMidPhiBin);
R__insp.Inspect(R__cl, R__parent, “fineMidThetaBin”, &fineMidThetaBin);
R__insp.Inspect(R__cl, R__parent, “meanCrossCorrelation”, &meanCrossCorrelation);
R__insp.Inspect(R__cl, R__parent, “peakCorrVal”, &peakCorrVal);
R__insp.Inspect(R__cl, R__parent, “finePeakCorrVal”, &finePeakCorrVal);
R__insp.Inspect(R__cl, R__parent, “maxPhi”, &maxPhi);
R__insp.Inspect(R__cl, R__parent, “fWaveformSNR[40]”, fWaveformSNR);
R__insp.Inspect(R__cl, R__parent, “fWaveformRMS[40]”, fWaveformRMS);
R__insp.Inspect(R__cl, R__parent, “fWaveformP2P[40]”, fWaveformP2P);
R__insp.Inspect(R__cl, R__parent, “fWaveformMean[40]”, fWaveformMean);
R__insp.Inspect(R__cl, R__parent, “secondMeasPhi”, &secondMeasPhi);
R__insp.Inspect(R__cl, R__parent, “secondMeasTheta”, &secondMeasTheta);
R__insp.Inspect(R__cl, R__parent, “secondPeakCorrVal”, &secondPeakCorrVal);
R__insp.Inspect(R__cl, R__parent, “fFiltered”, &fFiltered);
R__insp.Inspect(R__cl, R__parent, “fCoherentFiltered”, &fCoherentFiltered);
R__insp.Inspect(R__cl, R__parent, “*crossCorrelation”, &crossCorrelation);
R__insp.Inspect(R__cl, R__parent, “*fineCrossCorrelation”, &fineCrossCorrelation);
R__insp.Inspect(R__cl, R__parent, “*grFirst[40]”, &grFirst);
R__insp.Inspect(R__cl, R__parent, “*grNorm[40]”, &grNorm);
R__insp.Inspect(R__cl, R__parent, “*grPass[40]”, &grPass);
R__insp.Inspect(R__cl, R__parent, “*grTemp[40]”, &grTemp);
R__insp.Inspect(R__cl, R__parent, “*grInt[40]”, &grInt);
R__insp.Inspect(R__cl, R__parent, “*grFinal[40]”, &grFinal);
R__insp.Inspect(R__cl, R__parent, “*grCorr[781]”, &grCorr);
R__insp.Inspect(R__cl, R__parent, “*coherentWaveformFiltered”, &coherentWaveformFiltered);
R__insp.Inspect(R__cl, R__parent, “*coherentWaveformUnfiltered”, &coherentWaveformUnfiltered);
R__insp.Inspect(R__cl, R__parent, “*hilbertCoherentWaveformFiltered”, &hilbertCoherentWaveformFiltered);
R__insp.Inspect(R__cl, R__parent, “*hilbertCoherentWaveformUnfiltered”, &hilbertCoherentWaveformUnfiltered);
R__insp.Inspect(R__cl, R__parent, “*coherentPowerSpectrumFiltered”, &coherentPowerSpectrumFiltered);
R__insp.Inspect(R__cl, R__parent, “*coherentPowerSpectrumUnfiltered”, &coherentPowerSpectrumUnfiltered);
R__insp.Inspect(R__cl, R__parent, “*coherentBaselineFiltered”, &coherentBaselineFiltered);
R__insp.Inspect(R__cl, R__parent, “*coherentBaselineUnfiltered”, &coherentBaselineUnfiltered);
R__insp.Inspect(R__cl, R__parent, “peakCoherentWaveformFiltered”, &peakCoherentWaveformFiltered);
R__insp.Inspect(R__cl, R__parent, “peakCoherentWaveformUnfiltered”, &peakCoherentWaveformUnfiltered);
R__insp.Inspect(R__cl, R__parent, “peakHilbertCoherentWaveformFiltered”, &peakHilbertCoherentWaveformFiltered);
R__insp.Inspect(R__cl, R__parent, “peakHilbertCoherentWaveformUnfiltered”, &peakHilbertCoherentWaveformUnfiltered);
R__insp.Inspect(R__cl, R__parent, “rmsHilbertCoherentWaveformUnfiltered”, &rmsHilbertCoherentWaveformUnfiltered);
R__insp.Inspect(R__cl, R__parent, “snrHilbertCoherentWaveformUnfiltered”, &snrHilbertCoherentWaveformUnfiltered);
R__insp.Inspect(R__cl, R__parent, “timePeakHilbertCoherentWaveformUnfiltered”, &timePeakHilbertCoherentWaveformUnfiltered);
R__insp.Inspect(R__cl, R__parent, “rmsHilbertCoherentWaveformFiltered”, &rmsHilbertCoherentWaveformFiltered);
R__insp.Inspect(R__cl, R__parent, “snrHilbertCoherentWaveformFiltered”, &snrHilbertCoherentWaveformFiltered);
R__insp.Inspect(R__cl, R__parent, “timePeakHilbertCoherentWaveformFiltered”, &timePeakHilbertCoherentWaveformFiltered);
R__insp.Inspect(R__cl, R__parent, “rotatedPeakCorrelation”, &rotatedPeakCorrelation);
R__insp.Inspect(R__cl, R__parent, “*theFFT[40]”, &theFFT);
R__insp.Inspect(R__cl, R__parent, “fracFilteredFreqs”, &fracFilteredFreqs);
R__insp.Inspect(R__cl, R__parent, “*adjustedBaseline[6]”, &adjustedBaseline);
R__insp.Inspect(R__cl, R__parent, “*averagedEventPowerSpec[6]”, &averagedEventPowerSpec);
R__insp.Inspect(R__cl, R__parent, “fNorthFacing[40]”, fNorthFacing);
R__insp.Inspect(R__cl, R__parent, “aboveBaselineFilter”, &aboveBaselineFilter);
R__insp.Inspect(R__cl, R__parent, “peakyFilterDrop”, &peakyFilterDrop);
R__insp.Inspect(R__cl, R__parent, “numRoundsAdaptiveFiltering”, &numRoundsAdaptiveFiltering);
R__insp.Inspect(R__cl, R__parent, “setSimpleFilterAdaptive”, &setSimpleFilterAdaptive);
R__insp.Inspect(R__cl, R__parent, “setSimpleFilterSatellite”, &setSimpleFilterSatellite);
R__insp.Inspect(R__cl, R__parent, “satelliteLowerBound”, &satelliteLowerBound);
R__insp.Inspect(R__cl, R__parent, “satelliteUpperBound”, &satelliteUpperBound);
R__insp.Inspect(R__cl, R__parent, “setFilterNorthSatellite”, &setFilterNorthSatellite);
R__insp.Inspect(R__cl, R__parent, “normBeforeFilter”, &normBeforeFilter);
R__insp.Inspect(R__cl, R__parent, “adaptiveWithFixedFilterStage”, &adaptiveWithFixedFilterStage);
R__insp.Inspect(R__cl, R__parent, “useWhiteNoiseFilter”, &useWhiteNoiseFilter);
R__insp.Inspect(R__cl, R__parent, “coherentWaveformFilter”, &coherentWaveformFilter);
R__insp.Inspect(R__cl, R__parent, “aboveCoherentBaselineFilter”, &aboveCoherentBaselineFilter);
R__insp.Inspect(R__cl, R__parent, “ignoreNonRF”, &ignoreNonRF);
R__insp.Inspect(R__cl, R__parent, “ignorePulsing”, &ignorePulsing);
R__insp.Inspect(R__cl, R__parent, “requireGps”, &requireGps);
R__insp.Inspect(R__cl, R__parent, “cutPayloadBlasts”, &cutPayloadBlasts);
R__insp.Inspect(R__cl, R__parent, “useHeaderChecks”, &useHeaderChecks);
R__insp.Inspect(R__cl, R__parent, “useEventChecks”, &useEventChecks);
R__insp.Inspect(R__cl, R__parent, “useCorrelationChecks”, &useCorrelationChecks);
R__insp.Inspect(R__cl, R__parent, “rotationFactor”, &rotationFactor);
R__insp.Inspect(R__cl, R__parent, “rotatedCorrelationCut”, &rotatedCorrelationCut);
R__insp.Inspect(R__cl, R__parent, “*rand”, &rand);
R__insp.Inspect(R__cl, R__parent, “fFailHeaderCheck”, &fFailHeaderCheck);
R__insp.Inspect(R__cl, R__parent, “fFailEventCheck”, &fFailEventCheck);
R__insp.Inspect(R__cl, R__parent, “fFailCorrelationCheck”, &fFailCorrelationCheck);
R__insp.Inspect(R__cl, R__parent, “fNotRFTrigger”, &fNotRFTrigger);
R__insp.Inspect(R__cl, R__parent, “fFailGpsTiming”, &fFailGpsTiming);
R__insp.Inspect(R__cl, R__parent, “fCalPulserEvent”, &fCalPulserEvent);
R__insp.Inspect(R__cl, R__parent, “fSyncSlipFlag”, &fSyncSlipFlag);
R__insp.Inspect(R__cl, R__parent, “fRFCMStatus[5]”, fRFCMStatus);
R__insp.Inspect(R__cl, R__parent, “fMainRFCMOff”, &fMainRFCMOff);
R__insp.Inspect(R__cl, R__parent, “fTDEventFlag”, &fTDEventFlag);
R__insp.Inspect(R__cl, R__parent, “fWFEventFlag”, &fWFEventFlag);
R__insp.Inspect(R__cl, R__parent, “fPayloadBlastFlag”, &fPayloadBlastFlag);
R__insp.Inspect(R__cl, R__parent, “fShortWaveformFlag”, &fShortWaveformFlag);
R__insp.Inspect(R__cl, R__parent, “fVarnerEventFlag”, &fVarnerEventFlag);
R__insp.Inspect(R__cl, R__parent, “fDCOffsetFlag”, &fDCOffsetFlag);
R__insp.Inspect(R__cl, R__parent, “fSurfSaturatedFlag”, &fSurfSaturatedFlag);
R__insp.Inspect(R__cl, R__parent, “fCooldownBlastFlag”, &fCooldownBlastFlag);
R__insp.Inspect(R__cl, R__parent, “fPayloadBlastWaveformFlag”, &fPayloadBlastWaveformFlag);
R__insp.Inspect(R__cl, R__parent, “fTooManyFilteredFreqs”, &fTooManyFilteredFreqs);
R__insp.Inspect(R__cl, R__parent, “fPhiAtEdgeOfMap”, &fPhiAtEdgeOfMap);
R__insp.Inspect(R__cl, R__parent, “fThetaAtEdgeOfMap”, &fThetaAtEdgeOfMap);
R__insp.Inspect(R__cl, R__parent, “fThetaPointingUpwards”, &fThetaPointingUpwards);
R__insp.Inspect(R__cl, R__parent, “fPhiSectorMasked”, &fPhiSectorMasked);
R__insp.Inspect(R__cl, R__parent, “fPhiSectorDidNotTrigger”, &fPhiSectorDidNotTrigger);
R__insp.Inspect(R__cl, R__parent, “fPeakCorrNegative”, &fPeakCorrNegative);
R__insp.Inspect(R__cl, R__parent, “fNumRFCMOn”, &fNumRFCMOn);
TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
// Wrappers around operator new
static void *new_CrossCorrelator(void *p) {
return p ? new§ ::CrossCorrelator : new ::CrossCorrelator;
}
static void *newArray_CrossCorrelator(Long_t nElements, void *p) {
return p ? new§ ::CrossCorrelator[nElements] : new ::CrossCorrelator[nElements];
}
// Wrapper around operator delete
static void delete_CrossCorrelator(void p) {
delete ((::CrossCorrelator)p);
}
static void deleteArray_CrossCorrelator(void p) {
delete [] ((::CrossCorrelator)p);
}
static void destruct_CrossCorrelator(void p) {
typedef ::CrossCorrelator current_t;
((current_t)p)->~current_t();
}
} // end of namespace ROOT for class ::CrossCorrelator

//______________________________________________________________________________
namespace ROOT {
void CorrelatorTools_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent)
{
// Inspect the data members of an object of class CorrelatorTools.
typedef ::ROOT::Shadow::CorrelatorTools ShadowClass;
ShadowClass sobj = (ShadowClass)obj;
if (sobj) { } // Dummy usage just in case there is no datamember.

  TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::CorrelatorTools*)0x0)->GetClass();
  Int_t R__ncp = strlen(R__parent);
  if (R__ncp || R__cl || R__insp.IsA()) { }

}

}

namespace ROOT {
// Wrappers around operator new
static void *new_CorrelatorTools(void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) ::CorrelatorTools : new ::CorrelatorTools;
}
static void *newArray_CorrelatorTools(Long_t nElements, void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) ::CorrelatorTools[nElements] : new ::CorrelatorTools[nElements];
}
// Wrapper around operator delete
static void delete_CorrelatorTools(void p) {
delete ((::CorrelatorTools)p);
}
static void deleteArray_CorrelatorTools(void p) {
delete [] ((::CorrelatorTools)p);
}
static void destruct_CorrelatorTools(void p) {
typedef ::CorrelatorTools current_t;
((current_t)p)->~current_t();
}
} // end of namespace ROOT for class ::CorrelatorTools

//______________________________________________________________________________
void EventCluster::Streamer(TBuffer &R__b)
{
// Stream an object of class EventCluster.

if (R__b.IsReading()) {
R__b.ReadClassBuffer(EventCluster::Class(),this);
} else {
R__b.WriteClassBuffer(EventCluster::Class(),this);
}
}

//______________________________________________________________________________
void EventCluster::ShowMembers(TMemberInspector &R__insp, char R__parent)
{
// Inspect the data members of an object of class EventCluster.
TClass R__cl = ::EventCluster::IsA();
Int_t R__ncp = strlen(R__parent);
if (R__ncp || R__cl || R__insp.IsA()) { }
R__insp.Inspect(R__cl, R__parent, “fRun”, &fRun);
R__insp.Inspect(R__cl, R__parent, “fEventNumber”, &fEventNumber);
R__insp.Inspect(R__cl, R__parent, “fLat”, &fLat);
R__insp.Inspect(R__cl, R__parent, “fLon”, &fLon);
R__insp.Inspect(R__cl, R__parent, “fAlt”, &fAlt);
R__insp.Inspect(R__cl, R__parent, “baseClusters”, &baseClusters);
R__insp.Inspect(R__cl, R__parent, “baseNumberList”, (void)&baseNumberList);
::ROOT::GenericShowMembers(“vector<UInt_t>”, (void)&baseNumberList, R__insp, strcat(R__parent,“baseNumberList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “baseLonList”, (void*)&baseLonList);
::ROOT::GenericShowMembers(“vector”, (void*)&baseLonList, R__insp, strcat(R__parent,“baseLonList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “baseLatList”, (void*)&baseLatList);
::ROOT::GenericShowMembers(“vector”, (void*)&baseLatList, R__insp, strcat(R__parent,“baseLatList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “baseAltList”, (void*)&baseAltList);
::ROOT::GenericShowMembers(“vector”, (void*)&baseAltList, R__insp, strcat(R__parent,“baseAltList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “baseLogLikeList”, (void*)&baseLogLikeList);
::ROOT::GenericShowMembers(“vector”, (void*)&baseLogLikeList, R__insp, strcat(R__parent,“baseLogLikeList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “baseDistanceList”, (void*)&baseDistanceList);
::ROOT::GenericShowMembers(“vector”, (void*)&baseDistanceList, R__insp, strcat(R__parent,“baseDistanceList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “flightClusters”, &flightClusters);
R__insp.Inspect(R__cl, R__parent, “flightLonList”, (void*)&flightLonList);
::ROOT::GenericShowMembers(“vector”, (void*)&flightLonList, R__insp, strcat(R__parent,“flightLonList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “flightLatList”, (void*)&flightLatList);
::ROOT::GenericShowMembers(“vector”, (void*)&flightLatList, R__insp, strcat(R__parent,“flightLatList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “flightAltList”, (void*)&flightAltList);
::ROOT::GenericShowMembers(“vector”, (void*)&flightAltList, R__insp, strcat(R__parent,“flightAltList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “flightTimeList”, (void*)&flightTimeList);
::ROOT::GenericShowMembers(“vector<UInt_t>”, (void*)&flightTimeList, R__insp, strcat(R__parent,“flightTimeList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “flightLogLikeList”, (void*)&flightLogLikeList);
::ROOT::GenericShowMembers(“vector”, (void*)&flightLogLikeList, R__insp, strcat(R__parent,“flightLogLikeList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “flightDistanceList”, (void*)&flightDistanceList);
::ROOT::GenericShowMembers(“vector”, (void*)&flightDistanceList, R__insp, strcat(R__parent,“flightDistanceList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “eventClusters”, &eventClusters);
R__insp.Inspect(R__cl, R__parent, “eventNumberList”, (void*)&eventNumberList);
::ROOT::GenericShowMembers(“vector”, (void*)&eventNumberList, R__insp, strcat(R__parent,“eventNumberList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “eventLogLikeList”, (void*)&eventLogLikeList);
::ROOT::GenericShowMembers(“vector”, (void*)&eventLogLikeList, R__insp, strcat(R__parent,“eventLogLikeList.”),false);
R__parent[R__ncp] = 0;
R__insp.Inspect(R__cl, R__parent, “eventDistanceList”, (void*)&eventDistanceList);
::ROOT::GenericShowMembers(“vector”, (void*)&eventDistanceList, R__insp, strcat(R__parent,“eventDistanceList.”),false);
R__parent[R__ncp] = 0;
TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
// Wrappers around operator new
static void *new_EventCluster(void *p) {
return p ? new§ ::EventCluster : new ::EventCluster;
}
static void *newArray_EventCluster(Long_t nElements, void *p) {
return p ? new§ ::EventCluster[nElements] : new ::EventCluster[nElements];
}
// Wrapper around operator delete
static void delete_EventCluster(void p) {
delete ((::EventCluster)p);
}
static void deleteArray_EventCluster(void p) {
delete [] ((::EventCluster)p);
}
static void destruct_EventCluster(void p) {
typedef ::EventCluster current_t;
((current_t)p)->~current_t();
}
} // end of namespace ROOT for class ::EventCluster

//______________________________________________________________________________
namespace ROOT {
void FlightAndTraverse_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent)
{
// Inspect the data members of an object of class FlightAndTraverse.
typedef ::ROOT::Shadow::FlightAndTraverse ShadowClass;
ShadowClass sobj = (ShadowClass)obj;
if (sobj) { } // Dummy usage just in case there is no datamember.

  TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::FlightAndTraverse*)0x0)->GetClass();
  Int_t R__ncp = strlen(R__parent);
  if (R__ncp || R__cl || R__insp.IsA()) { }
  R__insp.Inspect(R__cl, R__parent, "*flightFiles[7][71]", &sobj->flightFiles);
  R__insp.Inspect(R__cl, R__parent, "*flightTrees[7][71]", &sobj->flightTrees);
  R__insp.Inspect(R__cl, R__parent, "flightTime[7][71]", sobj->flightTime);
  R__insp.Inspect(R__cl, R__parent, "flightLat[7][71]", sobj->flightLat);
  R__insp.Inspect(R__cl, R__parent, "flightLon[7][71]", sobj->flightLon);
  R__insp.Inspect(R__cl, R__parent, "flightAlt[7][71]", sobj->flightAlt);
  R__insp.Inspect(R__cl, R__parent, "flightEntry[7][71][3]", sobj->flightEntry);
  R__insp.Inspect(R__cl, R__parent, "flightTimes[7][71][3]", sobj->flightTimes);
  R__insp.Inspect(R__cl, R__parent, "numFlightsInData[7]", sobj->numFlightsInData);

}

}

namespace ROOT {
// Wrappers around operator new
static void *new_FlightAndTraverse(void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) ::FlightAndTraverse : new ::FlightAndTraverse;
}
static void *newArray_FlightAndTraverse(Long_t nElements, void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) ::FlightAndTraverse[nElements] : new ::FlightAndTraverse[nElements];
}
// Wrapper around operator delete
static void delete_FlightAndTraverse(void p) {
delete ((::FlightAndTraverse)p);
}
static void deleteArray_FlightAndTraverse(void p) {
delete [] ((::FlightAndTraverse)p);
}
static void destruct_FlightAndTraverse(void p) {
typedef ::FlightAndTraverse current_t;
((current_t)p)->~current_t();
}
} // end of namespace ROOT for class ::FlightAndTraverse

namespace ROOT {
void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
static void vectorlEdoublegR_Dictionary();
static void *new_vectorlEdoublegR(void *p = 0);
static void *newArray_vectorlEdoublegR(Long_t size, void *p);
static void delete_vectorlEdoublegR(void *p);
static void deleteArray_vectorlEdoublegR(void *p);
static void destruct_vectorlEdoublegR(void *p);

// Function generating the singleton type initializer
static TGenericClassInfo GenerateInitInstanceLocal(const vector)
{
vector ptr = 0;
static ::TVirtualIsAProxy isa_proxy = new ::TIsAProxy(typeid(vector),0);
static ::ROOT::TGenericClassInfo
instance(“vector”, -2, “vector.dll”, 0,
typeid(vector), DefineBehavior(ptr, ptr),
0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
sizeof(vector) );
instance.SetNew(&new_vectorlEdoublegR);
instance.SetNewArray(&newArray_vectorlEdoublegR);
instance.SetDelete(&delete_vectorlEdoublegR);
instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
instance.SetDestructor(&destruct_vectorlEdoublegR);
instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >()));
return &instance;
}
// Static variable to force the class initialization
static ::ROOT::TGenericClassInfo R__UNIQUE(Init) = GenerateInitInstanceLocal((const vector)0x0); R__UseDummy(R__UNIQUE(Init));

// Dictionary for non-ClassDef classes
static void vectorlEdoublegR_Dictionary() {
::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass();
}

} // end of namespace ROOT

namespace ROOT {
// Wrappers around operator new
static void *new_vectorlEdoublegR(void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) vector : new vector;
}
static void *newArray_vectorlEdoublegR(Long_t nElements, void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) vector[nElements] : new vector[nElements];
}
// Wrapper around operator delete
static void delete_vectorlEdoublegR(void p) {
delete ((vector)p);
}
static void deleteArray_vectorlEdoublegR(void p) {
delete [] ((vector)p);
}
static void destruct_vectorlEdoublegR(void p) {
typedef vector current_t;
((current_t)p)->~current_t();
}
} // end of namespace ROOT for class vector

namespace ROOT {
void vectorlEintgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
static void vectorlEintgR_Dictionary();
static void *new_vectorlEintgR(void *p = 0);
static void *newArray_vectorlEintgR(Long_t size, void *p);
static void delete_vectorlEintgR(void *p);
static void deleteArray_vectorlEintgR(void *p);
static void destruct_vectorlEintgR(void *p);

// Function generating the singleton type initializer
static TGenericClassInfo GenerateInitInstanceLocal(const vector)
{
vector ptr = 0;
static ::TVirtualIsAProxy isa_proxy = new ::TIsAProxy(typeid(vector),0);
static ::ROOT::TGenericClassInfo
instance(“vector”, -2, “/unix/anita1/software/root_v5.20.00/cint/cint/lib/prec_stl/vector”, 49,
typeid(vector), DefineBehavior(ptr, ptr),
0, &vectorlEintgR_Dictionary, isa_proxy, 0,
sizeof(vector) );
instance.SetNew(&new_vectorlEintgR);
instance.SetNewArray(&newArray_vectorlEintgR);
instance.SetDelete(&delete_vectorlEintgR);
instance.SetDeleteArray(&deleteArray_vectorlEintgR);
instance.SetDestructor(&destruct_vectorlEintgR);
instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >()));
return &instance;
}
// Static variable to force the class initialization
static ::ROOT::TGenericClassInfo R__UNIQUE(Init) = GenerateInitInstanceLocal((const vector)0x0); R__UseDummy(R__UNIQUE(Init));

// Dictionary for non-ClassDef classes
static void vectorlEintgR_Dictionary() {
::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass();
}

} // end of namespace ROOT

namespace ROOT {
// Wrappers around operator new
static void *new_vectorlEintgR(void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) vector : new vector;
}
static void *newArray_vectorlEintgR(Long_t nElements, void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) vector[nElements] : new vector[nElements];
}
// Wrapper around operator delete
static void delete_vectorlEintgR(void p) {
delete ((vector)p);
}
static void deleteArray_vectorlEintgR(void p) {
delete [] ((vector)p);
}
static void destruct_vectorlEintgR(void p) {
typedef vector current_t;
((current_t)p)->~current_t();
}
} // end of namespace ROOT for class vector

namespace ROOT {
void vectorlEunsignedsPintgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
static void vectorlEunsignedsPintgR_Dictionary();
static void *new_vectorlEunsignedsPintgR(void *p = 0);
static void *newArray_vectorlEunsignedsPintgR(Long_t size, void *p);
static void delete_vectorlEunsignedsPintgR(void *p);
static void deleteArray_vectorlEunsignedsPintgR(void *p);
static void destruct_vectorlEunsignedsPintgR(void *p);

// Function generating the singleton type initializer
static TGenericClassInfo GenerateInitInstanceLocal(const vector)
{
vector ptr = 0;
static ::TVirtualIsAProxy isa_proxy = new ::TIsAProxy(typeid(vector),0);
static ::ROOT::TGenericClassInfo
instance(“vector”, -2, “vector.dll”, 0,
typeid(vector), DefineBehavior(ptr, ptr),
0, &vectorlEunsignedsPintgR_Dictionary, isa_proxy, 0,
sizeof(vector) );
instance.SetNew(&new_vectorlEunsignedsPintgR);
instance.SetNewArray(&newArray_vectorlEunsignedsPintgR);
instance.SetDelete(&delete_vectorlEunsignedsPintgR);
instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPintgR);
instance.SetDestructor(&destruct_vectorlEunsignedsPintgR);
instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >()));
return &instance;
}
// Static variable to force the class initialization
static ::ROOT::TGenericClassInfo R__UNIQUE(Init) = GenerateInitInstanceLocal((const vector)0x0); R__UseDummy(R__UNIQUE(Init));

// Dictionary for non-ClassDef classes
static void vectorlEunsignedsPintgR_Dictionary() {
::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass();
}

} // end of namespace ROOT

namespace ROOT {
// Wrappers around operator new
static void *new_vectorlEunsignedsPintgR(void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) vector : new vector;
}
static void *newArray_vectorlEunsignedsPintgR(Long_t nElements, void p) {
return p ? ::new((::ROOT::TOperatorNewHelper)p) vector[nElements] : new vector[nElements];
}
// Wrapper around operator delete
static void delete_vectorlEunsignedsPintgR(void p) {
delete ((vector)p);
}
static void deleteArray_vectorlEunsignedsPintgR(void p) {
delete [] ((vector)p);
}
static void destruct_vectorlEunsignedsPintgR(void p) {
typedef vector current_t;
((current_t)p)->~current_t();
}
} // end of namespace ROOT for class vector
[/code][/code]

8

2nd part … (sorry about this!)

[code]

/********************************************************

  • correlatorDict.C
  • CAUTION: DON’T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
  •      FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().

  •      CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.

********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(GNUC) && (GNUC > 3) && (GNUC_MINOR > 1)
#pragma GCC diagnostic ignored “-Wstrict-aliasing”
#endif

extern “C” void G__cpp_reset_tagtablecorrelatorDict();

extern “C” void G__set_cpp_environmentcorrelatorDict() {
G__add_compiledheader(“TObject.h”);
G__add_compiledheader(“TMemberInspector.h”);
G__add_compiledheader(“CrossCorrelatorGeometry.h”);
G__add_compiledheader(“CrossCorrelator.h”);
G__add_compiledheader(“CorrelatorTools.h”);
G__add_compiledheader(“EventCluster.h”);
G__add_compiledheader(“FlightAndTraverse.h”);
G__add_compiledheader(“correlationDefs.h”);
G__cpp_reset_tagtablecorrelatorDict();
}
#include
extern “C” int G__cpp_dllrevcorrelatorDict() { return(30051515); }

/*********************************************************

  • Member function Interface Method
    *********************************************************/

/* CrossCorrelatorGeometry /
static int G__correlatorDict_220_0_1(G__value result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CrossCorrelatorGeometry* p = NULL;
char* gvp = (char*) G__getgvp();
int n = G__getaryconstruct();
if (n) {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new CrossCorrelatorGeometry[n];
} else {
p = new((void*) gvp) CrossCorrelatorGeometry[n];
}
} else {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new CrossCorrelatorGeometry;
} else {
p = new((void*) gvp) CrossCorrelatorGeometry;
}
}
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CrossCorrelatorGeometry* p = NULL;
char* gvp = (char*) G__getgvp();
//m: 1
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new CrossCorrelatorGeometry(((string) G__int(libp->para[0])));
} else {
p = new((void*) gvp) CrossCorrelatorGeometry(((string) G__int(libp->para[0])));
}
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((CrossCorrelatorGeometry*) G__getstructoffset())->fillFineDeltaTArray((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (int*) G__int(libp->para[2]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letdouble(result7, 100, (double) ((CrossCorrelatorGeometry*) G__getstructoffset())->getDeltaTExpected((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letdouble(result7, 100, (double) ((CrossCorrelatorGeometry*) G__getstructoffset())->getDeltaTExpected(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((CrossCorrelatorGeometry*) G__getstructoffset())->GetNumberAsString((ifstream) libp->para[0].ref, (string) libp->para[1].ref);
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) CrossCorrelatorGeometry::Class());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 67, (long) CrossCorrelatorGeometry::Class_Name());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 115, (long) CrossCorrelatorGeometry::Class_Version());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CrossCorrelatorGeometry::Dictionary();
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((CrossCorrelatorGeometry*) G__getstructoffset())->StreamerNVirtual((TBuffer) libp->para[0].ref);
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 67, (long) CrossCorrelatorGeometry::DeclFileName());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) CrossCorrelatorGeometry::ImplFileLine());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 67, (long) CrossCorrelatorGeometry::ImplFileName());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_220_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) CrossCorrelatorGeometry::DeclFileLine());
return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__correlatorDict_220_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
CrossCorrelatorGeometry* p;
void* tmp = (void*) G__int(libp->para[0]);
p = new CrossCorrelatorGeometry((CrossCorrelatorGeometry) tmp);
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef CrossCorrelatorGeometry G__TCrossCorrelatorGeometry;
static int G__correlatorDict_220_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
char* gvp = (char*) G__getgvp();
long soff = G__getstructoffset();
int n = G__getaryconstruct();
//
//has_a_delete: 1
//has_own_delete1arg: 0
//has_own_delete2arg: 0
//
if (!soff) {
return(1);
}
if (n) {
if (gvp == (char*)G__PVOID) {
delete[] (CrossCorrelatorGeometry*) soff;
} else {
G__setgvp((long) G__PVOID);
for (int i = n - 1; i >= 0; --i) {
((CrossCorrelatorGeometry*) (soff+(sizeof(CrossCorrelatorGeometry)i)))->~G__TCrossCorrelatorGeometry();
}
G__setgvp((long)gvp);
}
} else {
if (gvp == (char)G__PVOID) {
delete (CrossCorrelatorGeometry*) soff;
} else {
G__setgvp((long) G__PVOID);
((CrossCorrelatorGeometry*) (soff))->~G__TCrossCorrelatorGeometry();
G__setgvp((long)gvp);
}
}
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__correlatorDict_220_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CrossCorrelatorGeometry* dest = (CrossCorrelatorGeometry*) G__getstructoffset();
*dest = (CrossCorrelatorGeometry) libp->para[0].ref;
const CrossCorrelatorGeometry& obj = *dest;
result7->ref = (long) (&obj);
result7->obj.i = (long) (&obj);
return(1 || funcname || hash || result7 || libp) ;
}

/* CrossCorrelator /
static int G__correlatorDict_420_0_1(G__value result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CrossCorrelator* p = NULL;
char* gvp = (char*) G__getgvp();
int n = G__getaryconstruct();
if (n) {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new CrossCorrelator[n];
} else {
p = new((void*) gvp) CrossCorrelator[n];
}
} else {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new CrossCorrelator;
} else {
p = new((void*) gvp) CrossCorrelator;
}
}
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CrossCorrelator* p = NULL;
struct G__aRyp5 { Double_t a[1][2]; }* G__Ap5 = (struct G__aRyp5*) G__int(libp->para[5]);
char* gvp = (char*) G__getgvp();
//m: 6
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new CrossCorrelator(
(CalibratedAnitaEvent*) G__int(libp->para[0]), (RawAnitaHeader*) G__int(libp->para[1])
, (Adu5Pat*) G__int(libp->para[2]), (CrossCorrelatorGeometry*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), G__Ap5->a);
} else {
p = new((void*) gvp) CrossCorrelator(
(CalibratedAnitaEvent*) G__int(libp->para[0]), (RawAnitaHeader*) G__int(libp->para[1])
, (Adu5Pat*) G__int(libp->para[2]), (CrossCorrelatorGeometry*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), G__Ap5->a);
}
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CrossCorrelator* p = NULL;
char* gvp = (char*) G__getgvp();
//m: 4
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new CrossCorrelator(
(CalibratedAnitaEvent*) G__int(libp->para[0]), (RawAnitaHeader*) G__int(libp->para[1])
, (Adu5Pat*) G__int(libp->para[2]), (CrossCorrelatorGeometry*) G__int(libp->para[3]));
} else {
p = new((void*) gvp) CrossCorrelator(
(CalibratedAnitaEvent*) G__int(libp->para[0]), (RawAnitaHeader*) G__int(libp->para[1])
, (Adu5Pat*) G__int(libp->para[2]), (CrossCorrelatorGeometry*) G__int(libp->para[3]));
}
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((CrossCorrelator*) G__getstructoffset())->crossCorrelate((RawAnitaHeader*) G__int(libp->para[0]), (CrossCorrelatorGeometry*) G__int(libp->para[1]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((CrossCorrelator*) G__getstructoffset())->fineCrossCorrelate((RawAnitaHeader*) G__int(libp->para[0]), (CrossCorrelatorGeometry*) G__int(libp->para[1]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((CrossCorrelator*) G__getstructoffset())->coherentlySummedWaveformFiltered((CrossCorrelatorGeometry*) G__int(libp->para[0]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((CrossCorrelator*) G__getstructoffset())->coherentlySummedWaveformUnfiltered((CrossCorrelatorGeometry*) G__int(libp->para[0]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) ((CrossCorrelator*) G__getstructoffset())->getGausFit2D());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) CrossCorrelator::Class());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 67, (long) CrossCorrelator::Class_Name());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 115, (long) CrossCorrelator::Class_Version());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CrossCorrelator::Dictionary();
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((CrossCorrelator*) G__getstructoffset())->StreamerNVirtual((TBuffer) libp->para[0].ref);
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 67, (long) CrossCorrelator::DeclFileName());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) CrossCorrelator::ImplFileLine());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 67, (long) CrossCorrelator::ImplFileName());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_420_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) CrossCorrelator::DeclFileLine());
return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__correlatorDict_420_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
CrossCorrelator* p;
void* tmp = (void*) G__int(libp->para[0]);
p = new CrossCorrelator((CrossCorrelator) tmp);
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef CrossCorrelator G__TCrossCorrelator;
static int G__correlatorDict_420_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
char* gvp = (char*) G__getgvp();
long soff = G__getstructoffset();
int n = G__getaryconstruct();
//
//has_a_delete: 1
//has_own_delete1arg: 0
//has_own_delete2arg: 0
//
if (!soff) {
return(1);
}
if (n) {
if (gvp == (char*)G__PVOID) {
delete[] (CrossCorrelator*) soff;
} else {
G__setgvp((long) G__PVOID);
for (int i = n - 1; i >= 0; --i) {
((CrossCorrelator*) (soff+(sizeof(CrossCorrelator)i)))->~G__TCrossCorrelator();
}
G__setgvp((long)gvp);
}
} else {
if (gvp == (char)G__PVOID) {
delete (CrossCorrelator*) soff;
} else {
G__setgvp((long) G__PVOID);
((CrossCorrelator*) (soff))->~G__TCrossCorrelator();
G__setgvp((long)gvp);
}
}
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__correlatorDict_420_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CrossCorrelator* dest = (CrossCorrelator*) G__getstructoffset();
*dest = (CrossCorrelator) libp->para[0].ref;
const CrossCorrelator& obj = *dest;
result7->ref = (long) (&obj);
result7->obj.i = (long) (&obj);
return(1 || funcname || hash || result7 || libp) ;
}

/* CorrelatorTools /
static int G__correlatorDict_455_0_1(G__value result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools* p = NULL;
char* gvp = (char*) G__getgvp();
int n = G__getaryconstruct();
if (n) {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new CorrelatorTools[n];
} else {
p = new((void*) gvp) CorrelatorTools[n];
}
} else {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new CorrelatorTools;
} else {
p = new((void*) gvp) CorrelatorTools;
}
}
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_CorrelatorTools);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools::checkTDEvent((Adu5Pat*) G__int(libp->para[0]), (Double_t) G__Doubleref(&libp->para[1])
, (Double_t) G__Doubleref(&libp->para[2]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letdouble(result7, 100, (double) CorrelatorTools::getEventToTDDistance((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools::checkMCMDistance((Adu5Pat*) G__int(libp->para[0]), (double) G__Doubleref(&libp->para[1])
, (double) G__Doubleref(&libp->para[2]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letdouble(result7, 100, (double) CorrelatorTools::getSeperation((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]), (double) G__double(libp->para[5])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) CorrelatorTools::phiSliceImage((CrossCorrelator*) G__int(libp->para[0])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) CorrelatorTools::phiSliceFit((CrossCorrelator*) G__int(libp->para[0]), (TF2*) G__int(libp->para[1])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) CorrelatorTools::thetaSliceImage((CrossCorrelator*) G__int(libp->para[0])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) CorrelatorTools::thetaSliceFit((CrossCorrelator*) G__int(libp->para[0]), (TF2*) G__int(libp->para[1])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letdouble(result7, 100, (double) CorrelatorTools::gaus2D((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letdouble(result7, 100, (double) CorrelatorTools::checkLogLikelihood(
(double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]), (double) G__double(libp->para[5])
, (double) G__double(libp->para[6]), (double) G__double(libp->para[7])
, (double) G__double(libp->para[8]), (double) G__double(libp->para[9])
, (double) G__double(libp->para[10]), (double) G__double(libp->para[11])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letdouble(result7, 100, (double) CorrelatorTools::checkLogLikelihood((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]), (double) G__double(libp->para[5])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letdouble(result7, 100, (double) CorrelatorTools::checkLogLikelihood(
(double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]), (double) G__double(libp->para[5])
, (double) G__double(libp->para[6]), (double) G__double(libp->para[7])
, (double) G__double(libp->para[8]), (double) G__double(libp->para[9])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) CorrelatorTools::checkSyncSlips((RawAnitaHeader*) G__int(libp->para[0])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 115, (long) CorrelatorTools::getBaseColour((int) G__int(libp->para[0])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools::getMapColors();
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) CorrelatorTools::getMapColorExec());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) CorrelatorTools::getPrettyColorExec());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools::openBaseList((vector) libp->para[0].ref, (vector) libp->para[1].ref
, (vector) libp->para[2].ref, (vector) libp->para[3].ref
, (RampdemReader*) G__int(libp->para[4]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) CorrelatorTools::getBaseLatLonFromString((ifstream) libp->para[0].ref, (double) G__Doubleref(&libp->para[1])
, (double) G__Doubleref(&libp->para[2])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) CorrelatorTools::getAntFromMeasPhi((double) G__double(libp->para[0]), (AnitaRing::AnitaRing_t) G__int(libp->para[1])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) CorrelatorTools::getPhiSector((double) G__double(libp->para[0])));
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools::outputAllCheckInfo((CrossCorrelator*) G__int(libp->para[0]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools::outputHeaderCheckInfo((CrossCorrelator*) G__int(libp->para[0]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools::outputEventCheckInfo((CrossCorrelator*) G__int(libp->para[0]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_455_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools::outputCorrelationCheckInfo((CrossCorrelator*) G__int(libp->para[0]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__correlatorDict_455_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
CorrelatorTools* p;
void* tmp = (void*) G__int(libp->para[0]);
p = new CorrelatorTools((CorrelatorTools) tmp);
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_CorrelatorTools);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef CorrelatorTools G__TCorrelatorTools;
static int G__correlatorDict_455_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
char* gvp = (char*) G__getgvp();
long soff = G__getstructoffset();
int n = G__getaryconstruct();
//
//has_a_delete: 0
//has_own_delete1arg: 0
//has_own_delete2arg: 0
//
if (!soff) {
return(1);
}
if (n) {
if (gvp == (char*)G__PVOID) {
delete[] (CorrelatorTools*) soff;
} else {
G__setgvp((long) G__PVOID);
for (int i = n - 1; i >= 0; --i) {
((CorrelatorTools*) (soff+(sizeof(CorrelatorTools)i)))->~G__TCorrelatorTools();
}
G__setgvp((long)gvp);
}
} else {
if (gvp == (char)G__PVOID) {
delete (CorrelatorTools*) soff;
} else {
G__setgvp((long) G__PVOID);
((CorrelatorTools*) (soff))->~G__TCorrelatorTools();
G__setgvp((long)gvp);
}
}
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__correlatorDict_455_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
CorrelatorTools* dest = (CorrelatorTools*) G__getstructoffset();
const CorrelatorTools& obj = *dest;
result7->ref = (long) (&obj);
result7->obj.i = (long) (&obj);
return(1 || funcname || hash || result7 || libp) ;
}

/* EventCluster /
static int G__correlatorDict_490_0_1(G__value result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
EventCluster* p = NULL;
char* gvp = (char*) G__getgvp();
int n = G__getaryconstruct();
if (n) {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new EventCluster[n];
} else {
p = new((void*) gvp) EventCluster[n];
}
} else {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new EventCluster;
} else {
p = new((void*) gvp) EventCluster;
}
}
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_EventCluster);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
EventCluster* p = NULL;
char* gvp = (char*) G__getgvp();
//m: 5
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new EventCluster(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
} else {
p = new((void*) gvp) EventCluster(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
}
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_EventCluster);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((EventCluster*) G__getstructoffset())->addBaseToClusterList((UInt_t) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]), (double) G__double(libp->para[5]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((EventCluster*) G__getstructoffset())->addEventToClusterList((int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((EventCluster*) G__getstructoffset())->addFlightToClusterList((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (double) G__double(libp->para[4]), (double) G__double(libp->para[5]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 85, (long) EventCluster::Class());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 67, (long) EventCluster::Class_Name());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 115, (long) EventCluster::Class_Version());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
EventCluster::Dictionary();
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((EventCluster*) G__getstructoffset())->StreamerNVirtual((TBuffer) libp->para[0].ref);
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 67, (long) EventCluster::DeclFileName());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) EventCluster::ImplFileLine());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 67, (long) EventCluster::ImplFileName());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_490_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) EventCluster::DeclFileLine());
return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__correlatorDict_490_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
EventCluster* p;
void* tmp = (void*) G__int(libp->para[0]);
p = new EventCluster((EventCluster) tmp);
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_EventCluster);
return(1 || funcname || hash || result7 || libp) ;
}
[/code][/code]

9

3rd part ------ turns out I need 4 seperate posts!

[code]

// automatic destructor
typedef EventCluster G__TEventCluster;
static int G__correlatorDict_490_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
char* gvp = (char*) G__getgvp();
long soff = G__getstructoffset();
int n = G__getaryconstruct();
//
//has_a_delete: 1
//has_own_delete1arg: 0
//has_own_delete2arg: 0
//
if (!soff) {
return(1);
}
if (n) {
if (gvp == (char*)G__PVOID) {
delete[] (EventCluster*) soff;
} else {
G__setgvp((long) G__PVOID);
for (int i = n - 1; i >= 0; --i) {
((EventCluster*) (soff+(sizeof(EventCluster)i)))->~G__TEventCluster();
}
G__setgvp((long)gvp);
}
} else {
if (gvp == (char)G__PVOID) {
delete (EventCluster*) soff;
} else {
G__setgvp((long) G__PVOID);
((EventCluster*) (soff))->~G__TEventCluster();
G__setgvp((long)gvp);
}
}
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__correlatorDict_490_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
EventCluster* dest = (EventCluster*) G__getstructoffset();
*dest = (EventCluster) libp->para[0].ref;
const EventCluster& obj = *dest;
result7->ref = (long) (&obj);
result7->obj.i = (long) (&obj);
return(1 || funcname || hash || result7 || libp) ;
}

/* FlightAndTraverse /
static int G__correlatorDict_507_0_1(G__value result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
FlightAndTraverse* p = NULL;
char* gvp = (char*) G__getgvp();
int n = G__getaryconstruct();
if (n) {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new FlightAndTraverse[n];
} else {
p = new((void*) gvp) FlightAndTraverse[n];
}
} else {
if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
p = new FlightAndTraverse;
} else {
p = new((void*) gvp) FlightAndTraverse;
}
}
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_FlightAndTraverse);
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_507_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) ((FlightAndTraverse*) G__getstructoffset())->openAgapFiles());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_507_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) ((FlightAndTraverse*) G__getstructoffset())->openBasFiles());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_507_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) ((FlightAndTraverse*) G__getstructoffset())->openTexasFiles());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_507_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) ((FlightAndTraverse*) G__getstructoffset())->openCreamFiles());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_507_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) ((FlightAndTraverse*) G__getstructoffset())->openAwiFiles());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_507_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) ((FlightAndTraverse*) G__getstructoffset())->openNorwayFiles());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_507_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
G__letint(result7, 105, (long) ((FlightAndTraverse*) G__getstructoffset())->openShackletonFiles());
return(1 || funcname || hash || result7 || libp) ;
}

static int G__correlatorDict_507_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
((FlightAndTraverse*) G__getstructoffset())->getEntriesWithTime((UInt_t) G__int(libp->para[0]));
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__correlatorDict_507_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
FlightAndTraverse* p;
void* tmp = (void*) G__int(libp->para[0]);
p = new FlightAndTraverse((FlightAndTraverse) tmp);
result7->obj.i = (long) p;
result7->ref = (long) p;
result7->type = ‘u’;
result7->tagnum = G__get_linked_tagnum(&G__correlatorDictLN_FlightAndTraverse);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef FlightAndTraverse G__TFlightAndTraverse;
static int G__correlatorDict_507_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
char* gvp = (char*) G__getgvp();
long soff = G__getstructoffset();
int n = G__getaryconstruct();
//
//has_a_delete: 0
//has_own_delete1arg: 0
//has_own_delete2arg: 0
//
if (!soff) {
return(1);
}
if (n) {
if (gvp == (char*)G__PVOID) {
delete[] (FlightAndTraverse*) soff;
} else {
G__setgvp((long) G__PVOID);
for (int i = n - 1; i >= 0; --i) {
((FlightAndTraverse*) (soff+(sizeof(FlightAndTraverse)i)))->~G__TFlightAndTraverse();
}
G__setgvp((long)gvp);
}
} else {
if (gvp == (char)G__PVOID) {
delete (FlightAndTraverse*) soff;
} else {
G__setgvp((long) G__PVOID);
((FlightAndTraverse*) (soff))->~G__TFlightAndTraverse();
G__setgvp((long)gvp);
}
}
G__setnull(result7);
return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__correlatorDict_507_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
FlightAndTraverse* dest = (FlightAndTraverse*) G__getstructoffset();
*dest = (FlightAndTraverse) libp->para[0].ref;
const FlightAndTraverse& obj = *dest;
result7->ref = (long) (&obj);
result7->obj.i = (long) (&obj);
return(1 || funcname || hash || result7 || libp) ;
}

/* Setting up global function */

/*********************************************************

  • Member function Stub
    *********************************************************/

/* CrossCorrelatorGeometry */

/* CrossCorrelator */

/* CorrelatorTools */

/* EventCluster */

/* FlightAndTraverse */

/*********************************************************

  • Global function Stub
    *********************************************************/

/*********************************************************

  • Get size of pointer to member function
    *********************************************************/
    class G__Sizep2memfunccorrelatorDict {
    public:
    G__Sizep2memfunccorrelatorDict(): p(&G__Sizep2memfunccorrelatorDict::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof§); }
    private:
    size_t (G__Sizep2memfunccorrelatorDict::*p)();
    };

size_t G__get_sizep2memfunccorrelatorDict()
{
G__Sizep2memfunccorrelatorDict a;
G__setsizep2memfunc((int)a.sizep2memfunc());
return((size_t)a.sizep2memfunc());
}

/*********************************************************

  • virtual base class offset calculation interface
    *********************************************************/

    /* Setting up class inheritance */

/*********************************************************

  • Inheritance information setup/
    *********************************************************/
    extern “C” void G__cpp_setup_inheritancecorrelatorDict() {

    /* Setting up class inheritance */
    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry))) {
    CrossCorrelatorGeometry G__Lderived;
    G__Lderived=(CrossCorrelatorGeometry    )0x1000;
    {
    TObject G__Lpbase=(TObject)G__Lderived;
    G__inheritance_setup(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry),G__get_linked_tagnum(&G__correlatorDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
    }
    }
    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator))) {
    CrossCorrelator G__Lderived;
    G__Lderived=(CrossCorrelator    )0x1000;
    {
    TObject G__Lpbase=(TObject)G__Lderived;
    G__inheritance_setup(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator),G__get_linked_tagnum(&G__correlatorDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
    }
    }
    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__correlatorDictLN_EventCluster))) {
    EventCluster G__Lderived;
    G__Lderived=(EventCluster    )0x1000;
    {
    TObject G__Lpbase=(TObject)G__Lderived;
    G__inheritance_setup(G__get_linked_tagnum(&G__correlatorDictLN_EventCluster),G__get_linked_tagnum(&G__correlatorDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
    }
    }
    }

/*********************************************************

  • typedef information setup/
    *********************************************************/
    extern “C” void G__cpp_setup_typetablecorrelatorDict() {

    /* Setting up typedef entry /
    G__search_typename2(“Int_t”,105,-1,0,-1);
    G__setnewtype(-1,“Signed integer 4 bytes (int)”,0);
    G__search_typename2(“UInt_t”,104,-1,0,-1);
    G__setnewtype(-1,“Unsigned integer 4 bytes (unsigned int)”,0);
    G__search_typename2(“Double_t”,100,-1,0,-1);
    G__setnewtype(-1,“Double 8 bytes”,0);
    G__search_typename2(“Version_t”,115,-1,0,-1);
    G__setnewtype(-1,“Class version identifier (short)”,0);
    G__search_typename2(“Color_t”,115,-1,0,-1);
    G__setnewtype(-1,“Color number (short)”,0);
    G__search_typename2(“TMatrixTBase<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTBaselEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTBase<Double_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTBaselEdoublegR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TVectorT<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TVectorTlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TVectorT<Double_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TVectorTlEdoublegR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixT<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTRow_const<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTRow_constlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTColumn_const<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTColumn_constlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTDiag_const<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTDiag_constlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTFlat_const<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTFlat_constlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTSub_const<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTSub_constlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTSparseRow_const<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTSparseDiag_const<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTRow<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTRowlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTColumn<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTColumnlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTDiag<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTDiaglEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTFlat<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTFlatlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTSub<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTSublEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTSparseRow<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTSparseRowlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TMatrixTSparseDiag<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TMatrixTSparseDiaglEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TElementActionT<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TElementActionTlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“TElementPosActionT<Float_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_TElementPosActionTlEfloatgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject    ,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__correlatorDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“iterator<bidirectional_iterator_tag,TObject*>”,117,G__get_linked_tagnum(&G__correlatorDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“iterator<bidirectional_iterator_tag,TObject*,long>”,117,G__get_linked_tagnum(&G__correlatorDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>”,117,G__get_linked_tagnum(&G__correlatorDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“vector<std::vector >”,117,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“reverse_iterator<const_iterator>”,117,G__get_linked_tagnum(&G__correlatorDictLN_reverse_iteratorlEvectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgR));
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“reverse_iterator”,117,G__get_linked_tagnum(&G__correlatorDictLN_reverse_iteratorlEvectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgR));
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“vector<vector<short,allocator >>”,117,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“vector”,117,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“reverse_iterator<const_iterator>”,117,G__get_linked_tagnum(&G__correlatorDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEintcOallocatorlEintgRsPgR));
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“reverse_iterator”,117,G__get_linked_tagnum(&G__correlatorDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEintcOallocatorlEintgRsPgR));
    G__setnewtype(-1,NULL,0);
    G__search_typename2(“vector<UInt_t>”,117,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
    G__setnewtype(-1,NULL,0);
    }

/*********************************************************

  • Data Member information setup/
    *********************************************************/

    /* Setting up class,struct,union tag member variable */

    /* CrossCorrelatorGeometry /
    static void G__setup_memvarCrossCorrelatorGeometry(void) {
    G__tag_memvar_setup(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry));
    { CrossCorrelatorGeometry p; p=(CrossCorrelatorGeometry)0x1000; if § { }
    G__memvar_setup((void    )((long)(&p->phiArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“phiArray[180]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->thetaArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“thetaArray[90]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->cosPhiArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“cosPhiArray[180]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->cosThetaArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“cosThetaArray[90]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->sinPhiArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“sinPhiArray[180]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->sinThetaArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“sinThetaArray[90]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->deltaTArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“deltaTArray[40][15][180][90]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->finePhiArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“finePhiArray[120]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineThetaArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fineThetaArray[60]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->cosFinePhiArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“cosFinePhiArray[120]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->cosFineThetaArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“cosFineThetaArray[60]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->sinFinePhiArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“sinFinePhiArray[120]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->sinFineThetaArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“sinFineThetaArray[60]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineDeltaTArray)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fineDeltaTArray[40][15][120][60]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fAntPhi)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fAntPhi[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fSinAntPhi)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fSinAntPhi[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fCosAntPhi)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fCosAntPhi[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fAntR)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fAntR[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fAntZ)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fAntZ[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->within12dB)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“within12dB[40][180][90]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->numAntennas12dB)-(long)§),105,0,0,-1,G__defined_typename(“Int_t”),-1,1,“numAntennas12dB[180][90]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->phiGainData)-(long)§),100,0,0,-1,-1,-1,1,“phiGainData[2][180]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->thetaGainData)-(long)§),100,0,0,-1,-1,-1,1,“thetaGainData[2][180]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->baseline)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“baseline=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->baselinedB)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“baselinedB=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fitProbSigma)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fitProbSigma[40][125]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->boreholeFile)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TFile),-1,-1,1,“boreholeFile=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->seaveyVFile)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TFile),-1,-1,1,“seaveyVFile=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->seaveyHFile)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TFile),-1,-1,1,“seaveyHFile=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->seavey45File)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TFile),-1,-1,1,“seavey45File=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->boreholeChain)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TTree),-1,-1,1,“boreholeChain=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->seaveyVChain)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TTree),-1,-1,1,“seaveyVChain=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->seaveyHChain)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TTree),-1,-1,1,“seaveyHChain=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->seavey45Chain)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TTree),-1,-1,1,“seavey45Chain=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->boreholeEntry)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“boreholeEntry=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->seaveyVEntry)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“seaveyVEntry=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->seaveyHEntry)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“seaveyHEntry=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->seavey45Entry)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“seavey45Entry=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->aboveBaselineFilter)-(long)§),100,0,0,-1,-1,-1,1,“aboveBaselineFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->peakyFilterDrop)-(long)§),100,0,0,-1,-1,-1,1,“peakyFilterDrop=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->numRoundsAdaptiveFiltering)-(long)§),105,0,0,-1,-1,-1,1,“numRoundsAdaptiveFiltering=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->setSimpleFilterAdaptive)-(long)§),105,0,0,-1,-1,-1,1,“setSimpleFilterAdaptive=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->setSimpleFilterSatellite)-(long)§),105,0,0,-1,-1,-1,1,“setSimpleFilterSatellite=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->satelliteLowerBound)-(long)§),105,0,0,-1,-1,-1,1,“satelliteLowerBound=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->satelliteUpperBound)-(long)§),105,0,0,-1,-1,-1,1,“satelliteUpperBound=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->setFilterNorthSatellite)-(long)§),105,0,0,-1,-1,-1,1,“setFilterNorthSatellite=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->normBeforeFilter)-(long)§),105,0,0,-1,-1,-1,1,“normBeforeFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->adaptiveWithFixedFilterStage)-(long)§),105,0,0,-1,-1,-1,1,“adaptiveWithFixedFilterStage=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->useWhiteNoiseFilter)-(long)§),105,0,0,-1,-1,-1,1,“useWhiteNoiseFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->coherentWaveformFilter)-(long)§),105,0,0,-1,-1,-1,1,“coherentWaveformFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->aboveCoherentBaselineFilter)-(long)§),100,0,0,-1,-1,-1,1,“aboveCoherentBaselineFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->ignoreNonRF)-(long)§),105,0,0,-1,-1,-1,1,“ignoreNonRF=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->ignorePulsing)-(long)§),105,0,0,-1,-1,-1,1,“ignorePulsing=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->requireGps)-(long)§),105,0,0,-1,-1,-1,1,“requireGps=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->cutPayloadBlasts)-(long)§),105,0,0,-1,-1,-1,1,“cutPayloadBlasts=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->useHeaderChecks)-(long)§),105,0,0,-1,-1,-1,1,“useHeaderChecks=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->useEventChecks)-(long)§),105,0,0,-1,-1,-1,1,“useEventChecks=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->useCorrelationChecks)-(long)§),105,0,0,-1,-1,-1,1,“useCorrelationChecks=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->rotationFactor)-(long)§),100,0,0,-1,-1,-1,1,“rotationFactor=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->rotatedCorrelationCut)-(long)§),100,0,0,-1,-1,-1,1,“rotatedCorrelationCut=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->rand)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TRandom3),-1,-1,1,“rand=”,0,(char*)NULL);
    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename(“Double_t”),-1,4,“fThetaWave=”,0,(char*)NULL);
    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename(“Double_t”),-1,4,“fPhiWave=”,0,(char*)NULL);
    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TClass),-1,-2,4,“fgIsA=”,0,(char*)NULL);
    }
    G__tag_memvar_reset();
    }

    /* CrossCorrelator /
    static void G__setup_memvarCrossCorrelator(void) {
    G__tag_memvar_setup(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator));
    { CrossCorrelator p; p=(CrossCorrelator)0x1000; if § { }
    G__memvar_setup((void    )((long)(&p->correlationArray)-(long)§),100,0,0,-1,-1,-1,1,“correlationArray[180][90]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineCorrelationArray)-(long)§),100,0,0,-1,-1,-1,1,“fineCorrelationArray[120][60]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->numCrossCorrelationsArray)-(long)§),105,0,0,-1,-1,-1,1,“numCrossCorrelationsArray[180][90]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->numCrossCorrelations)-(long)§),105,0,0,-1,-1,-1,1,“numCrossCorrelations=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->triggeredPhi)-(long)§),105,0,0,-1,-1,-1,1,“triggeredPhi[16]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->triggeredAnt)-(long)§),105,0,0,-1,-1,-1,1,“triggeredAnt[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineTriggeredPhi)-(long)§),105,0,0,-1,-1,-1,1,“fineTriggeredPhi[16]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineTriggeredAnt)-(long)§),105,0,0,-1,-1,-1,1,“fineTriggeredAnt[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->numFineTriggeredAnt)-(long)§),105,0,0,-1,-1,-1,1,“numFineTriggeredAnt=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->midPhi)-(long)§),100,0,0,-1,-1,-1,1,“midPhi=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->midTheta)-(long)§),100,0,0,-1,-1,-1,1,“midTheta=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->midPhiBin)-(long)§),105,0,0,-1,-1,-1,1,“midPhiBin=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->midThetaBin)-(long)§),105,0,0,-1,-1,-1,1,“midThetaBin=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineMidPhi)-(long)§),100,0,0,-1,-1,-1,1,“fineMidPhi=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineMidTheta)-(long)§),100,0,0,-1,-1,-1,1,“fineMidTheta=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineMidPhiBin)-(long)§),105,0,0,-1,-1,-1,1,“fineMidPhiBin=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineMidThetaBin)-(long)§),105,0,0,-1,-1,-1,1,“fineMidThetaBin=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->meanCrossCorrelation)-(long)§),100,0,0,-1,-1,-1,1,“meanCrossCorrelation=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->peakCorrVal)-(long)§),100,0,0,-1,-1,-1,1,“peakCorrVal=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->finePeakCorrVal)-(long)§),100,0,0,-1,-1,-1,1,“finePeakCorrVal=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->maxPhi)-(long)§),105,0,0,-1,-1,-1,1,“maxPhi=”,0,“the peak phi sector for the fineCrossCorrelation”);
    G__memvar_setup((void*)((long)(&p->fWaveformSNR)-(long)§),100,0,0,-1,-1,-1,1,“fWaveformSNR[40]=”,0,“the snr of the grfirst waveforms”);
    G__memvar_setup((void*)((long)(&p->fWaveformRMS)-(long)§),100,0,0,-1,-1,-1,1,“fWaveformRMS[40]=”,0,“the rms of the grfirst waveforms”);
    G__memvar_setup((void*)((long)(&p->fWaveformP2P)-(long)§),100,0,0,-1,-1,-1,1,“fWaveformP2P[40]=”,0,“the p2p of the grfirst waveforms”);
    G__memvar_setup((void*)((long)(&p->fWaveformMean)-(long)§),100,0,0,-1,-1,-1,1,“fWaveformMean[40]=”,0,“the mean of the grfirst waveforms”);
    G__memvar_setup((void*)((long)(&p->secondMeasPhi)-(long)§),100,0,0,-1,-1,-1,1,“secondMeasPhi=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->secondMeasTheta)-(long)§),100,0,0,-1,-1,-1,1,“secondMeasTheta=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->secondPeakCorrVal)-(long)§),100,0,0,-1,-1,-1,1,“secondPeakCorrVal=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fFiltered)-(long)§),105,0,0,-1,-1,-1,1,“fFiltered=”,0,“was the adaptive filter used? 1 yes, 0 no”);
    G__memvar_setup((void*)((long)(&p->fCoherentFiltered)-(long)§),105,0,0,-1,-1,-1,1,“fCoherentFiltered=”,0,“was the coherently summed filter used? 1 yes, 0 no”);
    G__memvar_setup((void*)((long)(&p->crossCorrelation)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TH2D),-1,-1,1,“crossCorrelation=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fineCrossCorrelation)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TH2D),-1,-1,1,“fineCrossCorrelation=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->grFirst)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“grFirst[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->grNorm)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“grNorm[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->grPass)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“grPass[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->grTemp)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“grTemp[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->grInt)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“grInt[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->grFinal)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“grFinal[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->grCorr)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“grCorr[781]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->coherentWaveformFiltered)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“coherentWaveformFiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->coherentWaveformUnfiltered)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“coherentWaveformUnfiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->hilbertCoherentWaveformFiltered)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“hilbertCoherentWaveformFiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->hilbertCoherentWaveformUnfiltered)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“hilbertCoherentWaveformUnfiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->coherentPowerSpectrumFiltered)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“coherentPowerSpectrumFiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->coherentPowerSpectrumUnfiltered)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“coherentPowerSpectrumUnfiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->coherentBaselineFiltered)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“coherentBaselineFiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->coherentBaselineUnfiltered)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“coherentBaselineUnfiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->peakCoherentWaveformFiltered)-(long)§),100,0,0,-1,-1,-1,1,“peakCoherentWaveformFiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->peakCoherentWaveformUnfiltered)-(long)§),100,0,0,-1,-1,-1,1,“peakCoherentWaveformUnfiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->peakHilbertCoherentWaveformFiltered)-(long)§),100,0,0,-1,-1,-1,1,“peakHilbertCoherentWaveformFiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->peakHilbertCoherentWaveformUnfiltered)-(long)§),100,0,0,-1,-1,-1,1,“peakHilbertCoherentWaveformUnfiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->rmsHilbertCoherentWaveformUnfiltered)-(long)§),100,0,0,-1,-1,-1,1,“rmsHilbertCoherentWaveformUnfiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->snrHilbertCoherentWaveformUnfiltered)-(long)§),100,0,0,-1,-1,-1,1,“snrHilbertCoherentWaveformUnfiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->timePeakHilbertCoherentWaveformUnfiltered)-(long)§),100,0,0,-1,-1,-1,1,“timePeakHilbertCoherentWaveformUnfiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->rmsHilbertCoherentWaveformFiltered)-(long)§),100,0,0,-1,-1,-1,1,“rmsHilbertCoherentWaveformFiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->snrHilbertCoherentWaveformFiltered)-(long)§),100,0,0,-1,-1,-1,1,“snrHilbertCoherentWaveformFiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->timePeakHilbertCoherentWaveformFiltered)-(long)§),100,0,0,-1,-1,-1,1,“timePeakHilbertCoherentWaveformFiltered=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->rotatedPeakCorrelation)-(long)§),100,0,0,-1,-1,-1,1,“rotatedPeakCorrelation=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->theFFT)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_FFTWComplex),-1,-1,1,“theFFT[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fracFilteredFreqs)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fracFilteredFreqs=”,0,“fraction of filtered frequencies from 300 to 900 MHz”);
    G__memvar_setup((void*)((long)(&p->adjustedBaseline)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“adjustedBaseline[6]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->averagedEventPowerSpec)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TGraph),-1,-1,1,“averagedEventPowerSpec[6]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fNorthFacing)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fNorthFacing[40]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->aboveBaselineFilter)-(long)§),100,0,0,-1,-1,-1,1,“aboveBaselineFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->peakyFilterDrop)-(long)§),100,0,0,-1,-1,-1,1,“peakyFilterDrop=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->numRoundsAdaptiveFiltering)-(long)§),105,0,0,-1,-1,-1,1,“numRoundsAdaptiveFiltering=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->setSimpleFilterAdaptive)-(long)§),105,0,0,-1,-1,-1,1,“setSimpleFilterAdaptive=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->setSimpleFilterSatellite)-(long)§),105,0,0,-1,-1,-1,1,“setSimpleFilterSatellite=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->satelliteLowerBound)-(long)§),105,0,0,-1,-1,-1,1,“satelliteLowerBound=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->satelliteUpperBound)-(long)§),105,0,0,-1,-1,-1,1,“satelliteUpperBound=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->setFilterNorthSatellite)-(long)§),105,0,0,-1,-1,-1,1,“setFilterNorthSatellite=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->normBeforeFilter)-(long)§),105,0,0,-1,-1,-1,1,“normBeforeFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->adaptiveWithFixedFilterStage)-(long)§),105,0,0,-1,-1,-1,1,“adaptiveWithFixedFilterStage=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->useWhiteNoiseFilter)-(long)§),105,0,0,-1,-1,-1,1,“useWhiteNoiseFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->coherentWaveformFilter)-(long)§),105,0,0,-1,-1,-1,1,“coherentWaveformFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->aboveCoherentBaselineFilter)-(long)§),100,0,0,-1,-1,-1,1,“aboveCoherentBaselineFilter=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->ignoreNonRF)-(long)§),105,0,0,-1,-1,-1,1,“ignoreNonRF=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->ignorePulsing)-(long)§),105,0,0,-1,-1,-1,1,“ignorePulsing=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->requireGps)-(long)§),105,0,0,-1,-1,-1,1,“requireGps=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->cutPayloadBlasts)-(long)§),105,0,0,-1,-1,-1,1,“cutPayloadBlasts=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->useHeaderChecks)-(long)§),105,0,0,-1,-1,-1,1,“useHeaderChecks=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->useEventChecks)-(long)§),105,0,0,-1,-1,-1,1,“useEventChecks=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->useCorrelationChecks)-(long)§),105,0,0,-1,-1,-1,1,“useCorrelationChecks=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->rotationFactor)-(long)§),100,0,0,-1,-1,-1,1,“rotationFactor=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->rotatedCorrelationCut)-(long)§),100,0,0,-1,-1,-1,1,“rotatedCorrelationCut=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->rand)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TRandom3),-1,-1,1,“rand=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fFailHeaderCheck)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fFailHeaderCheck=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fFailEventCheck)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fFailEventCheck=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fFailCorrelationCheck)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fFailCorrelationCheck=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fNotRFTrigger)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fNotRFTrigger=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fFailGpsTiming)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fFailGpsTiming=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fCalPulserEvent)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fCalPulserEvent=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fSyncSlipFlag)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fSyncSlipFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fRFCMStatus)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fRFCMStatus[5]=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fMainRFCMOff)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fMainRFCMOff=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fTDEventFlag)-(long)§),105,0,0,-1,G__defined_typename(“Int_t”),-1,1,“fTDEventFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fWFEventFlag)-(long)§),105,0,0,-1,G__defined_typename(“Int_t”),-1,1,“fWFEventFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fPayloadBlastFlag)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fPayloadBlastFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fShortWaveformFlag)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fShortWaveformFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fVarnerEventFlag)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“fVarnerEventFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fDCOffsetFlag)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fDCOffsetFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fSurfSaturatedFlag)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fSurfSaturatedFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fCooldownBlastFlag)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fCooldownBlastFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fPayloadBlastWaveformFlag)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fPayloadBlastWaveformFlag=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fTooManyFilteredFreqs)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fTooManyFilteredFreqs=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fPhiAtEdgeOfMap)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fPhiAtEdgeOfMap=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fThetaAtEdgeOfMap)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fThetaAtEdgeOfMap=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fThetaPointingUpwards)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fThetaPointingUpwards=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fPhiSectorMasked)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fPhiSectorMasked=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fPhiSectorDidNotTrigger)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fPhiSectorDidNotTrigger=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fPeakCorrNegative)-(long)§),103,0,0,-1,G__defined_typename(“Bool_t”),-1,1,“fPeakCorrNegative=”,0,(char*)NULL);
    G__memvar_setup((void*)((long)(&p->fNumRFCMOn)-(long)§),105,0,0,-1,-1,-1,1,“fNumRFCMOn=”,0,(char*)NULL);
    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TClass),-1,-2,4,“fgIsA=”,0,(char*)NULL);
    }
    G__tag_memvar_reset();
    }

[/code][/code]

10

last bit (hooray!):

[code]

/* CorrelatorTools */
static void G__setup_memvarCorrelatorTools(void) {
G__tag_memvar_setup(G__get_linked_tagnum(&G__correlatorDictLN_CorrelatorTools));
{ CorrelatorTools p; p=(CorrelatorTools)0x1000; if § { }
}
G__tag_memvar_reset();
}

/* EventCluster /
static void G__setup_memvarEventCluster(void) {
G__tag_memvar_setup(G__get_linked_tagnum(&G__correlatorDictLN_EventCluster));
{ EventCluster p; p=(EventCluster)0x1000; if § { }
G__memvar_setup((void)((long)(&p->fRun)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“fRun=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->fEventNumber)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“fEventNumber=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->fLat)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fLat=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->fLon)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fLon=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->fAlt)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“fAlt=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->baseClusters)-(long)§),105,0,0,-1,-1,-1,1,“baseClusters=”,0,“number of bases the event is clustered to”);
G__memvar_setup((void*)((long)(&p->baseNumberList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename(“vector<UInt_t>”),-1,1,“baseNumberList=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->baseLonList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“baseLonList=”,0,“vectors containing the information”);
G__memvar_setup((void*)((long)(&p->baseLatList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“baseLatList=”,0,“of the base that the event”);
G__memvar_setup((void*)((long)(&p->baseAltList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“baseAltList=”,0,“is clustered to”);
G__memvar_setup((void*)((long)(&p->baseLogLikeList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“baseLogLikeList=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->baseDistanceList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“baseDistanceList=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightClusters)-(long)§),105,0,0,-1,-1,-1,1,“flightClusters=”,0,“number of flights/traverses the event is clustered to”);
G__memvar_setup((void*)((long)(&p->flightLonList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“flightLonList=”,0,“vectors containing the information”);
G__memvar_setup((void*)((long)(&p->flightLatList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“flightLatList=”,0,“of the flight that the event”);
G__memvar_setup((void*)((long)(&p->flightAltList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“flightAltList=”,0,“is clustered to”);
G__memvar_setup((void*)((long)(&p->flightTimeList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename(“vector<UInt_t>”),-1,1,“flightTimeList=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightLogLikeList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“flightLogLikeList=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightDistanceList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“flightDistanceList=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->eventClusters)-(long)§),105,0,0,-1,-1,-1,1,“eventClusters=”,0,“number of events the event is clustered to”);
G__memvar_setup((void*)((long)(&p->eventNumberList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename(“vector”),-1,1,“eventNumberList=”,0,“vector of event numbers the event is clustered to”);
G__memvar_setup((void*)((long)(&p->eventLogLikeList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“eventLogLikeList=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->eventDistanceList)-(long)§),117,0,0,G__get_linked_tagnum(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename(“vector”),-1,1,“eventDistanceList=”,0,(char*)NULL);
G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TClass),-1,-2,4,“fgIsA=”,0,(char*)NULL);
}
G__tag_memvar_reset();
}

/* FlightAndTraverse /
static void G__setup_memvarFlightAndTraverse(void) {
G__tag_memvar_setup(G__get_linked_tagnum(&G__correlatorDictLN_FlightAndTraverse));
{ FlightAndTraverse p; p=(FlightAndTraverse)0x1000; if § { }
G__memvar_setup((void)((long)(&p->flightFiles)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TFile),-1,-1,1,“flightFiles[7][71]=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightTrees)-(long)§),85,0,0,G__get_linked_tagnum(&G__correlatorDictLN_TTree),-1,-1,1,“flightTrees[7][71]=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightTime)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“flightTime[7][71]=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightLat)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“flightLat[7][71]=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightLon)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“flightLon[7][71]=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightAlt)-(long)§),100,0,0,-1,G__defined_typename(“Double_t”),-1,1,“flightAlt[7][71]=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightEntry)-(long)§),105,0,0,-1,G__defined_typename(“Int_t”),-1,1,“flightEntry[7][71][3]=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->flightTimes)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“flightTimes[7][71][3]=”,0,(char*)NULL);
G__memvar_setup((void*)((long)(&p->numFlightsInData)-(long)§),104,0,0,-1,G__defined_typename(“UInt_t”),-1,1,“numFlightsInData[7]=”,0,(char*)NULL);
}
G__tag_memvar_reset();
}

extern “C” void G__cpp_setup_memvarcorrelatorDict() {
}
/***********************************************************

***********************************************************/

/*********************************************************

  • Member function information setup for each class
    /
    static void G__setup_memfuncCrossCorrelatorGeometry(void) {
    /     CrossCorrelatorGeometry /
    G__tag_memfunc_setup(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry));
    G__memfunc_setup(“CrossCorrelatorGeometry”,2419,G__correlatorDict_220_0_1, 105, G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry), -1, 0, 0, 1, 1, 0, “”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“CrossCorrelatorGeometry”,2419,G__correlatorDict_220_0_2, 105, G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry), -1, 0, 1, 1, 1, 0, “u ‘string’ - 0 - variablesFile”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“fillFineDeltaTArray”,1894,G__correlatorDict_220_0_3, 121, -1, -1, 0, 3, 1, 1, 0,
    "d - - 0 - midPhi d - - 0 - midTheta "
    “I - - 0 - fineTriggeredAnt”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“getDeltaTExpected”,1712,G__correlatorDict_220_0_4, 100, -1, G__defined_typename(“Double_t”), 0, 4, 1, 1, 0,
    "i - ‘Int_t’ 0 - ant1 i - ‘Int_t’ 0 - ant2 "
    “d - ‘Double_t’ 0 - phiWave d - ‘Double_t’ 0 - thetaWave”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“getDeltaTExpected”,1712,G__correlatorDict_220_0_5, 100, -1, G__defined_typename(“Double_t”), 0, 8, 1, 1, 0,
    "i - ‘Int_t’ 0 - ant1 i - ‘Int_t’ 0 - ant2 "
    "d - ‘Double_t’ 0 - phiWave d - ‘Double_t’ 0 - thetaWave "
    "d - ‘Double_t’ 0 - sinPhiWave d - ‘Double_t’ 0 - cosPhiWave "
    “d - ‘Double_t’ 0 - sinThetaWave d - ‘Double_t’ 0 - cosThetaWave”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“GetNumberAsString”,1716,G__correlatorDict_220_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
    “u ‘basic_ifstream<char,char_traits >’ ‘ifstream’ 1 - fin u ‘string’ - 1 - number”, “GetNextNumberAsString”, (void    ) NULL, 0);
    G__memfunc_setup(“readInCorrelatorVariables”,2569,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, “u ‘string’ - 0 - variablesFile”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“setDefaultCorrelatorVariables”,3015,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“readGainData”,1173,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“readBaselineData”,1593,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“readWillyFieldEventData”,2317,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“setupPhiThetaArray”,1863,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“fillDeltaTArray”,1508,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“checkWithin12dB”,1402,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“checkWithin2PhiSectors”,2215,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 4, 0,
    “i - - 0 - ant1 i - - 0 - ant2”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“Class”,502,G__correlatorDict_220_0_16, 85, G__get_linked_tagnum(&G__correlatorDictLN_TClass), -1, 0, 0, 3, 1, 0, “”, (char    )NULL, (void    ) (TClass     (    )())(&CrossCorrelatorGeometry::Class), 0);
    G__memfunc_setup(“Class_Name”,982,G__correlatorDict_220_0_17, 67, -1, -1, 0, 0, 3, 1, 1, “”, (char    )NULL, (void    ) (const char     (    )())(&CrossCorrelatorGeometry::Class_Name), 0);
    G__memfunc_setup(“Class_Version”,1339,G__correlatorDict_220_0_18, 115, -1, G__defined_typename(“Version_t”), 0, 0, 3, 1, 0, “”, (char    )NULL, (void    ) (Version_t (    )())(&CrossCorrelatorGeometry::Class_Version), 0);
    G__memfunc_setup(“Dictionary”,1046,G__correlatorDict_220_0_19, 121, -1, -1, 0, 0, 3, 1, 0, “”, (char    )NULL, (void    ) (void (    )())(&CrossCorrelatorGeometry::Dictionary), 0);
    G__memfunc_setup(“IsA”,253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__correlatorDictLN_TClass), -1, 0, 0, 1, 1, 8, “”, (char    )NULL, (void    ) NULL, 1);
    G__memfunc_setup(“ShowMembers”,1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
    “u ‘TMemberInspector’ - 1 - insp C - - 0 - parent”, (char    )NULL, (void    ) NULL, 1);
    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);
    G__memfunc_setup(“StreamerNVirtual”,1656,G__correlatorDict_220_0_23, 121, -1, -1, 0, 1, 1, 1, 0, “u ‘TBuffer’ - 1 - b”, (char    )NULL, (void    ) NULL, 0);
    G__memfunc_setup(“DeclFileName”,1145,G__correlatorDict_220_0_24, 67, -1, -1, 0, 0, 3, 1, 1, “”, (char    )NULL, (void    ) (const char     (    )())(&CrossCorrelatorGeometry::DeclFileName), 0);
    G__memfunc_setup(“ImplFileLine”,1178,G__correlatorDict_220_0_25, 105, -1, -1, 0, 0, 3, 1, 0, “”, (char    )NULL, (void    ) (int ()())(&CrossCorrelatorGeometry::ImplFileLine), 0);
    G__memfunc_setup(“ImplFileName”,1171,G__correlatorDict_220_0_26, 67, -1, -1, 0, 0, 3, 1, 1, “”, (char    )NULL, (void*) (const char* ()())(&CrossCorrelatorGeometry::ImplFileName), 0);
    G__memfunc_setup(“DeclFileLine”,1152,G__correlatorDict_220_0_27, 105, -1, -1, 0, 0, 3, 1, 0, “”, (char    )NULL, (void*) (int ()())(&CrossCorrelatorGeometry::DeclFileLine), 0);
    // automatic copy constructor
    G__memfunc_setup(“CrossCorrelatorGeometry”, 2419, G__correlatorDict_220_0_28, (int) (‘i’),
    G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry), -1, 0, 1, 1, 1, 0, “u ‘CrossCorrelatorGeometry’ - 11 - -”, (char    ) NULL, (void*) NULL, 0);
    // automatic destructor
    G__memfunc_setup("~CrossCorrelatorGeometry", 2545, G__correlatorDict_220_0_29, (int) (‘y’), -1, -1, 0, 0, 1, 1, 0, “”, (char*) NULL, (void*) NULL, 1);
    // automatic assignment operator
    G__memfunc_setup(“operator=”, 937, G__correlatorDict_220_0_30, (int) (‘u’), G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry), -1, 1, 1, 1, 1, 0, “u ‘CrossCorrelatorGeometry’ - 11 - -”, (char*) NULL, (void*) NULL, 0);
    G__tag_memfunc_reset();
    }

static void G__setup_memfuncCrossCorrelator(void) {
/* CrossCorrelator /
G__tag_memfunc_setup(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator));
G__memfunc_setup(“CrossCorrelator”,1575,G__correlatorDict_420_0_1, 105, G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator), -1, 0, 0, 1, 1, 0, “”, (char)NULL, (void*) NULL, 0);
G__memfunc_setup(“CrossCorrelator”,1575,G__correlatorDict_420_0_2, 105, G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator), -1, 0, 6, 1, 1, 0,
"U ‘CalibratedAnitaEvent’ - 0 - evPtr U ‘RawAnitaHeader’ - 0 - hdPtr "
"U ‘Adu5Pat’ - 0 - patPtr U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom "
“h - ‘UInt_t’ 0 - numNotches D - ‘Double_t’ 2 - notchArray”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“CrossCorrelator”,1575,G__correlatorDict_420_0_3, 105, G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator), -1, 0, 4, 1, 1, 0,
"U ‘CalibratedAnitaEvent’ - 0 - evPtr U ‘RawAnitaHeader’ - 0 - hdPtr "
“U ‘Adu5Pat’ - 0 - patPtr U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“crossCorrelate”,1483,G__correlatorDict_420_0_4, 121, -1, -1, 0, 2, 1, 1, 0,
“U ‘RawAnitaHeader’ - 0 - hdPtr U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“fineCrossCorrelate”,1869,G__correlatorDict_420_0_5, 121, -1, -1, 0, 2, 1, 1, 0,
“U ‘RawAnitaHeader’ - 0 - hdPtr U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“coherentlySummedWaveformFiltered”,3358,G__correlatorDict_420_0_6, 121, -1, -1, 0, 1, 1, 1, 0, “U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“coherentlySummedWaveformUnfiltered”,3585,G__correlatorDict_420_0_7, 121, -1, -1, 0, 1, 1, 1, 0, “U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getGausFit2D”,1129,G__correlatorDict_420_0_8, 85, G__get_linked_tagnum(&G__correlatorDictLN_TF2), -1, 0, 0, 1, 1, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“initialiseVariables”,1988,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“readInCrossCorrGeomVariables”,2836,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, “U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getFirstWaveforms”,1794,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, “U ‘CalibratedAnitaEvent’ - 0 - evPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“setupWaveforms”,1515,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0,
"U ‘RawAnitaHeader’ - 0 - hdPtr h - ‘UInt_t’ 0 - numNotches "
“d - - 0 - notchArray[][2] U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“setupWaveforms”,1515,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
“U ‘RawAnitaHeader’ - 0 - hdPtr U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“adaptiveFilter”,1460,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
“U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom i - - 0 - length”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“simpleFilter”,1264,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
“i - ‘Int_t’ 0 - bin I - ‘Int_t’ 0 - filteredFreq”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“simpleFilterSatellite”,2199,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
“i - ‘Int_t’ 0 - bin I - ‘Int_t’ 0 - filteredFreq”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“peakyFilter”,1152,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0,
"i - ‘Int_t’ 0 - bin I - ‘Int_t’ 0 - filteredFreq "
"D - ‘Double_t’ 0 - powerThis i - ‘Int_t’ 0 - newLength "
“D - ‘Double_t’ 0 - freqVals i - ‘Int_t’ 1 - numBinsFiltered”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“peakyFilterSatellite”,2087,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0,
"i - ‘Int_t’ 0 - bin I - ‘Int_t’ 0 - filteredFreq "
"D - ‘Double_t’ 0 - powerThis i - ‘Int_t’ 0 - newLength "
“D - ‘Double_t’ 0 - freqVals i - ‘Int_t’ 1 - numBinsFiltered”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“whiteNoiseFilter”,1669,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0,
"i - - 0 - ant i - - 0 - bin "
“d - - 0 - meanDiff U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“findFractionFilteredFreqs”,2567,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename(“Double_t”), 0, 3, 1, 4, 0,
"i - ‘Int_t’ 0 - nBins d - ‘Double_t’ 0 - deltaF "
“I - ‘Int_t’ 0 - filteredFreq”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getTriggeredPhi”,1534,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getTriggeredAnt”,1536,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getPeakPhi”,994,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getFinePeakPhi”,1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getFineTriggeredAnt”,1922,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getNormalisedGraph”,1856,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, “i - - 0 - ant”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getNorthFacingAnts”,1833,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, “U ‘Adu5Pat’ - 0 - patPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkWithin12dB”,1402,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 4, 1, 4, 0,
"i - - 0 - ant d - - 0 - phiSignal "
“d - - 0 - thetaSignal U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkWithin2PhiSectors”,2215,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 4, 0,
“i - - 0 - ant1 i - - 0 - ant2”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“makeCorrelationGraphs”,2181,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getSummedWaveform”,1778,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__correlatorDictLN_TGraph), -1, 0, 1, 1, 4, 0, “U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“getHilbertMax”,1328,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 0, “U ‘TGraph’ - 0 - beforeHilbert”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“repeatFineCrossCorrelate”,2478,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
“U ‘RawAnitaHeader’ - 0 - hdPtr U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkRFTrigger”,1386,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkGpsTime”,1207,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 2, 1, 4, 0,
“U ‘RawAnitaHeader’ - 0 - hdPtr U ‘Adu5Pat’ - 0 - patPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkCalPulser”,1417,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkSyncSlips”,1446,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkRFCMStatus”,1450,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkTDEvent”,1176,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 2, 1, 4, 0,
“U ‘RawAnitaHeader’ - 0 - hdPtr U ‘Adu5Pat’ - 0 - patPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkWFEvent”,1181,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 2, 1, 4, 0,
“U ‘RawAnitaHeader’ - 0 - hdPtr U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkPayloadBlast”,1726,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkHeaderInformation”,2253,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0,
“U ‘RawAnitaHeader’ - 0 - hdPtr U ‘Adu5Pat’ - 0 - patPtr “
“U ‘CrossCorrelatorGeometry’ - 0 - crossCorrGeom”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkShortWaveform”,1877,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkVarnerEvent”,1646,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkDCOffset”,1260,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkSurfSat”,1222,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkBlastCooldown”,1849,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkPayloadBlastAgain”,2206,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkEventInformation”,2182,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“wasPhiMasked”,1217,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“didPhiTrigger”,1318,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“doesEventPassRotatedCut”,2371,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename(“Int_t”), 0, 0, 1, 4, 0, “”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“checkCorrelationInformation”,2822,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“Class”,502,G__correlatorDict_420_0_54, 85, G__get_linked_tagnum(&G__correlatorDictLN_TClass), -1, 0, 0, 3, 1, 0, “”, (char*)NULL, (void*) (TClass* ()())(&CrossCorrelator::Class), 0);
G__memfunc_setup(“Class_Name”,982,G__correlatorDict_420_0_55, 67, -1, -1, 0, 0, 3, 1, 1, “”, (char)NULL, (void*) (const char* ()())(&CrossCorrelator::Class_Name), 0);
G__memfunc_setup(“Class_Version”,1339,G__correlatorDict_420_0_56, 115, -1, G__defined_typename(“Version_t”), 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (Version_t ()())(&CrossCorrelator::Class_Version), 0);
G__memfunc_setup(“Dictionary”,1046,G__correlatorDict_420_0_57, 121, -1, -1, 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (void ()())(&CrossCorrelator::Dictionary), 0);
G__memfunc_setup(“IsA”,253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__correlatorDictLN_TClass), -1, 0, 0, 1, 1, 8, “”, (char)NULL, (void*) NULL, 1);
G__memfunc_setup(“ShowMembers”,1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
“u ‘TMemberInspector’ - 1 - insp C - - 0 - parent”, (char*)NULL, (void*) NULL, 1);
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);
G__memfunc_setup(“StreamerNVirtual”,1656,G__correlatorDict_420_0_61, 121, -1, -1, 0, 1, 1, 1, 0, “u ‘TBuffer’ - 1 - b”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“DeclFileName”,1145,G__correlatorDict_420_0_62, 67, -1, -1, 0, 0, 3, 1, 1, “”, (char*)NULL, (void*) (const char* ()())(&CrossCorrelator::DeclFileName), 0);
G__memfunc_setup(“ImplFileLine”,1178,G__correlatorDict_420_0_63, 105, -1, -1, 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (int ()())(&CrossCorrelator::ImplFileLine), 0);
G__memfunc_setup(“ImplFileName”,1171,G__correlatorDict_420_0_64, 67, -1, -1, 0, 0, 3, 1, 1, “”, (char)NULL, (void*) (const char* ()())(&CrossCorrelator::ImplFileName), 0);
G__memfunc_setup(“DeclFileLine”,1152,G__correlatorDict_420_0_65, 105, -1, -1, 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (int ()())(&CrossCorrelator::DeclFileLine), 0);
// automatic copy constructor
G__memfunc_setup(“CrossCorrelator”, 1575, G__correlatorDict_420_0_66, (int) (‘i’), G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator), -1, 0, 1, 1, 1, 0, “u ‘CrossCorrelator’ - 11 - -”, (char) NULL, (void*) NULL, 0);
// automatic destructor
G__memfunc_setup(”~CrossCorrelator”, 1701, G__correlatorDict_420_0_67, (int) (‘y’), -1, -1, 0, 0, 1, 1, 0, “”, (char*) NULL, (void*) NULL, 1);
// automatic assignment operator
G__memfunc_setup(“operator=”, 937, G__correlatorDict_420_0_68, (int) (‘u’), G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator), -1, 1, 1, 1, 1, 0, “u ‘CrossCorrelator’ - 11 - -”, (char*) NULL, (void*) NULL, 0);
G__tag_memfunc_reset();
}

static void G__setup_memfuncCorrelatorTools(void) {
/* CorrelatorTools /
G__tag_memfunc_setup(G__get_linked_tagnum(&G__correlatorDictLN_CorrelatorTools));
G__memfunc_setup(“CorrelatorTools”,1582,G__correlatorDict_455_0_1, 105, G__get_linked_tagnum(&G__correlatorDictLN_CorrelatorTools), -1, 0, 0, 1, 1, 0, “”, "/<Constructor - don’t need to implement for the static functions ", (void) NULL, 0);
G__memfunc_setup(“checkTDEvent”,1176,G__correlatorDict_455_0_2, 121, -1, -1, 0, 3, 3, 1, 0,
"U ‘Adu5Pat’ - 0 - patPtr d - ‘Double_t’ 1 - distance "
“d - ‘Double_t’ 1 - timeOfFlight”, (char*)NULL, (void*) (void ()(Adu5Pat, Double_t&, Double_t&))(&CorrelatorTools::checkTDEvent), 0);
G__memfunc_setup(“getEventToTDDistance”,1992,G__correlatorDict_455_0_3, 100, -1, G__defined_typename(“Double_t”), 0, 3, 3, 1, 0,
"d - - 0 - latEvent d - - 0 - lonEvent "
“d - - 0 - altEvent”, (char*)NULL, (void*) (Double_t ()(double, double, double))(&CorrelatorTools::getEventToTDDistance), 0);
G__memfunc_setup(“checkMCMDistance”,1542,G__correlatorDict_455_0_4, 121, -1, -1, 0, 3, 3, 1, 0,
"U ‘Adu5Pat’ - 0 - patPtr d - - 1 - distance "
“d - - 1 - timeOfFlight”, (char)NULL, (void*) (void ()(Adu5Pat, double&, double&))(&CorrelatorTools::checkMCMDistance), 0);
G__memfunc_setup(“getSeperation”,1370,G__correlatorDict_455_0_5, 100, -1, -1, 0, 6, 3, 1, 0,
"d - - 0 - lat1 d - - 0 - lon1 "
"d - - 0 - alt1 d - - 0 - lat2 "
“d - - 0 - lon2 d - - 0 - alt2”, (char*)NULL, (void*) (double ()(double, double, double, double, double, double))(&CorrelatorTools::getSeperation), 0);
G__memfunc_setup(“phiSliceImage”,1300,G__correlatorDict_455_0_6, 85, G__get_linked_tagnum(&G__correlatorDictLN_TGraph), -1, 0, 1, 3, 1, 0, “U ‘CrossCorrelator’ - 0 - crossCorr”, (char)NULL, (void*) (TGraph* ()(CrossCorrelator))(&CorrelatorTools::phiSliceImage), 0);
G__memfunc_setup(“phiSliceFit”,1108,G__correlatorDict_455_0_7, 85, G__get_linked_tagnum(&G__correlatorDictLN_TGraph), -1, 0, 2, 3, 1, 0,
“U ‘CrossCorrelator’ - 0 - crossCorr U ‘TF2’ - 0 - correlationFit”, (char*)NULL, (void*) (TGraph* ()(CrossCorrelator, TF2*))(&CorrelatorTools::phiSliceFit), 0);
G__memfunc_setup(“thetaSliceImage”,1513,G__correlatorDict_455_0_8, 85, G__get_linked_tagnum(&G__correlatorDictLN_TGraph), -1, 0, 1, 3, 1, 0, “U ‘CrossCorrelator’ - 0 - crossCorr”, (char*)NULL, (void*) (TGraph* ()(CrossCorrelator))(&CorrelatorTools::thetaSliceImage), 0);
G__memfunc_setup(“thetaSliceFit”,1321,G__correlatorDict_455_0_9, 85, G__get_linked_tagnum(&G__correlatorDictLN_TGraph), -1, 0, 2, 3, 1, 0,
“U ‘CrossCorrelator’ - 0 - crossCorr U ‘TF2’ - 0 - correlationFit”, (char*)NULL, (void*) (TGraph* ()(CrossCorrelator, TF2*))(&CorrelatorTools::thetaSliceFit), 0);
G__memfunc_setup(“gaus2D”,550,G__correlatorDict_455_0_10, 100, -1, G__defined_typename(“Double_t”), 0, 2, 3, 1, 0,
“D - ‘Double_t’ 0 - x D - ‘Double_t’ 0 - par”, (char*)NULL, (void*) (Double_t ()(Double_t, Double_t*))(&CorrelatorTools::gaus2D), 0);
G__memfunc_setup(“checkLogLikelihood”,1828,G__correlatorDict_455_0_11, 100, -1, G__defined_typename(“Double_t”), 0, 12, 3, 1, 0,
"d - - 0 - thetaWave1at1 d - - 0 - phiWave1at1 "
"d - - 0 - thetaWave2at1 d - - 0 - phiWave2at1 "
"d - - 0 - errThetaAt1 d - - 0 - errPhiAt1 "
"d - - 0 - thetaWave1at2 d - - 0 - phiWave1at2 "
"d - - 0 - thetaWave2at2 d - - 0 - phiWave2at2 "
“d - - 0 - errThetaAt2 d - - 0 - errPhiAt2”, (char*)NULL, (void*) (Double_t ()(double, double, double, double, double, double, double, double, double, double, double, double))(&CorrelatorTools::checkLogLikelihood), 0);
G__memfunc_setup(“checkLogLikelihood”,1828,G__correlatorDict_455_0_12, 100, -1, G__defined_typename(“Double_t”), 0, 6, 3, 1, 0,
"d - - 0 - thetaWave1at1 d - - 0 - phiWave1at1 "
"d - - 0 - thetaWave2at1 d - - 0 - phiWave2at1 "
“d - - 0 - errThetaAt1 d - - 0 - errPhiAt1”, (char)NULL, (void*) (Double_t ()(double, double, double, double, double, double))(&CorrelatorTools::checkLogLikelihood), 0);
G__memfunc_setup(“checkLogLikelihood”,1828,G__correlatorDict_455_0_13, 100, -1, G__defined_typename(“Double_t”), 0, 10, 3, 1, 0,
"d - - 0 - thetaWave1at1 d - - 0 - phiWave1at1 "
"d - - 0 - thetaWave2at1 d - - 0 - phiWave2at1 "
"d - - 0 - thetaWave1at2 d - - 0 - phiWave1at2 "
"d - - 0 - thetaWave2at2 d - - 0 - phiWave2at2 "
“d - - 0 - rmsTheta d - - 0 - rmsPhi”, (char)NULL, (void*) (Double_t ()(double, double, double, double, double, double, double, double, double, double))(&CorrelatorTools::checkLogLikelihood), 0);
G__memfunc_setup(“checkSyncSlips”,1446,G__correlatorDict_455_0_14, 105, -1, G__defined_typename(“Int_t”), 0, 1, 3, 1, 0, “U ‘RawAnitaHeader’ - 0 - hdPtr”, (char)NULL, (void*) (Int_t ()(RawAnitaHeader))(&CorrelatorTools::checkSyncSlips), 0);
G__memfunc_setup(“getBaseColour”,1327,G__correlatorDict_455_0_15, 115, -1, G__defined_typename(“Color_t”), 0, 1, 3, 1, 0, “i - - 0 - base”, (char*)NULL, (void*) (Color_t ()(int))(&CorrelatorTools::getBaseColour), 0);
G__memfunc_setup(“getMapColors”,1232,G__correlatorDict_455_0_16, 121, -1, -1, 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (void ()())(&CorrelatorTools::getMapColors), 0);
G__memfunc_setup(“getMapColorExec”,1506,G__correlatorDict_455_0_17, 85, G__get_linked_tagnum(&G__correlatorDictLN_TExec), -1, 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (TExec* ()())(&CorrelatorTools::getMapColorExec), 0);
G__memfunc_setup(“getPrettyColorExec”,1868,G__correlatorDict_455_0_18, 85, G__get_linked_tagnum(&G__correlatorDictLN_TExec), -1, 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (TExec* ()())(&CorrelatorTools::getPrettyColorExec), 0);
G__memfunc_setup(“openBaseList”,1225,G__correlatorDict_455_0_19, 121, -1, -1, 0, 5, 3, 1, 0,
"u ‘vector<double,allocator >’ ‘vector’ 1 - baseLon u ‘vector<double,allocator >’ ‘vector’ 1 - baseLat "
"u ‘vector<double,allocator >’ ‘vector’ 1 - baseAlt u ‘vector<int,allocator >’ ‘vector’ 1 - baseClusters "
“U ‘RampdemReader’ - 0 - fRampdemReader”, (char)NULL, (void*) (void ()(vector&, vector&, vector&, vector&, RampdemReader))(&CorrelatorTools::openBaseList), 0);
G__memfunc_setup(“getBaseLatLonFromString”,2320,G__correlatorDict_455_0_20, 105, -1, -1, 0, 3, 3, 1, 0,
“u ‘basic_ifstream<char,char_traits >’ ‘ifstream’ 1 - fin d - - 1 - lat “
“d - - 1 - lon”, (char*)NULL, (void*) (int ()(ifstream&, double&, double&))(&CorrelatorTools::getBaseLatLonFromString), 0);
G__memfunc_setup(“getAntFromMeasPhi”,1694,G__correlatorDict_455_0_21, 105, -1, -1, 0, 2, 3, 1, 0,
“d - - 0 - measPhi u ‘AnitaRing::EAnitaRing’ ‘AnitaRing::AnitaRing_t’ 0 - ring”, (char)NULL, (void*) (int ()(double, AnitaRing::AnitaRing_t))(&CorrelatorTools::getAntFromMeasPhi), 0);
G__memfunc_setup(“getPhiSector”,1233,G__correlatorDict_455_0_22, 105, -1, -1, 0, 1, 3, 1, 0, “d - - 0 - measPhi”, (char)NULL, (void*) (int ()(double))(&CorrelatorTools::getPhiSector), 0);
G__memfunc_setup(“outputAllCheckInfo”,1844,G__correlatorDict_455_0_23, 121, -1, -1, 0, 1, 3, 1, 0, “U ‘CrossCorrelator’ - 0 - crossCorr”, (char)NULL, (void*) (void ()(CrossCorrelator))(&CorrelatorTools::outputAllCheckInfo), 0);
G__memfunc_setup(“outputHeaderCheckInfo”,2148,G__correlatorDict_455_0_24, 121, -1, -1, 0, 1, 3, 1, 0, “U ‘CrossCorrelator’ - 0 - crossCorr”, (char*)NULL, (void*) (void ()(CrossCorrelator))(&CorrelatorTools::outputHeaderCheckInfo), 0);
G__memfunc_setup(“outputEventCheckInfo”,2077,G__correlatorDict_455_0_25, 121, -1, -1, 0, 1, 3, 1, 0, “U ‘CrossCorrelator’ - 0 - crossCorr”, (char*)NULL, (void*) (void ()(CrossCorrelator))(&CorrelatorTools::outputEventCheckInfo), 0);
G__memfunc_setup(“outputCorrelationCheckInfo”,2717,G__correlatorDict_455_0_26, 121, -1, -1, 0, 1, 3, 1, 0, “U ‘CrossCorrelator’ - 0 - crossCorr”, (char*)NULL, (void*) (void ()(CrossCorrelator))(&CorrelatorTools::outputCorrelationCheckInfo), 0);
// automatic copy constructor
G__memfunc_setup(“CorrelatorTools”, 1582, G__correlatorDict_455_0_27, (int) (‘i’), G__get_linked_tagnum(&G__correlatorDictLN_CorrelatorTools), -1, 0, 1, 1, 1, 0, “u ‘CorrelatorTools’ - 11 - -”, (char*) NULL, (void*) NULL, 0);
// automatic destructor
G__memfunc_setup(”~CorrelatorTools”, 1708, G__correlatorDict_455_0_28, (int) (‘y’), -1, -1, 0, 0, 1, 1, 0, “”, (char*) NULL, (void*) NULL, 0);
// automatic assignment operator
G__memfunc_setup(“operator=”, 937, G__correlatorDict_455_0_29, (int) (‘u’), G__get_linked_tagnum(&G__correlatorDictLN_CorrelatorTools), -1, 1, 1, 1, 1, 0, “u ‘CorrelatorTools’ - 11 - -”, (char*) NULL, (void*) NULL, 0);
G__tag_memfunc_reset();
}

static void G__setup_memfuncEventCluster(void) {
/* EventCluster /
G__tag_memfunc_setup(G__get_linked_tagnum(&G__correlatorDictLN_EventCluster));
G__memfunc_setup(“EventCluster”,1252,G__correlatorDict_490_0_1, 105, G__get_linked_tagnum(&G__correlatorDictLN_EventCluster), -1, 0, 0, 1, 1, 0, “”, “default constructor”, (void) NULL, 0);
G__memfunc_setup(“EventCluster”,1252,G__correlatorDict_490_0_2, 105, G__get_linked_tagnum(&G__correlatorDictLN_EventCluster), -1, 0, 5, 1, 1, 0,
"h - ‘UInt_t’ 0 - run h - ‘UInt_t’ 0 - eventNumber "
"d - ‘Double_t’ 0 - lat d - ‘Double_t’ 0 - lon "
“d - ‘Double_t’ 0 - alt”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“addBaseToClusterList”,2021,G__correlatorDict_490_0_3, 121, -1, -1, 0, 6, 1, 1, 0,
"h - ‘UInt_t’ 0 - baseNumber d - - 0 - lat "
"d - - 0 - lon d - - 0 - alt "
“d - - 0 - logLike d - - 0 - distance”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“addEventToClusterList”,2156,G__correlatorDict_490_0_4, 121, -1, -1, 0, 3, 1, 1, 0,
"i - - 0 - eventNumber d - - 0 - logLike "
“d - - 0 - distance”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“addFlightToClusterList”,2248,G__correlatorDict_490_0_5, 121, -1, -1, 0, 6, 1, 1, 0,
"d - - 0 - lat d - - 0 - lon "
“d - - 0 - alt h - ‘UInt_t’ 0 - flightTime “
“d - - 0 - logLike d - - 0 - distance”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“Class”,502,G__correlatorDict_490_0_6, 85, G__get_linked_tagnum(&G__correlatorDictLN_TClass), -1, 0, 0, 3, 1, 0, “”, (char*)NULL, (void*) (TClass* ()())(&EventCluster::Class), 0);
G__memfunc_setup(“Class_Name”,982,G__correlatorDict_490_0_7, 67, -1, -1, 0, 0, 3, 1, 1, “”, (char)NULL, (void*) (const char* ()())(&EventCluster::Class_Name), 0);
G__memfunc_setup(“Class_Version”,1339,G__correlatorDict_490_0_8, 115, -1, G__defined_typename(“Version_t”), 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (Version_t ()())(&EventCluster::Class_Version), 0);
G__memfunc_setup(“Dictionary”,1046,G__correlatorDict_490_0_9, 121, -1, -1, 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (void ()())(&EventCluster::Dictionary), 0);
G__memfunc_setup(“IsA”,253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__correlatorDictLN_TClass), -1, 0, 0, 1, 1, 8, “”, (char)NULL, (void*) NULL, 1);
G__memfunc_setup(“ShowMembers”,1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
“u ‘TMemberInspector’ - 1 - insp C - - 0 - parent”, (char*)NULL, (void*) NULL, 1);
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);
G__memfunc_setup(“StreamerNVirtual”,1656,G__correlatorDict_490_0_13, 121, -1, -1, 0, 1, 1, 1, 0, “u ‘TBuffer’ - 1 - b”, (char*)NULL, (void*) NULL, 0);
G__memfunc_setup(“DeclFileName”,1145,G__correlatorDict_490_0_14, 67, -1, -1, 0, 0, 3, 1, 1, “”, (char*)NULL, (void*) (const char* ()())(&EventCluster::DeclFileName), 0);
G__memfunc_setup(“ImplFileLine”,1178,G__correlatorDict_490_0_15, 105, -1, -1, 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (int ()())(&EventCluster::ImplFileLine), 0);
G__memfunc_setup(“ImplFileName”,1171,G__correlatorDict_490_0_16, 67, -1, -1, 0, 0, 3, 1, 1, “”, (char)NULL, (void*) (const char* ()())(&EventCluster::ImplFileName), 0);
G__memfunc_setup(“DeclFileLine”,1152,G__correlatorDict_490_0_17, 105, -1, -1, 0, 0, 3, 1, 0, “”, (char)NULL, (void*) (int ()())(&EventCluster::DeclFileLine), 0);
// automatic copy constructor
G__memfunc_setup(“EventCluster”, 1252, G__correlatorDict_490_0_18, (int) (‘i’), G__get_linked_tagnum(&G__correlatorDictLN_EventCluster), -1, 0, 1, 1, 1, 0, “u ‘EventCluster’ - 11 - -”, (char) NULL, (void*) NULL, 0);
// automatic destructor
G__memfunc_setup(”~EventCluster”, 1378, G__correlatorDict_490_0_19, (int) (‘y’), -1, -1, 0, 0, 1, 1, 0, “”, (char*) NULL, (void*) NULL, 1);
// automatic assignment operator
G__memfunc_setup(“operator=”, 937, G__correlatorDict_490_0_20, (int) (‘u’), G__get_linked_tagnum(&G__correlatorDictLN_EventCluster), -1, 1, 1, 1, 1, 0, “u ‘EventCluster’ - 11 - -”, (char*) NULL, (void*) NULL, 0);
G__tag_memfunc_reset();
}
[/code][/code]

11

actually, this is the last bit…


static void G__setup_memfuncFlightAndTraverse(void) {
   /* FlightAndTraverse */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__correlatorDictLN_FlightAndTraverse));
   G__memfunc_setup("FlightAndTraverse",1725,G__correlatorDict_507_0_1, 105, G__get_linked_tagnum(&G__correlatorDictLN_FlightAndTraverse), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("openAgapFiles",1310,G__correlatorDict_507_0_2, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("openBasFiles",1211,G__correlatorDict_507_0_3, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("openTexasFiles",1450,G__correlatorDict_507_0_4, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("openCreamFiles",1421,G__correlatorDict_507_0_5, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("openAwiFiles",1222,G__correlatorDict_507_0_6, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("openNorwayFiles",1573,G__correlatorDict_507_0_7, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("openShackletonFiles",1969,G__correlatorDict_507_0_8, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEntriesWithTime",1861,G__correlatorDict_507_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - time", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("FlightAndTraverse", 1725, G__correlatorDict_507_0_10, (int) ('i'), G__get_linked_tagnum(&G__correlatorDictLN_FlightAndTraverse), -1, 0, 1, 1, 1, 0, "u 'FlightAndTraverse' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FlightAndTraverse", 1851, G__correlatorDict_507_0_11, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__correlatorDict_507_0_12, (int) ('u'), G__get_linked_tagnum(&G__correlatorDictLN_FlightAndTraverse), -1, 1, 1, 1, 1, 0, "u 'FlightAndTraverse' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfunccorrelatorDict() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalcorrelatorDict() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funccorrelatorDict() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__correlatorDictLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ifstream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_string = { "string" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_AnitaRing = { "AnitaRing" , 110 , -1 };
G__linked_taginfo G__correlatorDictLN_AnitaRingcLcLEAnitaRing = { "AnitaRing::EAnitaRing" , 101 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TGraph = { "TGraph" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TRandom3 = { "TRandom3" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__correlatorDictLN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_CrossCorrelatorGeometry = { "CrossCorrelatorGeometry" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_RawAnitaHeader = { "RawAnitaHeader" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_CalibratedAnitaEvent = { "CalibratedAnitaEvent" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_FFTWComplex = { "FFTWComplex" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TH2D = { "TH2D" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TF2 = { "TF2" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_Adu5Pat = { "Adu5Pat" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_CrossCorrelator = { "CrossCorrelator" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_TExec = { "TExec" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_RampdemReader = { "RampdemReader" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_vectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgR = { "vector<vector<short,allocator<short> >,allocator<vector<short,allocator<short> > > >" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_reverse_iteratorlEvectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<short,allocator<short> >,allocator<vector<short,allocator<short> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_CorrelatorTools = { "CorrelatorTools" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_EventCluster = { "EventCluster" , 99 , -1 };
G__linked_taginfo G__correlatorDictLN_FlightAndTraverse = { "FlightAndTraverse" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtablecorrelatorDict() {
  G__correlatorDictLN_TClass.tagnum = -1 ;
  G__correlatorDictLN_TBuffer.tagnum = -1 ;
  G__correlatorDictLN_TMemberInspector.tagnum = -1 ;
  G__correlatorDictLN_TObject.tagnum = -1 ;
  G__correlatorDictLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__correlatorDictLN_string.tagnum = -1 ;
  G__correlatorDictLN_AnitaRing.tagnum = -1 ;
  G__correlatorDictLN_AnitaRingcLcLEAnitaRing.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__correlatorDictLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__correlatorDictLN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__correlatorDictLN_TGraph.tagnum = -1 ;
  G__correlatorDictLN_TRandom3.tagnum = -1 ;
  G__correlatorDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__correlatorDictLN_TTree.tagnum = -1 ;
  G__correlatorDictLN_TFile.tagnum = -1 ;
  G__correlatorDictLN_CrossCorrelatorGeometry.tagnum = -1 ;
  G__correlatorDictLN_RawAnitaHeader.tagnum = -1 ;
  G__correlatorDictLN_CalibratedAnitaEvent.tagnum = -1 ;
  G__correlatorDictLN_FFTWComplex.tagnum = -1 ;
  G__correlatorDictLN_TH2D.tagnum = -1 ;
  G__correlatorDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__correlatorDictLN_TF2.tagnum = -1 ;
  G__correlatorDictLN_Adu5Pat.tagnum = -1 ;
  G__correlatorDictLN_CrossCorrelator.tagnum = -1 ;
  G__correlatorDictLN_TExec.tagnum = -1 ;
  G__correlatorDictLN_RampdemReader.tagnum = -1 ;
  G__correlatorDictLN_vectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgR.tagnum = -1 ;
  G__correlatorDictLN_reverse_iteratorlEvectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__correlatorDictLN_CorrelatorTools.tagnum = -1 ;
  G__correlatorDictLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__correlatorDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__correlatorDictLN_EventCluster.tagnum = -1 ;
  G__correlatorDictLN_FlightAndTraverse.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtablecorrelatorDict() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TClass);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TObject);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_string);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_AnitaRing);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_AnitaRingcLcLEAnitaRing);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTColumn_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTFlat_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTSub_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTSparseRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTColumnlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTFlatlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTSparseRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TMatrixTSparseDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TGraph);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TRandom3);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TTree);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TFile);
   G__tagtable_setup(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelatorGeometry),sizeof(CrossCorrelatorGeometry),-1,324864,(char*)NULL,G__setup_memvarCrossCorrelatorGeometry,G__setup_memfuncCrossCorrelatorGeometry);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_RawAnitaHeader);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_CalibratedAnitaEvent);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_FFTWComplex);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TH2D);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TF2);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_Adu5Pat);
   G__tagtable_setup(G__get_linked_tagnum(&G__correlatorDictLN_CrossCorrelator),sizeof(CrossCorrelator),-1,324864,(char*)NULL,G__setup_memvarCrossCorrelator,G__setup_memfuncCrossCorrelator);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_TExec);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_RampdemReader);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_vectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_reverse_iteratorlEvectorlEvectorlEshortcOallocatorlEshortgRsPgRcOallocatorlEvectorlEshortcOallocatorlEshortgRsPgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__correlatorDictLN_CorrelatorTools),sizeof(CorrelatorTools),-1,263424,(char*)NULL,G__setup_memvarCorrelatorTools,G__setup_memfuncCorrelatorTools);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__correlatorDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__correlatorDictLN_EventCluster),sizeof(EventCluster),-1,324864,(char*)NULL,G__setup_memvarEventCluster,G__setup_memfuncEventCluster);
   G__tagtable_setup(G__get_linked_tagnum(&G__correlatorDictLN_FlightAndTraverse),sizeof(FlightAndTraverse),-1,263424,(char*)NULL,G__setup_memvarFlightAndTraverse,G__setup_memfuncFlightAndTraverse);
}
extern "C" void G__cpp_setupcorrelatorDict(void) {
  G__check_setup_version(30051515,"G__cpp_setupcorrelatorDict()");
  G__set_cpp_environmentcorrelatorDict();
  G__cpp_setup_tagtablecorrelatorDict();

  G__cpp_setup_inheritancecorrelatorDict();

  G__cpp_setup_typetablecorrelatorDict();

  G__cpp_setup_memvarcorrelatorDict();

  G__cpp_setup_memfunccorrelatorDict();
  G__cpp_setup_globalcorrelatorDict();
  G__cpp_setup_funccorrelatorDict();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfunccorrelatorDict();
  return;
}
class G__cpp_setup_initcorrelatorDict {
  public:
    G__cpp_setup_initcorrelatorDict() { G__add_setup_func("correlatorDict",(G__incsetup)(&G__cpp_setupcorrelatorDict)); G__call_setup_funcs(); }
   ~G__cpp_setup_initcorrelatorDict() { G__remove_setup_func("correlatorDict"); }
};
G__cpp_setup_initcorrelatorDict G__cpp_setup_initializercorrelatorDict;
12

Hi,

From your description it looks like it should be working :frowning:. Can you provide us with a small example reproducing the problem? Did you try to generate the library with ACLiC?

Cheers,
Philippe

13

Hi,

using your files from your first posting I cannot reproduce your issue:

rootcint -f ECdict.cxx -c EventCluster.h LinkDef.h
g++ -shared -fPIC *.cxx -o libEC.so `root-config --cflags`
root -l -b
root [0] gSystem->Load("libEC.so");
root [1] EventCluster *theCluster = new EventCluster();
root [2] TTree *tree=new TTree("T","tree")
root [3] tree->Branch("cluster","EventCluster",&theCluster);
root [4] .q

Cheers, Axel.

14

this is kind of odd. the EventCluster class was a member of a library that had other classes in with it. When running from the command line in root I could create branches using it, when running compiled executables this was not the case. I’ve moved the class so it now is the sole member of another library and now it works fine from both the command line and compiled programs…