/*
 * hddm_s.hpp - DO NOT EDIT THIS FILE
 *
 * This file was generated automatically by hddm-cpp from the file
 * exam2.xml

 * This header file defines the c++ classes that hold the data
 * described in the data model (from exam2.xml). 
 *
 * The hddm data model tool set was written by
 * Richard Jones, University of Connecticut.
 *
 * For more information see the following web site
 *
 * http://zeus.phys.uconn.edu/halld/datamodel/doc
 *
 */

#ifndef SAW_s_HDDM
#define SAW_s_HDDM

#include <list>
#include <deque>
#include <vector>
#include <string>
#include <sstream>
#include <stdexcept>
#include <streambuf>
#include <xstream/z.h>
#include <xstream/bz.h>
#include <xstream/xdr.h>
#include <particleType.h>

namespace hddm_s {

const int k_bits_compression = 0xf0;
const int k_no_compression = 0x00;
const int k_z_compression = 0x10;
const int k_bz2_compression = 0x20;
const int k_default_status = 0x0;

class HDDM;
class istream;
class ostream;

class streamable {
 public:
   virtual ~streamable() {}
   virtual void streamer(istream &istr) {}
   virtual void streamer(ostream &ostr) {}
};

class ostream {
 public:
   ostream(std::ostream &src);
   ~ostream();
   ostream &operator<<(HDDM &record);
   ostream &operator<<(streamable &object);
   int getCompression() const;
   void setCompression(int flags);
   void clear_streambufs();
   xstream::xdr::ostream *m_xstr;
 private:
   void configure_streambufs();
   std::ostream &m_ostr;
   std::ostringstream m_sstr;
   std::streambuf *m_xcmp;
   std::streambuf *m_xraw;
   char *m_event_buffer;
   int m_event_buffer_size;
   int m_status_bits;
};

class codon {
 public:
   codon(): m_order(0) {}
   int m_order;
   std::string m_tagname;
   std::vector<codon> m_sequence;
   std::deque<streamable*> m_target;
};

typedef std::vector<codon> chromosome;

class istream {
 public:
   istream(std::istream &src);
   ~istream();
   istream &operator>>(HDDM &record);
   istream &operator>>(streamable &object);
   void sequencer(streamable &object);
   void skip(int count);
   int getCompression() const;
   void configure_streambufs();
   void clear_streambufs();
   xstream::xdr::istream *m_xstr;
   int m_sequencing;
 private:
   codon m_genome;
   codon *m_codon;
   std::string m_documentString;
   chromosome synthesize(const std::string &src, int p_src,
                         const std::string &ref, int p_ref);
   int getTag(const std::string &src, int p_src, std::string &tag, int &level);
   int getEndTag(const std::string &src, int p_src, const std::string &tag);
   void collide(const std::string &itag, const std::string &rtag);
   std::istream &m_istr;
   std::istringstream m_sstr;
   std::streambuf *m_xcmp;
   std::streambuf *m_xraw;
   int m_events_to_skip;
   char *m_event_buffer;
   int m_event_buffer_size;
   int m_next_event_size;
   int m_status_bits;
};

class HDDM_Element: public streamable {
 public:
   ~HDDM_Element() {}
   virtual const void *getAttribute(const std::string &name) const {
      return 0;
   }
 protected:
   HDDM_Element() : m_parent(0), m_host(0) {}
   HDDM_Element(HDDM_Element *parent)
    : m_parent(parent),
      m_host(parent->m_host)
    {}
   HDDM_Element(HDDM_Element &src)
    : m_parent(src.m_parent),
      m_host(src.m_host)
   {}
   HDDM_Element *m_parent;
   HDDM *m_host;
};

template <class T>
class HDDM_ElementList: public streamable {
 public:
   HDDM_ElementList(typename std::list<T*> *plist,
                    typename std::list<T*>::iterator begin,
                    typename std::list<T*>::iterator end,
                    HDDM_Element *parent=0)
    : m_host_plist(plist),
      m_first_iter(begin),
      m_last_iter(end),
      m_parent(parent)
   {
      for (m_size = 0; begin != end; ++m_size, ++begin) {}
      if (m_size) {
         --m_last_iter;
      }
   }

   HDDM_ElementList(const HDDM_ElementList<T> &src)
    : m_host_plist(src.m_host_plist),
      m_first_iter(src.m_first_iter),
      m_last_iter(src.m_last_iter),
      m_parent(src.m_parent),
      m_size(src.m_size)
   {}

   bool empty() const { return (m_size == 0); }
   int size() const { return m_size; }
   T &front() const { return *m_first_iter; }
   T &back() const { return *m_last_iter; }
   T &operator()() { return *m_first_iter; }
   T &operator()(int index) {
      if (index == 0) {
         return *m_first_iter;
      }
      else if (index == -1) {
         return *m_last_iter;
      }
      else if (index > 0) {
         return *(m_first_iter + index);
      }
      else {
         return *(m_last_iter + (++index));
      }
   }

   class iterator: public std::list<T*>::iterator {
    public:
      iterator() {}
      iterator(typename std::list<T*>::iterator src)
       : std::list<T*>::iterator(src) {}

      T *operator->() const { 
         return *(typename std::list<T*>::iterator)(*this);
      }

      T &operator*() const {
         return **(typename std::list<T*>::iterator)(*this);
      }

      iterator operator+=(int offset) {
         if (offset > 0) {
            for (int i=0; i<offset; ++i, ++(*this)) {}
         }
         else if (offset < 0) {
            for (int i=0; i>offset; --i, --(*this)) {}
         }
         return *this;
      }

      iterator operator-=(int offset) {
         if (offset > 0) {
            for (int i=0; i<offset; ++i, --(*this)) {}
         }
         else if (offset < 0) {
            for (int i=0; i>offset; --i, ++(*this)) {}
         }
         return *this;
      }

      iterator operator+(int offset) const {
         iterator iter(*this);
         return iter += offset;
      }

      iterator operator-(int offset) const {
         iterator iter(*this);
         return iter -= offset;
      }

      int operator-(iterator iter) const {
         if (*this == iter) {
            return 0;
         }
         iterator iter2(iter);
         for (int n=1; n < m_size; ++n) {
            if (++iter == *this) {
               return n;
            }
            else if (--iter2 == *this) {
               return -n;
            }
         }
         return m_size;
      }
   };

   class const_iterator: public std::list<T*>::const_iterator {
    public:
      const_iterator() {}
      const_iterator(const typename std::list<T*>::const_iterator src)
       : std::list<T*>::const_iterator(src) {}

      const_iterator(const typename std::list<T*>::iterator src)
       : std::list<T*>::const_iterator(src) {}

      const T *operator->() const { 
         return *(typename std::list<T*>::const_iterator)(*this);
      }

      const T &operator*() const { 
         return **(typename std::list<T*>::const_iterator)(*this);
      }

      const const_iterator operator+=(int offset) {
         if (offset > 0) {
            for (int i=0; i<offset; ++i, ++(*this)) {}
         }
         else if (offset < 0) {
            for (int i=0; i>offset; --i, --(*this)) {}
         }
         return *this;
      }

      const const_iterator operator-=(int offset) {
         if (offset > 0) {
            for (int i=0; i<offset; ++i, --(*this)) {}
         }
         else if (offset > 0) {
            for (int i=0; i>offset; --i, ++(*this)) {}
         }
         return *this;
      }

      const const_iterator operator+(int offset) const {
         const_iterator iter(*this);
         return iter += offset;
      }

      const const_iterator operator-(int offset) const {
         const_iterator iter(*this);
         return iter -= offset;
      }

      int operator-(const_iterator iter) const {
         if (*this == iter) {
            return 0;
         }
         const_iterator iter2(iter);
         for (int n=1; n < m_size; ++n) {
            if (++iter == *this) {
               return n;
            }
            else if (--iter2 == *this) {
               return -n;
            }
         }
         return m_size;
      }
   };

   iterator begin() const { return m_first_iter; }
   iterator end() const { return (m_size)? m_last_iter + 1 : m_last_iter; }
   void clear() { del(); }

   HDDM_ElementList add(int count=1, int start=-1) {
      if (m_parent == 0) {
         throw std::runtime_error("HDDM_ElementList error - "
                                  "attempt to add to immutable list");
      }
      iterator it = insert(start, count);
      typename std::list<T*>::iterator iter(it);
      for (int n=0; n<count; ++n, ++iter) {
         *iter = new T(m_parent);
      }
      return HDDM_ElementList(m_host_plist, it, it+count, m_parent);
   }

   void del(int count=-1, int start=0) {
      if (m_parent == 0) {
         throw std::runtime_error("HDDM_ElementList error - "
                                  "attempt to delete from immutable list");
      }
      iterator iter_begin(begin());
      iterator iter_end(end());
      if (start < 0) {
         if (count >= 0) {
            iter_begin = iter_end - count;
         }
      }
      else {
         iter_begin += start;
         if (count >= 0) {
            iter_end = iter_begin + start;
         }
      }
      typename std::list<T*>::iterator iter;
      for (iter = iter_begin; iter != iter_end; ++iter) {
         delete *iter;
      }
      erase(start, count);
   }

   void streamer(istream &istr) {
      clear();
      int size;
      *istr.m_xstr >> size;
      if (size) {
         iterator iter = add(size).begin();
         for (int n=0; n < size; ++n, ++iter) {
            istr.sequencer(*iter);
         }
      }
      istr.m_sequencing = 0;
   }

   void streamer(ostream &ostr) {
      if (m_size) {
         *ostr.m_xstr << m_size;
         for (iterator iter = begin(); iter != end(); ++iter) {
            iter->streamer(ostr);
         }
      }
   }

 private:
   HDDM_ElementList() {}

   iterator insert(int start, int count) {
      if (m_size == 0) {
         if (count > 0) {
            if (m_first_iter == m_host_plist->begin()) {
               m_host_plist->insert(m_first_iter,count,(T*)0);
               m_first_iter = m_host_plist->begin();
            }
            else {
               m_host_plist->insert(m_first_iter--,count,(T*)0);
               ++m_first_iter;
            }
            --m_last_iter;
            m_size = count;
         }
         return m_first_iter;
      }
      else if (start == 0) {
         if (count > 0) {
            if (m_first_iter == m_host_plist->begin()) {
               m_host_plist->insert(m_first_iter,count,(T*)0);
               m_first_iter = m_host_plist->begin();
            }
            else {
               m_host_plist->insert(m_first_iter--,count,(T*)0);
               ++m_first_iter;
            }
            m_size += count;
         }
         return m_first_iter;
      }
      else if (start == -1) {
         if (count > 0) {
            iterator pos(m_last_iter);
            m_host_plist->insert(++m_last_iter,count,(T*)0);
            --m_last_iter;
            m_size += count;
            return ++pos;
         }
         return m_last_iter;
      }
      else if (start > 0) {
         if (count > 0) {
            iterator pos(m_first_iter);
            iterator pos2(pos += start-1);
            m_host_plist->insert(++pos,count,(T*)0);
            if (m_last_iter == pos2) {
               m_last_iter = --pos;
            }
            m_size += count;
            return ++pos2;
         }
         return m_first_iter + start;
      }
      else {
         if (count > 0) {
            iterator pos(m_last_iter);
            iterator pos2(pos += start);
            m_host_plist->insert(++pos,count,(T*)0);
            m_size += count;
            return ++pos2;
         }
         return m_last_iter + (start+1);
      }
   }

   iterator erase(int start, int count) {
      if (m_size == 0) {
         return m_first_iter+start;
      }
      else if ((count >= m_size || count == -1) &&
               (start == 0 || start <= -m_size)) {
         m_host_plist->erase(m_first_iter,++m_last_iter);
         m_first_iter = m_last_iter;
         m_size = 0;
         return m_first_iter;
      }
      else if (start > 0 && start <= m_size) {
         ++m_last_iter;
         count = (count < 0)? m_size-start : count;
         iterator pos(m_first_iter + start);
         iterator pos2(pos + count);
         m_host_plist->erase(pos,pos2);
         m_size -= count;
         --m_last_iter;
         return pos2;
      }
      else if (start < 0 && start >= -m_size) {
         ++m_last_iter;
         count = (count < 0)? -start : count;
         iterator pos(m_last_iter + (start+1));
         iterator pos2(pos + count);
         m_host_plist->erase(pos,pos2);
         if (m_size -= count) {
            --m_last_iter;
         }
         else {
            m_first_iter = m_last_iter;
         }
         return pos2;
      }
      return m_last_iter+1;
   }

 protected:
   std::list<T*> *m_host_plist;
   iterator m_first_iter;
   iterator m_last_iter;
   HDDM_Element *m_parent;
   int m_size;
};

template <class T>
class HDDM_ElementLink: public HDDM_ElementList<T> {
 public:
   HDDM_ElementLink(typename std::list<T*> *plist,
                    typename std::list<T*>::iterator begin,
                    typename std::list<T*>::iterator end,
                    HDDM_Element *parent)
    : HDDM_ElementList<T>(plist,begin,end,parent)
   {}
   HDDM_ElementLink(const HDDM_ElementList<T> &src)
    : HDDM_ElementList<T>(src)
   {}

   void streamer(istream &istr) {
      HDDM_ElementList<T>::clear();
      HDDM_ElementList<T>::add().begin()->streamer(istr);
   }

   void streamer(ostream &ostr) {
      if (HDDM_ElementList<T>::m_size) {
         HDDM_ElementList<T>::begin()->streamer(ostr);
      }
   }

 protected:
   HDDM_ElementLink() {}
};

class Geometry: public HDDM_Element {
 public:
   ~Geometry();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getMaxOccurs() const;
   std::string getMd5reconstruction() const;
   void setMd5reconstruction(const std::string &md5reconstruction);
   std::string getMd5simulation() const;
   void setMd5simulation(const std::string &md5simulation);
   std::string getMd5smear() const;
   void setMd5smear(const std::string &md5smear);
   int getMinOccurs() const;
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Geometry>;
   friend class HDDM_ElementLink<Geometry>;
 private:
   Geometry(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   std::string m_md5reconstruction;
   std::string m_md5simulation;
   std::string m_md5smear;
};

typedef HDDM_ElementList<Geometry> GeometryList;
typedef HDDM_ElementLink<Geometry> GeometryLink;

class Momentum: public HDDM_Element {
 public:
   ~Momentum();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   float getFOM() const;
   int getNdof() const;
   int getCandidateid() const;
   float getChisq() const;
   int getId() const;
   int getTrackid() const;
   int getType() const;
   float getWeight() const;
   int getDecayVertex() const;
   int getMech() const;
   int getParentid() const;
   int getPdgtype() const;
   float getE() const;
   void setE(float E);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Momentum>;
   friend class HDDM_ElementLink<Momentum>;
 private:
   Momentum(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_px;
   float m_py;
   float m_pz;
};

typedef HDDM_ElementList<Momentum> MomentumList;
typedef HDDM_ElementLink<Momentum> MomentumLink;

class Properties: public HDDM_Element {
 public:
   ~Properties();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   float getFOM() const;
   int getNdof() const;
   int getCandidateid() const;
   float getChisq() const;
   int getId() const;
   int getTrackid() const;
   int getType() const;
   float getWeight() const;
   int getDecayVertex() const;
   int getMech() const;
   int getParentid() const;
   int getPdgtype() const;
   int getCharge() const;
   void setCharge(int charge);
   float getMass() const;
   void setMass(float mass);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Properties>;
   friend class HDDM_ElementLink<Properties>;
 private:
   Properties(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_charge;
   float m_mass;
};

typedef HDDM_ElementList<Properties> PropertiesList;
typedef HDDM_ElementLink<Properties> PropertiesLink;

class Beam: public HDDM_Element {
 public:
   ~Beam();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   float getWeight() const;
   int getMinOccurs() const;
   Particle_t getType() const;
   void setType(Particle_t type);
   Momentum &getMomentum();
   MomentumList &getMomenta();
   MomentumList addMomenta(int count=1, int start=-1);
   void deleteMomenta(int count=-1, int start=0);
   Properties &getProperties();
   PropertiesList &getPropertiesList();
   PropertiesList addPropertiesList(int count=1, int start=-1);
   void deletePropertiesList(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Beam>;
   friend class HDDM_ElementLink<Beam>;
 private:
   Beam(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_type;
   MomentumLink m_momentum_link;
   PropertiesLink m_properties_link;
};

typedef HDDM_ElementList<Beam> BeamList;
typedef HDDM_ElementLink<Beam> BeamLink;

class Target: public HDDM_Element {
 public:
   ~Target();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   float getWeight() const;
   int getMinOccurs() const;
   Particle_t getType() const;
   void setType(Particle_t type);
   Momentum &getMomentum();
   MomentumList &getMomenta();
   MomentumList addMomenta(int count=1, int start=-1);
   void deleteMomenta(int count=-1, int start=0);
   Properties &getProperties();
   PropertiesList &getPropertiesList();
   PropertiesList addPropertiesList(int count=1, int start=-1);
   void deletePropertiesList(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Target>;
   friend class HDDM_ElementLink<Target>;
 private:
   Target(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_type;
   MomentumLink m_momentum_link;
   PropertiesLink m_properties_link;
};

typedef HDDM_ElementList<Target> TargetList;
typedef HDDM_ElementLink<Target> TargetLink;

class Product: public HDDM_Element {
 public:
   ~Product();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   float getWeight() const;
   int getDecayVertex() const;
   void setDecayVertex(int decayVertex);
   int getId() const;
   void setId(int id);
   std::string getMaxOccurs() const;
   int getMech() const;
   void setMech(int mech);
   int getParentid() const;
   void setParentid(int parentid);
   int getPdgtype() const;
   void setPdgtype(int pdgtype);
   Particle_t getType() const;
   void setType(Particle_t type);
   Momentum &getMomentum();
   MomentumList &getMomenta();
   MomentumList addMomenta(int count=1, int start=-1);
   void deleteMomenta(int count=-1, int start=0);
   Properties &getProperties();
   PropertiesList &getPropertiesList();
   PropertiesList addPropertiesList(int count=1, int start=-1);
   void deletePropertiesList(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Product>;
   friend class HDDM_ElementLink<Product>;
 private:
   Product(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_decayVertex;
   int m_id;
   int m_mech;
   int m_parentid;
   int m_pdgtype;
   int m_type;
   MomentumLink m_momentum_link;
   PropertiesLink m_properties_link;
};

typedef HDDM_ElementList<Product> ProductList;
typedef HDDM_ElementLink<Product> ProductLink;

class Origin: public HDDM_Element {
 public:
   ~Origin();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   float getFOM() const;
   int getNdof() const;
   int getCandidateid() const;
   float getChisq() const;
   int getId() const;
   int getTrackid() const;
   int getType() const;
   float getWeight() const;
   float getT() const;
   void setT(float t);
   float getVx() const;
   void setVx(float vx);
   float getVy() const;
   void setVy(float vy);
   float getVz() const;
   void setVz(float vz);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Origin>;
   friend class HDDM_ElementLink<Origin>;
 private:
   Origin(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_t;
   float m_vx;
   float m_vy;
   float m_vz;
};

typedef HDDM_ElementList<Origin> OriginList;
typedef HDDM_ElementLink<Origin> OriginLink;

class Vertex: public HDDM_Element {
 public:
   ~Vertex();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getType() const;
   float getWeight() const;
   std::string getMaxOccurs() const;
   Product &getProduct(int index=0);
   ProductList &getProducts();
   ProductList addProducts(int count=1, int start=-1);
   void deleteProducts(int count=-1, int start=0);
   Origin &getOrigin();
   OriginList &getOrigins();
   OriginList addOrigins(int count=1, int start=-1);
   void deleteOrigins(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Vertex>;
   friend class HDDM_ElementLink<Vertex>;
 private:
   Vertex(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   ProductList m_product_list;
   OriginLink m_origin_link;
};

typedef HDDM_ElementList<Vertex> VertexList;
typedef HDDM_ElementLink<Vertex> VertexLink;

class Random: public HDDM_Element {
 public:
   ~Random();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getType() const;
   float getWeight() const;
   int getMaxOccurs() const;
   int getMinOccurs() const;
   int getSeed1() const;
   void setSeed1(int seed1);
   int getSeed2() const;
   void setSeed2(int seed2);
   int getSeed_mcsmear1() const;
   void setSeed_mcsmear1(int seed_mcsmear1);
   int getSeed_mcsmear2() const;
   void setSeed_mcsmear2(int seed_mcsmear2);
   int getSeed_mcsmear3() const;
   void setSeed_mcsmear3(int seed_mcsmear3);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Random>;
   friend class HDDM_ElementLink<Random>;
 private:
   Random(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_seed1;
   int m_seed2;
   int m_seed_mcsmear1;
   int m_seed_mcsmear2;
   int m_seed_mcsmear3;
};

typedef HDDM_ElementList<Random> RandomList;
typedef HDDM_ElementLink<Random> RandomLink;

class Reaction: public HDDM_Element {
 public:
   ~Reaction();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getType() const;
   void setType(int type);
   float getWeight() const;
   void setWeight(float weight);
   Beam &getBeam();
   BeamList &getBeams();
   BeamList addBeams(int count=1, int start=-1);
   void deleteBeams(int count=-1, int start=0);
   Target &getTarget();
   TargetList &getTargets();
   TargetList addTargets(int count=1, int start=-1);
   void deleteTargets(int count=-1, int start=0);
   Vertex &getVertex(int index=0);
   VertexList &getVertices();
   VertexList addVertices(int count=1, int start=-1);
   void deleteVertices(int count=-1, int start=0);
   Random &getRandom();
   RandomList &getRandoms();
   RandomList addRandoms(int count=1, int start=-1);
   void deleteRandoms(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Reaction>;
   friend class HDDM_ElementLink<Reaction>;
 private:
   Reaction(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_type;
   float m_weight;
   BeamLink m_beam_link;
   TargetLink m_target_link;
   VertexList m_vertex_list;
   RandomLink m_random_link;
};

typedef HDDM_ElementList<Reaction> ReactionList;
typedef HDDM_ElementLink<Reaction> ReactionLink;

class CdcStrawHit: public HDDM_Element {
 public:
   ~CdcStrawHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getRing() const;
   int getStraw() const;
   float getD() const;
   void setD(float d);
   int getItrack() const;
   void setItrack(int itrack);
   std::string getMaxOccurs() const;
   int getPtype() const;
   void setPtype(int ptype);
   float getQ() const;
   void setQ(float q);
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CdcStrawHit>;
   friend class HDDM_ElementLink<CdcStrawHit>;
 private:
   CdcStrawHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_d;
   int m_itrack;
   int m_ptype;
   float m_q;
   float m_t;
};

typedef HDDM_ElementList<CdcStrawHit> CdcStrawHitList;
typedef HDDM_ElementLink<CdcStrawHit> CdcStrawHitLink;

class CdcStrawTruthHit: public HDDM_Element {
 public:
   ~CdcStrawTruthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getRing() const;
   int getStraw() const;
   float getD() const;
   void setD(float d);
   int getItrack() const;
   void setItrack(int itrack);
   std::string getMaxOccurs() const;
   int getPtype() const;
   void setPtype(int ptype);
   float getQ() const;
   void setQ(float q);
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CdcStrawTruthHit>;
   friend class HDDM_ElementLink<CdcStrawTruthHit>;
 private:
   CdcStrawTruthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_d;
   int m_itrack;
   int m_ptype;
   float m_q;
   float m_t;
};

typedef HDDM_ElementList<CdcStrawTruthHit> CdcStrawTruthHitList;
typedef HDDM_ElementLink<CdcStrawTruthHit> CdcStrawTruthHitLink;

class CdcStraw: public HDDM_Element {
 public:
   ~CdcStraw();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getRing() const;
   void setRing(int ring);
   int getStraw() const;
   void setStraw(int straw);
   CdcStrawHit &getCdcStrawHit(int index=0);
   CdcStrawHitList &getCdcStrawHits();
   CdcStrawHitList addCdcStrawHits(int count=1, int start=-1);
   void deleteCdcStrawHits(int count=-1, int start=0);
   CdcStrawTruthHit &getCdcStrawTruthHit(int index=0);
   CdcStrawTruthHitList &getCdcStrawTruthHits();
   CdcStrawTruthHitList addCdcStrawTruthHits(int count=1, int start=-1);
   void deleteCdcStrawTruthHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CdcStraw>;
   friend class HDDM_ElementLink<CdcStraw>;
 private:
   CdcStraw(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_ring;
   int m_straw;
   CdcStrawHitList m_cdcStrawHit_list;
   CdcStrawTruthHitList m_cdcStrawTruthHit_list;
};

typedef HDDM_ElementList<CdcStraw> CdcStrawList;
typedef HDDM_ElementLink<CdcStraw> CdcStrawLink;

class CdcTruthPoint: public HDDM_Element {
 public:
   ~CdcTruthPoint();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getDEdx() const;
   void setDEdx(float dEdx);
   float getDradius() const;
   void setDradius(float dradius);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getPhi() const;
   void setPhi(float phi);
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getR() const;
   void setR(float r);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CdcTruthPoint>;
   friend class HDDM_ElementLink<CdcTruthPoint>;
 private:
   CdcTruthPoint(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_dEdx;
   float m_dradius;
   float m_phi;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_r;
   float m_t;
   int m_track;
   float m_z;
};

typedef HDDM_ElementList<CdcTruthPoint> CdcTruthPointList;
typedef HDDM_ElementLink<CdcTruthPoint> CdcTruthPointLink;

class CentralDC: public HDDM_Element {
 public:
   ~CentralDC();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   CdcStraw &getCdcStraw(int index=0);
   CdcStrawList &getCdcStraws();
   CdcStrawList addCdcStraws(int count=1, int start=-1);
   void deleteCdcStraws(int count=-1, int start=0);
   CdcTruthPoint &getCdcTruthPoint(int index=0);
   CdcTruthPointList &getCdcTruthPoints();
   CdcTruthPointList addCdcTruthPoints(int count=1, int start=-1);
   void deleteCdcTruthPoints(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CentralDC>;
   friend class HDDM_ElementLink<CentralDC>;
 private:
   CentralDC(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   CdcStrawList m_cdcStraw_list;
   CdcTruthPointList m_cdcTruthPoint_list;
};

typedef HDDM_ElementList<CentralDC> CentralDCList;
typedef HDDM_ElementLink<CentralDC> CentralDCLink;

class FdcAnodeHit: public HDDM_Element {
 public:
   ~FdcAnodeHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getLayer() const;
   int getModule() const;
   int getWire() const;
   float getD() const;
   void setD(float d);
   float getDE() const;
   void setDE(float dE);
   int getItrack() const;
   void setItrack(int itrack);
   std::string getMaxOccurs() const;
   int getPtype() const;
   void setPtype(int ptype);
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FdcAnodeHit>;
   friend class HDDM_ElementLink<FdcAnodeHit>;
 private:
   FdcAnodeHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_d;
   float m_dE;
   int m_itrack;
   int m_ptype;
   float m_t;
};

typedef HDDM_ElementList<FdcAnodeHit> FdcAnodeHitList;
typedef HDDM_ElementLink<FdcAnodeHit> FdcAnodeHitLink;

class FdcAnodeTruthHit: public HDDM_Element {
 public:
   ~FdcAnodeTruthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getLayer() const;
   int getModule() const;
   int getWire() const;
   float getD() const;
   void setD(float d);
   float getDE() const;
   void setDE(float dE);
   int getItrack() const;
   void setItrack(int itrack);
   std::string getMaxOccurs() const;
   int getPtype() const;
   void setPtype(int ptype);
   float getT() const;
   void setT(float t);
   float getT_unsmeared() const;
   void setT_unsmeared(float t_unsmeared);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FdcAnodeTruthHit>;
   friend class HDDM_ElementLink<FdcAnodeTruthHit>;
 private:
   FdcAnodeTruthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_d;
   float m_dE;
   int m_itrack;
   int m_ptype;
   float m_t;
   float m_t_unsmeared;
};

typedef HDDM_ElementList<FdcAnodeTruthHit> FdcAnodeTruthHitList;
typedef HDDM_ElementLink<FdcAnodeTruthHit> FdcAnodeTruthHitLink;

class FdcAnodeWire: public HDDM_Element {
 public:
   ~FdcAnodeWire();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getModule() const;
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getWire() const;
   void setWire(int wire);
   FdcAnodeHit &getFdcAnodeHit(int index=0);
   FdcAnodeHitList &getFdcAnodeHits();
   FdcAnodeHitList addFdcAnodeHits(int count=1, int start=-1);
   void deleteFdcAnodeHits(int count=-1, int start=0);
   FdcAnodeTruthHit &getFdcAnodeTruthHit(int index=0);
   FdcAnodeTruthHitList &getFdcAnodeTruthHits();
   FdcAnodeTruthHitList addFdcAnodeTruthHits(int count=1, int start=-1);
   void deleteFdcAnodeTruthHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FdcAnodeWire>;
   friend class HDDM_ElementLink<FdcAnodeWire>;
 private:
   FdcAnodeWire(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_wire;
   FdcAnodeHitList m_fdcAnodeHit_list;
   FdcAnodeTruthHitList m_fdcAnodeTruthHit_list;
};

typedef HDDM_ElementList<FdcAnodeWire> FdcAnodeWireList;
typedef HDDM_ElementLink<FdcAnodeWire> FdcAnodeWireLink;

class FdcCathodeHit: public HDDM_Element {
 public:
   ~FdcCathodeHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getLayer() const;
   int getModule() const;
   int getPlane() const;
   int getStrip() const;
   int getItrack() const;
   void setItrack(int itrack);
   std::string getMaxOccurs() const;
   int getPtype() const;
   void setPtype(int ptype);
   float getQ() const;
   void setQ(float q);
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FdcCathodeHit>;
   friend class HDDM_ElementLink<FdcCathodeHit>;
 private:
   FdcCathodeHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_itrack;
   int m_ptype;
   float m_q;
   float m_t;
};

typedef HDDM_ElementList<FdcCathodeHit> FdcCathodeHitList;
typedef HDDM_ElementLink<FdcCathodeHit> FdcCathodeHitLink;

class FdcCathodeTruthHit: public HDDM_Element {
 public:
   ~FdcCathodeTruthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getLayer() const;
   int getModule() const;
   int getPlane() const;
   int getStrip() const;
   int getItrack() const;
   void setItrack(int itrack);
   std::string getMaxOccurs() const;
   int getPtype() const;
   void setPtype(int ptype);
   float getQ() const;
   void setQ(float q);
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FdcCathodeTruthHit>;
   friend class HDDM_ElementLink<FdcCathodeTruthHit>;
 private:
   FdcCathodeTruthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_itrack;
   int m_ptype;
   float m_q;
   float m_t;
};

typedef HDDM_ElementList<FdcCathodeTruthHit> FdcCathodeTruthHitList;
typedef HDDM_ElementLink<FdcCathodeTruthHit> FdcCathodeTruthHitLink;

class FdcCathodeStrip: public HDDM_Element {
 public:
   ~FdcCathodeStrip();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getModule() const;
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getPlane() const;
   void setPlane(int plane);
   int getStrip() const;
   void setStrip(int strip);
   FdcCathodeHit &getFdcCathodeHit(int index=0);
   FdcCathodeHitList &getFdcCathodeHits();
   FdcCathodeHitList addFdcCathodeHits(int count=1, int start=-1);
   void deleteFdcCathodeHits(int count=-1, int start=0);
   FdcCathodeTruthHit &getFdcCathodeTruthHit(int index=0);
   FdcCathodeTruthHitList &getFdcCathodeTruthHits();
   FdcCathodeTruthHitList addFdcCathodeTruthHits(int count=1, int start=-1);
   void deleteFdcCathodeTruthHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FdcCathodeStrip>;
   friend class HDDM_ElementLink<FdcCathodeStrip>;
 private:
   FdcCathodeStrip(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_plane;
   int m_strip;
   FdcCathodeHitList m_fdcCathodeHit_list;
   FdcCathodeTruthHitList m_fdcCathodeTruthHit_list;
};

typedef HDDM_ElementList<FdcCathodeStrip> FdcCathodeStripList;
typedef HDDM_ElementLink<FdcCathodeStrip> FdcCathodeStripLink;

class FdcTruthPoint: public HDDM_Element {
 public:
   ~FdcTruthPoint();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getModule() const;
   float getE() const;
   void setE(float E);
   float getDEdx() const;
   void setDEdx(float dEdx);
   float getDradius() const;
   void setDradius(float dradius);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FdcTruthPoint>;
   friend class HDDM_ElementLink<FdcTruthPoint>;
 private:
   FdcTruthPoint(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_dEdx;
   float m_dradius;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_t;
   int m_track;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<FdcTruthPoint> FdcTruthPointList;
typedef HDDM_ElementLink<FdcTruthPoint> FdcTruthPointLink;

class FdcChamber: public HDDM_Element {
 public:
   ~FdcChamber();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getLayer() const;
   void setLayer(int layer);
   std::string getMaxOccurs() const;
   int getModule() const;
   void setModule(int module);
   FdcAnodeWire &getFdcAnodeWire(int index=0);
   FdcAnodeWireList &getFdcAnodeWires();
   FdcAnodeWireList addFdcAnodeWires(int count=1, int start=-1);
   void deleteFdcAnodeWires(int count=-1, int start=0);
   FdcCathodeStrip &getFdcCathodeStrip(int index=0);
   FdcCathodeStripList &getFdcCathodeStrips();
   FdcCathodeStripList addFdcCathodeStrips(int count=1, int start=-1);
   void deleteFdcCathodeStrips(int count=-1, int start=0);
   FdcTruthPoint &getFdcTruthPoint(int index=0);
   FdcTruthPointList &getFdcTruthPoints();
   FdcTruthPointList addFdcTruthPoints(int count=1, int start=-1);
   void deleteFdcTruthPoints(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FdcChamber>;
   friend class HDDM_ElementLink<FdcChamber>;
 private:
   FdcChamber(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_layer;
   int m_module;
   FdcAnodeWireList m_fdcAnodeWire_list;
   FdcCathodeStripList m_fdcCathodeStrip_list;
   FdcTruthPointList m_fdcTruthPoint_list;
};

typedef HDDM_ElementList<FdcChamber> FdcChamberList;
typedef HDDM_ElementLink<FdcChamber> FdcChamberLink;

class ForwardDC: public HDDM_Element {
 public:
   ~ForwardDC();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   FdcChamber &getFdcChamber(int index=0);
   FdcChamberList &getFdcChambers();
   FdcChamberList addFdcChambers(int count=1, int start=-1);
   void deleteFdcChambers(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<ForwardDC>;
   friend class HDDM_ElementLink<ForwardDC>;
 private:
   ForwardDC(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   FdcChamberList m_fdcChamber_list;
};

typedef HDDM_ElementList<ForwardDC> ForwardDCList;
typedef HDDM_ElementLink<ForwardDC> ForwardDCLink;

class StcHit: public HDDM_Element {
 public:
   ~StcHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getSector() const;
   float getDE() const;
   void setDE(float dE);
   std::string getMaxOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<StcHit>;
   friend class HDDM_ElementLink<StcHit>;
 private:
   StcHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_dE;
   float m_t;
};

typedef HDDM_ElementList<StcHit> StcHitList;
typedef HDDM_ElementLink<StcHit> StcHitLink;

class StcTruthHit: public HDDM_Element {
 public:
   ~StcTruthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getSector() const;
   float getDE() const;
   void setDE(float dE);
   std::string getMaxOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<StcTruthHit>;
   friend class HDDM_ElementLink<StcTruthHit>;
 private:
   StcTruthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_dE;
   float m_t;
};

typedef HDDM_ElementList<StcTruthHit> StcTruthHitList;
typedef HDDM_ElementLink<StcTruthHit> StcTruthHitLink;

class StcPaddle: public HDDM_Element {
 public:
   ~StcPaddle();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getSector() const;
   void setSector(int sector);
   StcHit &getStcHit(int index=0);
   StcHitList &getStcHits();
   StcHitList addStcHits(int count=1, int start=-1);
   void deleteStcHits(int count=-1, int start=0);
   StcTruthHit &getStcTruthHit(int index=0);
   StcTruthHitList &getStcTruthHits();
   StcTruthHitList addStcTruthHits(int count=1, int start=-1);
   void deleteStcTruthHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<StcPaddle>;
   friend class HDDM_ElementLink<StcPaddle>;
 private:
   StcPaddle(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_sector;
   StcHitList m_stcHit_list;
   StcTruthHitList m_stcTruthHit_list;
};

typedef HDDM_ElementList<StcPaddle> StcPaddleList;
typedef HDDM_ElementLink<StcPaddle> StcPaddleLink;

class StcTruthPoint: public HDDM_Element {
 public:
   ~StcTruthPoint();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   float getDEdx() const;
   void setDEdx(float dEdx);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getPhi() const;
   void setPhi(float phi);
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getR() const;
   void setR(float r);
   int getSector() const;
   void setSector(int sector);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<StcTruthPoint>;
   friend class HDDM_ElementLink<StcTruthPoint>;
 private:
   StcTruthPoint(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_dEdx;
   float m_phi;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_r;
   int m_sector;
   float m_t;
   int m_track;
   float m_z;
};

typedef HDDM_ElementList<StcTruthPoint> StcTruthPointList;
typedef HDDM_ElementLink<StcTruthPoint> StcTruthPointLink;

class StartCntr: public HDDM_Element {
 public:
   ~StartCntr();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   StcPaddle &getStcPaddle(int index=0);
   StcPaddleList &getStcPaddles();
   StcPaddleList addStcPaddles(int count=1, int start=-1);
   void deleteStcPaddles(int count=-1, int start=0);
   StcTruthPoint &getStcTruthPoint(int index=0);
   StcTruthPointList &getStcTruthPoints();
   StcTruthPointList addStcTruthPoints(int count=1, int start=-1);
   void deleteStcTruthPoints(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<StartCntr>;
   friend class HDDM_ElementLink<StartCntr>;
 private:
   StartCntr(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   StcPaddleList m_stcPaddle_list;
   StcTruthPointList m_stcTruthPoint_list;
};

typedef HDDM_ElementList<StartCntr> StartCntrList;
typedef HDDM_ElementLink<StartCntr> StartCntrLink;

class BcalSiPMUpHit: public HDDM_Element {
 public:
   ~BcalSiPMUpHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getModule() const;
   int getSector() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalSiPMUpHit>;
   friend class HDDM_ElementLink<BcalSiPMUpHit>;
 private:
   BcalSiPMUpHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<BcalSiPMUpHit> BcalSiPMUpHitList;
typedef HDDM_ElementLink<BcalSiPMUpHit> BcalSiPMUpHitLink;

class BcalSiPMDownHit: public HDDM_Element {
 public:
   ~BcalSiPMDownHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getModule() const;
   int getSector() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalSiPMDownHit>;
   friend class HDDM_ElementLink<BcalSiPMDownHit>;
 private:
   BcalSiPMDownHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<BcalSiPMDownHit> BcalSiPMDownHitList;
typedef HDDM_ElementLink<BcalSiPMDownHit> BcalSiPMDownHitLink;

class BcalHit: public HDDM_Element {
 public:
   ~BcalHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getModule() const;
   int getSector() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   float getZLocal() const;
   void setZLocal(float zLocal);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalHit>;
   friend class HDDM_ElementLink<BcalHit>;
 private:
   BcalHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
   float m_zLocal;
};

typedef HDDM_ElementList<BcalHit> BcalHitList;
typedef HDDM_ElementLink<BcalHit> BcalHitLink;

class BcalCell: public HDDM_Element {
 public:
   ~BcalCell();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   void setLayer(int layer);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getModule() const;
   void setModule(int module);
   int getSector() const;
   void setSector(int sector);
   BcalSiPMUpHit &getBcalSiPMUpHit(int index=0);
   BcalSiPMUpHitList &getBcalSiPMUpHits();
   BcalSiPMUpHitList addBcalSiPMUpHits(int count=1, int start=-1);
   void deleteBcalSiPMUpHits(int count=-1, int start=0);
   BcalSiPMDownHit &getBcalSiPMDownHit(int index=0);
   BcalSiPMDownHitList &getBcalSiPMDownHits();
   BcalSiPMDownHitList addBcalSiPMDownHits(int count=1, int start=-1);
   void deleteBcalSiPMDownHits(int count=-1, int start=0);
   BcalHit &getBcalHit(int index=0);
   BcalHitList &getBcalHits();
   BcalHitList addBcalHits(int count=1, int start=-1);
   void deleteBcalHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalCell>;
   friend class HDDM_ElementLink<BcalCell>;
 private:
   BcalCell(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_layer;
   int m_module;
   int m_sector;
   BcalSiPMUpHitList m_bcalSiPMUpHit_list;
   BcalSiPMDownHitList m_bcalSiPMDownHit_list;
   BcalHitList m_bcalHit_list;
};

typedef HDDM_ElementList<BcalCell> BcalCellList;
typedef HDDM_ElementLink<BcalCell> BcalCellLink;

class BcalIncidentParticle: public HDDM_Element {
 public:
   ~BcalIncidentParticle();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getId() const;
   void setId(int id);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalIncidentParticle>;
   friend class HDDM_ElementLink<BcalIncidentParticle>;
 private:
   BcalIncidentParticle(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_id;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<BcalIncidentParticle> BcalIncidentParticleList;
typedef HDDM_ElementLink<BcalIncidentParticle> BcalIncidentParticleLink;

class BcalSiPMSpectrum: public HDDM_Element {
 public:
   ~BcalSiPMSpectrum();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getEtruth() const;
   void setEtruth(float Etruth);
   float getBin_width() const;
   void setBin_width(float bin_width);
   int getEnd() const;
   void setEnd(int end);
   int getIncident_id() const;
   void setIncident_id(int incident_id);
   int getLayer() const;
   void setLayer(int layer);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getModule() const;
   void setModule(int module);
   int getSector() const;
   void setSector(int sector);
   float getTstart() const;
   void setTstart(float tstart);
   std::string getVals() const;
   void setVals(const std::string &vals);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalSiPMSpectrum>;
   friend class HDDM_ElementLink<BcalSiPMSpectrum>;
 private:
   BcalSiPMSpectrum(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_Etruth;
   float m_bin_width;
   int m_end;
   int m_incident_id;
   int m_layer;
   int m_module;
   int m_sector;
   float m_tstart;
   std::string m_vals;
};

typedef HDDM_ElementList<BcalSiPMSpectrum> BcalSiPMSpectrumList;
typedef HDDM_ElementLink<BcalSiPMSpectrum> BcalSiPMSpectrumLink;

class BcalfADCUpHit: public HDDM_Element {
 public:
   ~BcalfADCUpHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getModule() const;
   int getSector() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalfADCUpHit>;
   friend class HDDM_ElementLink<BcalfADCUpHit>;
 private:
   BcalfADCUpHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<BcalfADCUpHit> BcalfADCUpHitList;
typedef HDDM_ElementLink<BcalfADCUpHit> BcalfADCUpHitLink;

class BcalfADCDownHit: public HDDM_Element {
 public:
   ~BcalfADCDownHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getModule() const;
   int getSector() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalfADCDownHit>;
   friend class HDDM_ElementLink<BcalfADCDownHit>;
 private:
   BcalfADCDownHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<BcalfADCDownHit> BcalfADCDownHitList;
typedef HDDM_ElementLink<BcalfADCDownHit> BcalfADCDownHitLink;

class BcalfADCCell: public HDDM_Element {
 public:
   ~BcalfADCCell();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   void setLayer(int layer);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getModule() const;
   void setModule(int module);
   int getSector() const;
   void setSector(int sector);
   BcalfADCUpHit &getBcalfADCUpHit(int index=0);
   BcalfADCUpHitList &getBcalfADCUpHits();
   BcalfADCUpHitList addBcalfADCUpHits(int count=1, int start=-1);
   void deleteBcalfADCUpHits(int count=-1, int start=0);
   BcalfADCDownHit &getBcalfADCDownHit(int index=0);
   BcalfADCDownHitList &getBcalfADCDownHits();
   BcalfADCDownHitList addBcalfADCDownHits(int count=1, int start=-1);
   void deleteBcalfADCDownHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalfADCCell>;
   friend class HDDM_ElementLink<BcalfADCCell>;
 private:
   BcalfADCCell(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_layer;
   int m_module;
   int m_sector;
   BcalfADCUpHitList m_bcalfADCUpHit_list;
   BcalfADCDownHitList m_bcalfADCDownHit_list;
};

typedef HDDM_ElementList<BcalfADCCell> BcalfADCCellList;
typedef HDDM_ElementLink<BcalfADCCell> BcalfADCCellLink;

class BcalTDCHit: public HDDM_Element {
 public:
   ~BcalTDCHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getEnd() const;
   void setEnd(int end);
   int getLayer() const;
   void setLayer(int layer);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getModule() const;
   void setModule(int module);
   int getSector() const;
   void setSector(int sector);
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalTDCHit>;
   friend class HDDM_ElementLink<BcalTDCHit>;
 private:
   BcalTDCHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_end;
   int m_layer;
   int m_module;
   int m_sector;
   float m_t;
};

typedef HDDM_ElementList<BcalTDCHit> BcalTDCHitList;
typedef HDDM_ElementLink<BcalTDCHit> BcalTDCHitLink;

class BcalTruthShower: public HDDM_Element {
 public:
   ~BcalTruthShower();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getPhi() const;
   void setPhi(float phi);
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getR() const;
   void setR(float r);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BcalTruthShower>;
   friend class HDDM_ElementLink<BcalTruthShower>;
 private:
   BcalTruthShower(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_phi;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_r;
   float m_t;
   int m_track;
   float m_z;
};

typedef HDDM_ElementList<BcalTruthShower> BcalTruthShowerList;
typedef HDDM_ElementLink<BcalTruthShower> BcalTruthShowerLink;

class BarrelEMcal: public HDDM_Element {
 public:
   ~BarrelEMcal();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   BcalCell &getBcalCell(int index=0);
   BcalCellList &getBcalCells();
   BcalCellList addBcalCells(int count=1, int start=-1);
   void deleteBcalCells(int count=-1, int start=0);
   BcalIncidentParticle &getBcalIncidentParticle(int index=0);
   BcalIncidentParticleList &getBcalIncidentParticles();
   BcalIncidentParticleList addBcalIncidentParticles(int count=1, int start=-1);
   void deleteBcalIncidentParticles(int count=-1, int start=0);
   BcalSiPMSpectrum &getBcalSiPMSpectrum(int index=0);
   BcalSiPMSpectrumList &getBcalSiPMSpectrums();
   BcalSiPMSpectrumList addBcalSiPMSpectrums(int count=1, int start=-1);
   void deleteBcalSiPMSpectrums(int count=-1, int start=0);
   BcalfADCCell &getBcalfADCCell(int index=0);
   BcalfADCCellList &getBcalfADCCells();
   BcalfADCCellList addBcalfADCCells(int count=1, int start=-1);
   void deleteBcalfADCCells(int count=-1, int start=0);
   BcalTDCHit &getBcalTDCHit(int index=0);
   BcalTDCHitList &getBcalTDCHits();
   BcalTDCHitList addBcalTDCHits(int count=1, int start=-1);
   void deleteBcalTDCHits(int count=-1, int start=0);
   BcalTruthShower &getBcalTruthShower(int index=0);
   BcalTruthShowerList &getBcalTruthShowers();
   BcalTruthShowerList addBcalTruthShowers(int count=1, int start=-1);
   void deleteBcalTruthShowers(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<BarrelEMcal>;
   friend class HDDM_ElementLink<BarrelEMcal>;
 private:
   BarrelEMcal(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   BcalCellList m_bcalCell_list;
   BcalIncidentParticleList m_bcalIncidentParticle_list;
   BcalSiPMSpectrumList m_bcalSiPMSpectrum_list;
   BcalfADCCellList m_bcalfADCCell_list;
   BcalTDCHitList m_bcalTDCHit_list;
   BcalTruthShowerList m_bcalTruthShower_list;
};

typedef HDDM_ElementList<BarrelEMcal> BarrelEMcalList;
typedef HDDM_ElementLink<BarrelEMcal> BarrelEMcalLink;

class GcalHit: public HDDM_Element {
 public:
   ~GcalHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getModule() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   float getZLocal() const;
   void setZLocal(float zLocal);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<GcalHit>;
   friend class HDDM_ElementLink<GcalHit>;
 private:
   GcalHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
   float m_zLocal;
};

typedef HDDM_ElementList<GcalHit> GcalHitList;
typedef HDDM_ElementLink<GcalHit> GcalHitLink;

class GcalCell: public HDDM_Element {
 public:
   ~GcalCell();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMaxOccurs() const;
   int getMinOccurs() const;
   int getModule() const;
   void setModule(int module);
   GcalHit &getGcalHit(int index=0);
   GcalHitList &getGcalHits();
   GcalHitList addGcalHits(int count=1, int start=-1);
   void deleteGcalHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<GcalCell>;
   friend class HDDM_ElementLink<GcalCell>;
 private:
   GcalCell(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_module;
   GcalHitList m_gcalHit_list;
};

typedef HDDM_ElementList<GcalCell> GcalCellList;
typedef HDDM_ElementLink<GcalCell> GcalCellLink;

class GcalTruthShower: public HDDM_Element {
 public:
   ~GcalTruthShower();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getPhi() const;
   void setPhi(float phi);
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getR() const;
   void setR(float r);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<GcalTruthShower>;
   friend class HDDM_ElementLink<GcalTruthShower>;
 private:
   GcalTruthShower(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_phi;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_r;
   float m_t;
   int m_track;
   float m_z;
};

typedef HDDM_ElementList<GcalTruthShower> GcalTruthShowerList;
typedef HDDM_ElementLink<GcalTruthShower> GcalTruthShowerLink;

class GapEMcal: public HDDM_Element {
 public:
   ~GapEMcal();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   GcalCell &getGcalCell(int index=0);
   GcalCellList &getGcalCells();
   GcalCellList addGcalCells(int count=1, int start=-1);
   void deleteGcalCells(int count=-1, int start=0);
   GcalTruthShower &getGcalTruthShower(int index=0);
   GcalTruthShowerList &getGcalTruthShowers();
   GcalTruthShowerList addGcalTruthShowers(int count=1, int start=-1);
   void deleteGcalTruthShowers(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<GapEMcal>;
   friend class HDDM_ElementLink<GapEMcal>;
 private:
   GapEMcal(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   GcalCellList m_gcalCell_list;
   GcalTruthShowerList m_gcalTruthShower_list;
};

typedef HDDM_ElementList<GapEMcal> GapEMcalList;
typedef HDDM_ElementLink<GapEMcal> GapEMcalLink;

class CereHit: public HDDM_Element {
 public:
   ~CereHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getSector() const;
   std::string getMaxOccurs() const;
   float getPe() const;
   void setPe(float pe);
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CereHit>;
   friend class HDDM_ElementLink<CereHit>;
 private:
   CereHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_pe;
   float m_t;
};

typedef HDDM_ElementList<CereHit> CereHitList;
typedef HDDM_ElementLink<CereHit> CereHitLink;

class CereSection: public HDDM_Element {
 public:
   ~CereSection();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getSector() const;
   void setSector(int sector);
   CereHit &getCereHit(int index=0);
   CereHitList &getCereHits();
   CereHitList addCereHits(int count=1, int start=-1);
   void deleteCereHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CereSection>;
   friend class HDDM_ElementLink<CereSection>;
 private:
   CereSection(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_sector;
   CereHitList m_cereHit_list;
};

typedef HDDM_ElementList<CereSection> CereSectionList;
typedef HDDM_ElementLink<CereSection> CereSectionLink;

class CereTruthPoint: public HDDM_Element {
 public:
   ~CereTruthPoint();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CereTruthPoint>;
   friend class HDDM_ElementLink<CereTruthPoint>;
 private:
   CereTruthPoint(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_t;
   int m_track;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<CereTruthPoint> CereTruthPointList;
typedef HDDM_ElementLink<CereTruthPoint> CereTruthPointLink;

class Cerenkov: public HDDM_Element {
 public:
   ~Cerenkov();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   CereSection &getCereSection(int index=0);
   CereSectionList &getCereSections();
   CereSectionList addCereSections(int count=1, int start=-1);
   void deleteCereSections(int count=-1, int start=0);
   CereTruthPoint &getCereTruthPoint(int index=0);
   CereTruthPointList &getCereTruthPoints();
   CereTruthPointList addCereTruthPoints(int count=1, int start=-1);
   void deleteCereTruthPoints(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Cerenkov>;
   friend class HDDM_ElementLink<Cerenkov>;
 private:
   Cerenkov(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   CereSectionList m_cereSection_list;
   CereTruthPointList m_cereTruthPoint_list;
};

typedef HDDM_ElementList<Cerenkov> CerenkovList;
typedef HDDM_ElementLink<Cerenkov> CerenkovLink;

class RichHit: public HDDM_Element {
 public:
   ~RichHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<RichHit>;
   friend class HDDM_ElementLink<RichHit>;
 private:
   RichHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_t;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<RichHit> RichHitList;
typedef HDDM_ElementLink<RichHit> RichHitLink;

class RichTruthPoint: public HDDM_Element {
 public:
   ~RichTruthPoint();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<RichTruthPoint>;
   friend class HDDM_ElementLink<RichTruthPoint>;
 private:
   RichTruthPoint(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_t;
   int m_track;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<RichTruthPoint> RichTruthPointList;
typedef HDDM_ElementLink<RichTruthPoint> RichTruthPointLink;

class RICH: public HDDM_Element {
 public:
   ~RICH();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   RichHit &getRichHit(int index=0);
   RichHitList &getRichHits();
   RichHitList addRichHits(int count=1, int start=-1);
   void deleteRichHits(int count=-1, int start=0);
   RichTruthPoint &getRichTruthPoint(int index=0);
   RichTruthPointList &getRichTruthPoints();
   RichTruthPointList addRichTruthPoints(int count=1, int start=-1);
   void deleteRichTruthPoints(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<RICH>;
   friend class HDDM_ElementLink<RICH>;
 private:
   RICH(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   RichHitList m_richHit_list;
   RichTruthPointList m_richTruthPoint_list;
};

typedef HDDM_ElementList<RICH> RICHList;
typedef HDDM_ElementLink<RICH> RICHLink;

class FtofMCHit: public HDDM_Element {
 public:
   ~FtofMCHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getBar() const;
   int getPlane() const;
   float getDE() const;
   float getT() const;
   float getE() const;
   void setE(float E);
   float getDist() const;
   void setDist(float dist);
   int getItrack() const;
   void setItrack(int itrack);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FtofMCHit>;
   friend class HDDM_ElementLink<FtofMCHit>;
 private:
   FtofMCHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_dist;
   int m_itrack;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<FtofMCHit> FtofMCHitList;
typedef HDDM_ElementLink<FtofMCHit> FtofMCHitLink;

class FtofNorthTruthHit: public HDDM_Element {
 public:
   ~FtofNorthTruthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getBar() const;
   int getPlane() const;
   float getDE() const;
   void setDE(float dE);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   FtofMCHit &getFtofMCHit(int index=0);
   FtofMCHitList &getFtofMCHits();
   FtofMCHitList addFtofMCHits(int count=1, int start=-1);
   void deleteFtofMCHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FtofNorthTruthHit>;
   friend class HDDM_ElementLink<FtofNorthTruthHit>;
 private:
   FtofNorthTruthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_dE;
   float m_t;
   FtofMCHitList m_ftofMCHit_list;
};

typedef HDDM_ElementList<FtofNorthTruthHit> FtofNorthTruthHitList;
typedef HDDM_ElementLink<FtofNorthTruthHit> FtofNorthTruthHitLink;

class FtofSouthTruthHit: public HDDM_Element {
 public:
   ~FtofSouthTruthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getBar() const;
   int getPlane() const;
   float getDE() const;
   void setDE(float dE);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   FtofMCHit &getFtofMCHit(int index=0);
   FtofMCHitList &getFtofMCHits();
   FtofMCHitList addFtofMCHits(int count=1, int start=-1);
   void deleteFtofMCHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FtofSouthTruthHit>;
   friend class HDDM_ElementLink<FtofSouthTruthHit>;
 private:
   FtofSouthTruthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_dE;
   float m_t;
   FtofMCHitList m_ftofMCHit_list;
};

typedef HDDM_ElementList<FtofSouthTruthHit> FtofSouthTruthHitList;
typedef HDDM_ElementLink<FtofSouthTruthHit> FtofSouthTruthHitLink;

class FtofNorthHit: public HDDM_Element {
 public:
   ~FtofNorthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getBar() const;
   int getPlane() const;
   float getDE() const;
   void setDE(float dE);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FtofNorthHit>;
   friend class HDDM_ElementLink<FtofNorthHit>;
 private:
   FtofNorthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_dE;
   float m_t;
};

typedef HDDM_ElementList<FtofNorthHit> FtofNorthHitList;
typedef HDDM_ElementLink<FtofNorthHit> FtofNorthHitLink;

class FtofSouthHit: public HDDM_Element {
 public:
   ~FtofSouthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getBar() const;
   int getPlane() const;
   float getDE() const;
   void setDE(float dE);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FtofSouthHit>;
   friend class HDDM_ElementLink<FtofSouthHit>;
 private:
   FtofSouthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_dE;
   float m_t;
};

typedef HDDM_ElementList<FtofSouthHit> FtofSouthHitList;
typedef HDDM_ElementLink<FtofSouthHit> FtofSouthHitLink;

class FtofCounter: public HDDM_Element {
 public:
   ~FtofCounter();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getBar() const;
   void setBar(int bar);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getPlane() const;
   void setPlane(int plane);
   FtofNorthTruthHit &getFtofNorthTruthHit(int index=0);
   FtofNorthTruthHitList &getFtofNorthTruthHits();
   FtofNorthTruthHitList addFtofNorthTruthHits(int count=1, int start=-1);
   void deleteFtofNorthTruthHits(int count=-1, int start=0);
   FtofSouthTruthHit &getFtofSouthTruthHit(int index=0);
   FtofSouthTruthHitList &getFtofSouthTruthHits();
   FtofSouthTruthHitList addFtofSouthTruthHits(int count=1, int start=-1);
   void deleteFtofSouthTruthHits(int count=-1, int start=0);
   FtofNorthHit &getFtofNorthHit(int index=0);
   FtofNorthHitList &getFtofNorthHits();
   FtofNorthHitList addFtofNorthHits(int count=1, int start=-1);
   void deleteFtofNorthHits(int count=-1, int start=0);
   FtofSouthHit &getFtofSouthHit(int index=0);
   FtofSouthHitList &getFtofSouthHits();
   FtofSouthHitList addFtofSouthHits(int count=1, int start=-1);
   void deleteFtofSouthHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FtofCounter>;
   friend class HDDM_ElementLink<FtofCounter>;
 private:
   FtofCounter(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_bar;
   int m_plane;
   FtofNorthTruthHitList m_ftofNorthTruthHit_list;
   FtofSouthTruthHitList m_ftofSouthTruthHit_list;
   FtofNorthHitList m_ftofNorthHit_list;
   FtofSouthHitList m_ftofSouthHit_list;
};

typedef HDDM_ElementList<FtofCounter> FtofCounterList;
typedef HDDM_ElementLink<FtofCounter> FtofCounterLink;

class FtofTruthPoint: public HDDM_Element {
 public:
   ~FtofTruthPoint();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FtofTruthPoint>;
   friend class HDDM_ElementLink<FtofTruthPoint>;
 private:
   FtofTruthPoint(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_t;
   int m_track;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<FtofTruthPoint> FtofTruthPointList;
typedef HDDM_ElementLink<FtofTruthPoint> FtofTruthPointLink;

class ForwardTOF: public HDDM_Element {
 public:
   ~ForwardTOF();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   FtofCounter &getFtofCounter(int index=0);
   FtofCounterList &getFtofCounters();
   FtofCounterList addFtofCounters(int count=1, int start=-1);
   void deleteFtofCounters(int count=-1, int start=0);
   FtofTruthPoint &getFtofTruthPoint(int index=0);
   FtofTruthPointList &getFtofTruthPoints();
   FtofTruthPointList addFtofTruthPoints(int count=1, int start=-1);
   void deleteFtofTruthPoints(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<ForwardTOF>;
   friend class HDDM_ElementLink<ForwardTOF>;
 private:
   ForwardTOF(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   FtofCounterList m_ftofCounter_list;
   FtofTruthPointList m_ftofTruthPoint_list;
};

typedef HDDM_ElementList<ForwardTOF> ForwardTOFList;
typedef HDDM_ElementLink<ForwardTOF> ForwardTOFLink;

class FcalHit: public HDDM_Element {
 public:
   ~FcalHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getColumn() const;
   int getRow() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FcalHit>;
   friend class HDDM_ElementLink<FcalHit>;
 private:
   FcalHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<FcalHit> FcalHitList;
typedef HDDM_ElementLink<FcalHit> FcalHitLink;

class FcalTruthHit: public HDDM_Element {
 public:
   ~FcalTruthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getColumn() const;
   int getRow() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FcalTruthHit>;
   friend class HDDM_ElementLink<FcalTruthHit>;
 private:
   FcalTruthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<FcalTruthHit> FcalTruthHitList;
typedef HDDM_ElementLink<FcalTruthHit> FcalTruthHitLink;

class FcalBlock: public HDDM_Element {
 public:
   ~FcalBlock();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getColumn() const;
   void setColumn(int column);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getRow() const;
   void setRow(int row);
   FcalHit &getFcalHit(int index=0);
   FcalHitList &getFcalHits();
   FcalHitList addFcalHits(int count=1, int start=-1);
   void deleteFcalHits(int count=-1, int start=0);
   FcalTruthHit &getFcalTruthHit(int index=0);
   FcalTruthHitList &getFcalTruthHits();
   FcalTruthHitList addFcalTruthHits(int count=1, int start=-1);
   void deleteFcalTruthHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FcalBlock>;
   friend class HDDM_ElementLink<FcalBlock>;
 private:
   FcalBlock(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_column;
   int m_row;
   FcalHitList m_fcalHit_list;
   FcalTruthHitList m_fcalTruthHit_list;
};

typedef HDDM_ElementList<FcalBlock> FcalBlockList;
typedef HDDM_ElementLink<FcalBlock> FcalBlockLink;

class FcalTruthShower: public HDDM_Element {
 public:
   ~FcalTruthShower();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<FcalTruthShower>;
   friend class HDDM_ElementLink<FcalTruthShower>;
 private:
   FcalTruthShower(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_t;
   int m_track;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<FcalTruthShower> FcalTruthShowerList;
typedef HDDM_ElementLink<FcalTruthShower> FcalTruthShowerLink;

class ForwardEMcal: public HDDM_Element {
 public:
   ~ForwardEMcal();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   FcalBlock &getFcalBlock(int index=0);
   FcalBlockList &getFcalBlocks();
   FcalBlockList addFcalBlocks(int count=1, int start=-1);
   void deleteFcalBlocks(int count=-1, int start=0);
   FcalTruthShower &getFcalTruthShower(int index=0);
   FcalTruthShowerList &getFcalTruthShowers();
   FcalTruthShowerList addFcalTruthShowers(int count=1, int start=-1);
   void deleteFcalTruthShowers(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<ForwardEMcal>;
   friend class HDDM_ElementLink<ForwardEMcal>;
 private:
   ForwardEMcal(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   FcalBlockList m_fcalBlock_list;
   FcalTruthShowerList m_fcalTruthShower_list;
};

typedef HDDM_ElementList<ForwardEMcal> ForwardEMcalList;
typedef HDDM_ElementLink<ForwardEMcal> ForwardEMcalLink;

class CcalHit: public HDDM_Element {
 public:
   ~CcalHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getColumn() const;
   int getRow() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CcalHit>;
   friend class HDDM_ElementLink<CcalHit>;
 private:
   CcalHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<CcalHit> CcalHitList;
typedef HDDM_ElementLink<CcalHit> CcalHitLink;

class CcalTruthHit: public HDDM_Element {
 public:
   ~CcalTruthHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getMinOccurs() const;
   int getColumn() const;
   int getRow() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CcalTruthHit>;
   friend class HDDM_ElementLink<CcalTruthHit>;
 private:
   CcalTruthHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<CcalTruthHit> CcalTruthHitList;
typedef HDDM_ElementLink<CcalTruthHit> CcalTruthHitLink;

class CcalBlock: public HDDM_Element {
 public:
   ~CcalBlock();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getColumn() const;
   void setColumn(int column);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getRow() const;
   void setRow(int row);
   CcalHit &getCcalHit(int index=0);
   CcalHitList &getCcalHits();
   CcalHitList addCcalHits(int count=1, int start=-1);
   void deleteCcalHits(int count=-1, int start=0);
   CcalTruthHit &getCcalTruthHit(int index=0);
   CcalTruthHitList &getCcalTruthHits();
   CcalTruthHitList addCcalTruthHits(int count=1, int start=-1);
   void deleteCcalTruthHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CcalBlock>;
   friend class HDDM_ElementLink<CcalBlock>;
 private:
   CcalBlock(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_column;
   int m_row;
   CcalHitList m_ccalHit_list;
   CcalTruthHitList m_ccalTruthHit_list;
};

typedef HDDM_ElementList<CcalBlock> CcalBlockList;
typedef HDDM_ElementLink<CcalBlock> CcalBlockLink;

class CcalTruthShower: public HDDM_Element {
 public:
   ~CcalTruthShower();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<CcalTruthShower>;
   friend class HDDM_ElementLink<CcalTruthShower>;
 private:
   CcalTruthShower(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_t;
   int m_track;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<CcalTruthShower> CcalTruthShowerList;
typedef HDDM_ElementLink<CcalTruthShower> CcalTruthShowerLink;

class ComptonEMcal: public HDDM_Element {
 public:
   ~ComptonEMcal();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   CcalBlock &getCcalBlock(int index=0);
   CcalBlockList &getCcalBlocks();
   CcalBlockList addCcalBlocks(int count=1, int start=-1);
   void deleteCcalBlocks(int count=-1, int start=0);
   CcalTruthShower &getCcalTruthShower(int index=0);
   CcalTruthShowerList &getCcalTruthShowers();
   CcalTruthShowerList addCcalTruthShowers(int count=1, int start=-1);
   void deleteCcalTruthShowers(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<ComptonEMcal>;
   friend class HDDM_ElementLink<ComptonEMcal>;
 private:
   ComptonEMcal(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   CcalBlockList m_ccalBlock_list;
   CcalTruthShowerList m_ccalTruthShower_list;
};

typedef HDDM_ElementList<ComptonEMcal> ComptonEMcalList;
typedef HDDM_ElementLink<ComptonEMcal> ComptonEMcalLink;

class GamsClust: public HDDM_Element {
 public:
   ~GamsClust();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   float getChi2() const;
   void setChi2(float chi2);
   int getDime() const;
   void setDime(int dime);
   int getId() const;
   void setId(int id);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   int getType() const;
   void setType(int type);
   float getX() const;
   void setX(float x);
   float getXc() const;
   void setXc(float xc);
   float getY() const;
   void setY(float y);
   float getYc() const;
   void setYc(float yc);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<GamsClust>;
   friend class HDDM_ElementLink<GamsClust>;
 private:
   GamsClust(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_chi2;
   int m_dime;
   int m_id;
   float m_t;
   int m_type;
   float m_x;
   float m_xc;
   float m_y;
   float m_yc;
   float m_z;
};

typedef HDDM_ElementList<GamsClust> GamsClustList;
typedef HDDM_ElementLink<GamsClust> GamsClustLink;

class GamsEMcal: public HDDM_Element {
 public:
   ~GamsEMcal();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   GamsClust &getGamsClust(int index=0);
   GamsClustList &getGamsClusts();
   GamsClustList addGamsClusts(int count=1, int start=-1);
   void deleteGamsClusts(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<GamsEMcal>;
   friend class HDDM_ElementLink<GamsEMcal>;
 private:
   GamsEMcal(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   GamsClustList m_gamsClust_list;
};

typedef HDDM_ElementList<GamsEMcal> GamsEMcalList;
typedef HDDM_ElementLink<GamsEMcal> GamsEMcalLink;

class UpvLeftHit: public HDDM_Element {
 public:
   ~UpvLeftHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getRow() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<UpvLeftHit>;
   friend class HDDM_ElementLink<UpvLeftHit>;
 private:
   UpvLeftHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<UpvLeftHit> UpvLeftHitList;
typedef HDDM_ElementLink<UpvLeftHit> UpvLeftHitLink;

class UpvRightHit: public HDDM_Element {
 public:
   ~UpvRightHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   int getRow() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<UpvRightHit>;
   friend class HDDM_ElementLink<UpvRightHit>;
 private:
   UpvRightHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_t;
};

typedef HDDM_ElementList<UpvRightHit> UpvRightHitList;
typedef HDDM_ElementLink<UpvRightHit> UpvRightHitLink;

class UpvPaddle: public HDDM_Element {
 public:
   ~UpvPaddle();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   int getLayer() const;
   void setLayer(int layer);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getRow() const;
   void setRow(int row);
   UpvLeftHit &getUpvLeftHit(int index=0);
   UpvLeftHitList &getUpvLeftHits();
   UpvLeftHitList addUpvLeftHits(int count=1, int start=-1);
   void deleteUpvLeftHits(int count=-1, int start=0);
   UpvRightHit &getUpvRightHit(int index=0);
   UpvRightHitList &getUpvRightHits();
   UpvRightHitList addUpvRightHits(int count=1, int start=-1);
   void deleteUpvRightHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<UpvPaddle>;
   friend class HDDM_ElementLink<UpvPaddle>;
 private:
   UpvPaddle(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_layer;
   int m_row;
   UpvLeftHitList m_upvLeftHit_list;
   UpvRightHitList m_upvRightHit_list;
};

typedef HDDM_ElementList<UpvPaddle> UpvPaddleList;
typedef HDDM_ElementLink<UpvPaddle> UpvPaddleLink;

class UpvTruthShower: public HDDM_Element {
 public:
   ~UpvTruthShower();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   bool getPrimary() const;
   void setPrimary(bool primary);
   int getPtype() const;
   void setPtype(int ptype);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<UpvTruthShower>;
   friend class HDDM_ElementLink<UpvTruthShower>;
 private:
   UpvTruthShower(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   int m_primary;
   int m_ptype;
   float m_px;
   float m_py;
   float m_pz;
   float m_t;
   int m_track;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<UpvTruthShower> UpvTruthShowerList;
typedef HDDM_ElementLink<UpvTruthShower> UpvTruthShowerLink;

class UpstreamEMveto: public HDDM_Element {
 public:
   ~UpstreamEMveto();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   UpvPaddle &getUpvPaddle(int index=0);
   UpvPaddleList &getUpvPaddles();
   UpvPaddleList addUpvPaddles(int count=1, int start=-1);
   void deleteUpvPaddles(int count=-1, int start=0);
   UpvTruthShower &getUpvTruthShower(int index=0);
   UpvTruthShowerList &getUpvTruthShowers();
   UpvTruthShowerList addUpvTruthShowers(int count=1, int start=-1);
   void deleteUpvTruthShowers(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<UpstreamEMveto>;
   friend class HDDM_ElementLink<UpstreamEMveto>;
 private:
   UpstreamEMveto(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   UpvPaddleList m_upvPaddle_list;
   UpvTruthShowerList m_upvTruthShower_list;
};

typedef HDDM_ElementList<UpstreamEMveto> UpstreamEMvetoList;
typedef HDDM_ElementLink<UpstreamEMveto> UpstreamEMvetoLink;

class TaggerHit: public HDDM_Element {
 public:
   ~TaggerHit();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   int getColumn() const;
   int getRow() const;
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   float getT() const;
   void setT(float t);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<TaggerHit>;
   friend class HDDM_ElementLink<TaggerHit>;
 private:
   TaggerHit(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_t;
};

typedef HDDM_ElementList<TaggerHit> TaggerHitList;
typedef HDDM_ElementLink<TaggerHit> TaggerHitLink;

class MicroChannel: public HDDM_Element {
 public:
   ~MicroChannel();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   int getColumn() const;
   void setColumn(int column);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getRow() const;
   void setRow(int row);
   TaggerHit &getTaggerHit(int index=0);
   TaggerHitList &getTaggerHits();
   TaggerHitList addTaggerHits(int count=1, int start=-1);
   void deleteTaggerHits(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<MicroChannel>;
   friend class HDDM_ElementLink<MicroChannel>;
 private:
   MicroChannel(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   int m_column;
   int m_row;
   TaggerHitList m_taggerHit_list;
};

typedef HDDM_ElementList<MicroChannel> MicroChannelList;
typedef HDDM_ElementLink<MicroChannel> MicroChannelLink;

class Tagger: public HDDM_Element {
 public:
   ~Tagger();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   MicroChannel &getMicroChannel(int index=0);
   MicroChannelList &getMicroChannels();
   MicroChannelList addMicroChannels(int count=1, int start=-1);
   void deleteMicroChannels(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Tagger>;
   friend class HDDM_ElementLink<Tagger>;
 private:
   Tagger(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   MicroChannelList m_microChannel_list;
};

typedef HDDM_ElementList<Tagger> TaggerList;
typedef HDDM_ElementLink<Tagger> TaggerLink;

class McTrajectoryPoint: public HDDM_Element {
 public:
   ~McTrajectoryPoint();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getE() const;
   void setE(float E);
   float getDE() const;
   void setDE(float dE);
   std::string getMaxOccurs() const;
   int getMech() const;
   void setMech(int mech);
   int getMinOccurs() const;
   int getPart() const;
   void setPart(int part);
   int getPrimary_track() const;
   void setPrimary_track(int primary_track);
   float getPx() const;
   void setPx(float px);
   float getPy() const;
   void setPy(float py);
   float getPz() const;
   void setPz(float pz);
   float getRadlen() const;
   void setRadlen(float radlen);
   float getStep() const;
   void setStep(float step);
   float getT() const;
   void setT(float t);
   int getTrack() const;
   void setTrack(int track);
   float getX() const;
   void setX(float x);
   float getY() const;
   void setY(float y);
   float getZ() const;
   void setZ(float z);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<McTrajectoryPoint>;
   friend class HDDM_ElementLink<McTrajectoryPoint>;
 private:
   McTrajectoryPoint(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_E;
   float m_dE;
   int m_mech;
   int m_part;
   int m_primary_track;
   float m_px;
   float m_py;
   float m_pz;
   float m_radlen;
   float m_step;
   float m_t;
   int m_track;
   float m_x;
   float m_y;
   float m_z;
};

typedef HDDM_ElementList<McTrajectoryPoint> McTrajectoryPointList;
typedef HDDM_ElementLink<McTrajectoryPoint> McTrajectoryPointLink;

class McTrajectory: public HDDM_Element {
 public:
   ~McTrajectory();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   McTrajectoryPoint &getMcTrajectoryPoint(int index=0);
   McTrajectoryPointList &getMcTrajectoryPoints();
   McTrajectoryPointList addMcTrajectoryPoints(int count=1, int start=-1);
   void deleteMcTrajectoryPoints(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<McTrajectory>;
   friend class HDDM_ElementLink<McTrajectory>;
 private:
   McTrajectory(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   McTrajectoryPointList m_mcTrajectoryPoint_list;
};

typedef HDDM_ElementList<McTrajectory> McTrajectoryList;
typedef HDDM_ElementLink<McTrajectory> McTrajectoryLink;

class HitView: public HDDM_Element {
 public:
   ~HitView();
   std::string getClass() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   float getVersion() const;
   CentralDC &getCentralDC();
   CentralDCList &getCentralDCs();
   CentralDCList addCentralDCs(int count=1, int start=-1);
   void deleteCentralDCs(int count=-1, int start=0);
   ForwardDC &getForwardDC();
   ForwardDCList &getForwardDCs();
   ForwardDCList addForwardDCs(int count=1, int start=-1);
   void deleteForwardDCs(int count=-1, int start=0);
   StartCntr &getStartCntr();
   StartCntrList &getStartCntrs();
   StartCntrList addStartCntrs(int count=1, int start=-1);
   void deleteStartCntrs(int count=-1, int start=0);
   BarrelEMcal &getBarrelEMcal();
   BarrelEMcalList &getBarrelEMcals();
   BarrelEMcalList addBarrelEMcals(int count=1, int start=-1);
   void deleteBarrelEMcals(int count=-1, int start=0);
   GapEMcal &getGapEMcal();
   GapEMcalList &getGapEMcals();
   GapEMcalList addGapEMcals(int count=1, int start=-1);
   void deleteGapEMcals(int count=-1, int start=0);
   Cerenkov &getCerenkov();
   CerenkovList &getCerenkovs();
   CerenkovList addCerenkovs(int count=1, int start=-1);
   void deleteCerenkovs(int count=-1, int start=0);
   RICH &getRICH();
   RICHList &getRICHs();
   RICHList addRICHs(int count=1, int start=-1);
   void deleteRICHs(int count=-1, int start=0);
   ForwardTOF &getForwardTOF();
   ForwardTOFList &getForwardTOFs();
   ForwardTOFList addForwardTOFs(int count=1, int start=-1);
   void deleteForwardTOFs(int count=-1, int start=0);
   ForwardEMcal &getForwardEMcal();
   ForwardEMcalList &getForwardEMcals();
   ForwardEMcalList addForwardEMcals(int count=1, int start=-1);
   void deleteForwardEMcals(int count=-1, int start=0);
   ComptonEMcal &getComptonEMcal();
   ComptonEMcalList &getComptonEMcals();
   ComptonEMcalList addComptonEMcals(int count=1, int start=-1);
   void deleteComptonEMcals(int count=-1, int start=0);
   GamsEMcal &getGamsEMcal();
   GamsEMcalList &getGamsEMcals();
   GamsEMcalList addGamsEMcals(int count=1, int start=-1);
   void deleteGamsEMcals(int count=-1, int start=0);
   UpstreamEMveto &getUpstreamEMveto();
   UpstreamEMvetoList &getUpstreamEMvetos();
   UpstreamEMvetoList addUpstreamEMvetos(int count=1, int start=-1);
   void deleteUpstreamEMvetos(int count=-1, int start=0);
   Tagger &getTagger();
   TaggerList &getTaggers();
   TaggerList addTaggers(int count=1, int start=-1);
   void deleteTaggers(int count=-1, int start=0);
   McTrajectory &getMcTrajectory();
   McTrajectoryList &getMcTrajectorys();
   McTrajectoryList addMcTrajectorys(int count=1, int start=-1);
   void deleteMcTrajectorys(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<HitView>;
   friend class HDDM_ElementLink<HitView>;
 private:
   HitView(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   CentralDCLink m_centralDC_link;
   ForwardDCLink m_forwardDC_link;
   StartCntrLink m_startCntr_link;
   BarrelEMcalLink m_barrelEMcal_link;
   GapEMcalLink m_gapEMcal_link;
   CerenkovLink m_Cerenkov_link;
   RICHLink m_RICH_link;
   ForwardTOFLink m_forwardTOF_link;
   ForwardEMcalLink m_forwardEMcal_link;
   ComptonEMcalLink m_ComptonEMcal_link;
   GamsEMcalLink m_gamsEMcal_link;
   UpstreamEMvetoLink m_upstreamEMveto_link;
   TaggerLink m_tagger_link;
   McTrajectoryLink m_mcTrajectory_link;
};

typedef HDDM_ElementList<HitView> HitViewList;
typedef HDDM_ElementLink<HitView> HitViewLink;

class ErrorMatrix: public HDDM_Element {
 public:
   ~ErrorMatrix();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   float getFOM() const;
   int getNdof() const;
   int getCandidateid() const;
   float getChisq() const;
   int getId() const;
   int getTrackid() const;
   int getNcols() const;
   void setNcols(int Ncols);
   int getNrows() const;
   void setNrows(int Nrows);
   std::string getType() const;
   void setType(const std::string &type);
   std::string getVals() const;
   void setVals(const std::string &vals);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<ErrorMatrix>;
   friend class HDDM_ElementLink<ErrorMatrix>;
 private:
   ErrorMatrix(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_Ncols;
   int m_Nrows;
   std::string m_type;
   std::string m_vals;
};

typedef HDDM_ElementList<ErrorMatrix> ErrorMatrixList;
typedef HDDM_ElementLink<ErrorMatrix> ErrorMatrixLink;

class TrackingErrorMatrix: public HDDM_Element {
 public:
   ~TrackingErrorMatrix();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   float getFOM() const;
   int getNdof() const;
   int getCandidateid() const;
   float getChisq() const;
   int getId() const;
   int getTrackid() const;
   int getNcols() const;
   void setNcols(int Ncols);
   int getNrows() const;
   void setNrows(int Nrows);
   std::string getType() const;
   void setType(const std::string &type);
   std::string getVals() const;
   void setVals(const std::string &vals);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<TrackingErrorMatrix>;
   friend class HDDM_ElementLink<TrackingErrorMatrix>;
 private:
   TrackingErrorMatrix(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_Ncols;
   int m_Nrows;
   std::string m_type;
   std::string m_vals;
};

typedef HDDM_ElementList<TrackingErrorMatrix> TrackingErrorMatrixList;
typedef HDDM_ElementLink<TrackingErrorMatrix> TrackingErrorMatrixLink;

class Tracktimebased: public HDDM_Element {
 public:
   ~Tracktimebased();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   int getRunNo() const;
   float getFOM() const;
   void setFOM(float FOM);
   int getNdof() const;
   void setNdof(int Ndof);
   int getCandidateid() const;
   void setCandidateid(int candidateid);
   float getChisq() const;
   void setChisq(float chisq);
   int getId() const;
   void setId(int id);
   std::string getMaxOccurs() const;
   int getMinOccurs() const;
   int getTrackid() const;
   void setTrackid(int trackid);
   Momentum &getMomentum();
   MomentumList &getMomenta();
   MomentumList addMomenta(int count=1, int start=-1);
   void deleteMomenta(int count=-1, int start=0);
   Properties &getProperties();
   PropertiesList &getPropertiesList();
   PropertiesList addPropertiesList(int count=1, int start=-1);
   void deletePropertiesList(int count=-1, int start=0);
   Origin &getOrigin();
   OriginList &getOrigins();
   OriginList addOrigins(int count=1, int start=-1);
   void deleteOrigins(int count=-1, int start=0);
   ErrorMatrix &getErrorMatrix();
   ErrorMatrixList &getErrorMatrixs();
   ErrorMatrixList addErrorMatrixs(int count=1, int start=-1);
   void deleteErrorMatrixs(int count=-1, int start=0);
   TrackingErrorMatrix &getTrackingErrorMatrix();
   TrackingErrorMatrixList &getTrackingErrorMatrixs();
   TrackingErrorMatrixList addTrackingErrorMatrixs(int count=1, int start=-1);
   void deleteTrackingErrorMatrixs(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<Tracktimebased>;
   friend class HDDM_ElementLink<Tracktimebased>;
 private:
   Tracktimebased(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   float m_FOM;
   int m_Ndof;
   int m_candidateid;
   float m_chisq;
   int m_id;
   int m_trackid;
   MomentumLink m_momentum_link;
   PropertiesLink m_properties_link;
   OriginLink m_origin_link;
   ErrorMatrixLink m_errorMatrix_link;
   TrackingErrorMatrixLink m_TrackingErrorMatrix_link;
};

typedef HDDM_ElementList<Tracktimebased> TracktimebasedList;
typedef HDDM_ElementLink<Tracktimebased> TracktimebasedLink;

class ReconView: public HDDM_Element {
 public:
   ~ReconView();
   std::string getClass() const;
   std::string getXmlns() const;
   int getEventNo() const;
   std::string getMaxOccurs() const;
   int getRunNo() const;
   int getMinOccurs() const;
   float getVersion() const;
   Tracktimebased &getTracktimebased(int index=0);
   TracktimebasedList &getTracktimebaseds();
   TracktimebasedList addTracktimebaseds(int count=1, int start=-1);
   void deleteTracktimebaseds(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<ReconView>;
   friend class HDDM_ElementLink<ReconView>;
 private:
   ReconView(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   TracktimebasedList m_tracktimebased_list;
};

typedef HDDM_ElementList<ReconView> ReconViewList;
typedef HDDM_ElementLink<ReconView> ReconViewLink;

class PhysicsEvent: public HDDM_Element {
 public:
   ~PhysicsEvent();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   int getEventNo() const;
   void setEventNo(int eventNo);
   std::string getMaxOccurs() const;
   int getRunNo() const;
   void setRunNo(int runNo);
   Reaction &getReaction(int index=0);
   ReactionList &getReactions();
   ReactionList addReactions(int count=1, int start=-1);
   void deleteReactions(int count=-1, int start=0);
   HitView &getHitView();
   HitViewList &getHitViews();
   HitViewList addHitViews(int count=1, int start=-1);
   void deleteHitViews(int count=-1, int start=0);
   ReconView &getReconView();
   ReconViewList &getReconViews();
   ReconViewList addReconViews(int count=1, int start=-1);
   void deleteReconViews(int count=-1, int start=0);
   const void *getAttribute(const std::string &name) const;
   friend class HDDM_ElementList<PhysicsEvent>;
   friend class HDDM_ElementLink<PhysicsEvent>;
 private:
   PhysicsEvent(HDDM_Element *parent=0);
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   int m_eventNo;
   int m_runNo;
   ReactionList m_reaction_list;
   HitViewLink m_hitView_link;
   ReconViewLink m_reconView_link;
};

typedef HDDM_ElementList<PhysicsEvent> PhysicsEventList;
typedef HDDM_ElementLink<PhysicsEvent> PhysicsEventLink;

class HDDM: public HDDM_Element {
 public:
   HDDM();
   ~HDDM();
   std::string getClass() const;
   float getVersion() const;
   std::string getXmlns() const;
   CerenkovList getCerenkovs();
   ComptonEMcalList getComptonEMcals();
   RICHList getRICHs();
   TrackingErrorMatrixList getTrackingErrorMatrixs();
   BarrelEMcalList getBarrelEMcals();
   BcalCellList getBcalCells();
   BcalHitList getBcalHits();
   BcalIncidentParticleList getBcalIncidentParticles();
   BcalSiPMDownHitList getBcalSiPMDownHits();
   BcalSiPMSpectrumList getBcalSiPMSpectrums();
   BcalSiPMUpHitList getBcalSiPMUpHits();
   BcalTDCHitList getBcalTDCHits();
   BcalTruthShowerList getBcalTruthShowers();
   BcalfADCCellList getBcalfADCCells();
   BcalfADCDownHitList getBcalfADCDownHits();
   BcalfADCUpHitList getBcalfADCUpHits();
   BeamList getBeams();
   CcalBlockList getCcalBlocks();
   CcalHitList getCcalHits();
   CcalTruthHitList getCcalTruthHits();
   CcalTruthShowerList getCcalTruthShowers();
   CdcStrawList getCdcStraws();
   CdcStrawHitList getCdcStrawHits();
   CdcStrawTruthHitList getCdcStrawTruthHits();
   CdcTruthPointList getCdcTruthPoints();
   CentralDCList getCentralDCs();
   CereHitList getCereHits();
   CereSectionList getCereSections();
   CereTruthPointList getCereTruthPoints();
   ErrorMatrixList getErrorMatrixs();
   FcalBlockList getFcalBlocks();
   FcalHitList getFcalHits();
   FcalTruthHitList getFcalTruthHits();
   FcalTruthShowerList getFcalTruthShowers();
   FdcAnodeHitList getFdcAnodeHits();
   FdcAnodeTruthHitList getFdcAnodeTruthHits();
   FdcAnodeWireList getFdcAnodeWires();
   FdcCathodeHitList getFdcCathodeHits();
   FdcCathodeStripList getFdcCathodeStrips();
   FdcCathodeTruthHitList getFdcCathodeTruthHits();
   FdcChamberList getFdcChambers();
   FdcTruthPointList getFdcTruthPoints();
   ForwardDCList getForwardDCs();
   ForwardEMcalList getForwardEMcals();
   ForwardTOFList getForwardTOFs();
   FtofCounterList getFtofCounters();
   FtofMCHitList getFtofMCHits();
   FtofNorthHitList getFtofNorthHits();
   FtofNorthTruthHitList getFtofNorthTruthHits();
   FtofSouthHitList getFtofSouthHits();
   FtofSouthTruthHitList getFtofSouthTruthHits();
   FtofTruthPointList getFtofTruthPoints();
   GamsClustList getGamsClusts();
   GamsEMcalList getGamsEMcals();
   GapEMcalList getGapEMcals();
   GcalCellList getGcalCells();
   GcalHitList getGcalHits();
   GcalTruthShowerList getGcalTruthShowers();
   HitViewList getHitViews();
   McTrajectoryList getMcTrajectorys();
   McTrajectoryPointList getMcTrajectoryPoints();
   MicroChannelList getMicroChannels();
   MomentumList getMomenta();
   OriginList getOrigins();
   ProductList getProducts();
   PropertiesList getPropertiesList();
   RandomList getRandoms();
   ReactionList getReactions();
   ReconViewList getReconViews();
   RichHitList getRichHits();
   RichTruthPointList getRichTruthPoints();
   StartCntrList getStartCntrs();
   StcHitList getStcHits();
   StcPaddleList getStcPaddles();
   StcTruthHitList getStcTruthHits();
   StcTruthPointList getStcTruthPoints();
   TaggerList getTaggers();
   TaggerHitList getTaggerHits();
   TargetList getTargets();
   TracktimebasedList getTracktimebaseds();
   UpstreamEMvetoList getUpstreamEMvetos();
   UpvLeftHitList getUpvLeftHits();
   UpvPaddleList getUpvPaddles();
   UpvRightHitList getUpvRightHits();
   UpvTruthShowerList getUpvTruthShowers();
   VertexList getVertices();
   Geometry &getGeometry();
   GeometryList &getGeometrys();
   GeometryList addGeometrys(int count=1, int start=-1);
   void deleteGeometrys(int count=-1, int start=0);
   PhysicsEvent &getPhysicsEvent(int index=0);
   PhysicsEventList &getPhysicsEvents();
   PhysicsEventList addPhysicsEvents(int count=1, int start=-1);
   void deletePhysicsEvents(int count=-1, int start=0);
   void clear();
   friend class Cerenkov;
   friend class ComptonEMcal;
   friend class RICH;
   friend class TrackingErrorMatrix;
   friend class BarrelEMcal;
   friend class BcalCell;
   friend class BcalHit;
   friend class BcalIncidentParticle;
   friend class BcalSiPMDownHit;
   friend class BcalSiPMSpectrum;
   friend class BcalSiPMUpHit;
   friend class BcalTDCHit;
   friend class BcalTruthShower;
   friend class BcalfADCCell;
   friend class BcalfADCDownHit;
   friend class BcalfADCUpHit;
   friend class Beam;
   friend class CcalBlock;
   friend class CcalHit;
   friend class CcalTruthHit;
   friend class CcalTruthShower;
   friend class CdcStraw;
   friend class CdcStrawHit;
   friend class CdcStrawTruthHit;
   friend class CdcTruthPoint;
   friend class CentralDC;
   friend class CereHit;
   friend class CereSection;
   friend class CereTruthPoint;
   friend class ErrorMatrix;
   friend class FcalBlock;
   friend class FcalHit;
   friend class FcalTruthHit;
   friend class FcalTruthShower;
   friend class FdcAnodeHit;
   friend class FdcAnodeTruthHit;
   friend class FdcAnodeWire;
   friend class FdcCathodeHit;
   friend class FdcCathodeStrip;
   friend class FdcCathodeTruthHit;
   friend class FdcChamber;
   friend class FdcTruthPoint;
   friend class ForwardDC;
   friend class ForwardEMcal;
   friend class ForwardTOF;
   friend class FtofCounter;
   friend class FtofMCHit;
   friend class FtofNorthHit;
   friend class FtofNorthTruthHit;
   friend class FtofSouthHit;
   friend class FtofSouthTruthHit;
   friend class FtofTruthPoint;
   friend class GamsClust;
   friend class GamsEMcal;
   friend class GapEMcal;
   friend class GcalCell;
   friend class GcalHit;
   friend class GcalTruthShower;
   friend class Geometry;
   friend class HitView;
   friend class McTrajectory;
   friend class McTrajectoryPoint;
   friend class MicroChannel;
   friend class Momentum;
   friend class Origin;
   friend class PhysicsEvent;
   friend class Product;
   friend class Properties;
   friend class Random;
   friend class Reaction;
   friend class ReconView;
   friend class RichHit;
   friend class RichTruthPoint;
   friend class StartCntr;
   friend class StcHit;
   friend class StcPaddle;
   friend class StcTruthHit;
   friend class StcTruthPoint;
   friend class Tagger;
   friend class TaggerHit;
   friend class Target;
   friend class Tracktimebased;
   friend class UpstreamEMveto;
   friend class UpvLeftHit;
   friend class UpvPaddle;
   friend class UpvRightHit;
   friend class UpvTruthShower;
   friend class Vertex;
   static std::string DocumentString();
 private:
   void streamer(istream &istr);
   void streamer(ostream &ostr);
   std::list<Cerenkov*> m_Cerenkov_plist;
   std::list<ComptonEMcal*> m_ComptonEMcal_plist;
   std::list<RICH*> m_RICH_plist;
   std::list<TrackingErrorMatrix*> m_TrackingErrorMatrix_plist;
   std::list<BarrelEMcal*> m_barrelEMcal_plist;
   std::list<BcalCell*> m_bcalCell_plist;
   std::list<BcalHit*> m_bcalHit_plist;
   std::list<BcalIncidentParticle*> m_bcalIncidentParticle_plist;
   std::list<BcalSiPMDownHit*> m_bcalSiPMDownHit_plist;
   std::list<BcalSiPMSpectrum*> m_bcalSiPMSpectrum_plist;
   std::list<BcalSiPMUpHit*> m_bcalSiPMUpHit_plist;
   std::list<BcalTDCHit*> m_bcalTDCHit_plist;
   std::list<BcalTruthShower*> m_bcalTruthShower_plist;
   std::list<BcalfADCCell*> m_bcalfADCCell_plist;
   std::list<BcalfADCDownHit*> m_bcalfADCDownHit_plist;
   std::list<BcalfADCUpHit*> m_bcalfADCUpHit_plist;
   std::list<Beam*> m_beam_plist;
   std::list<CcalBlock*> m_ccalBlock_plist;
   std::list<CcalHit*> m_ccalHit_plist;
   std::list<CcalTruthHit*> m_ccalTruthHit_plist;
   std::list<CcalTruthShower*> m_ccalTruthShower_plist;
   std::list<CdcStraw*> m_cdcStraw_plist;
   std::list<CdcStrawHit*> m_cdcStrawHit_plist;
   std::list<CdcStrawTruthHit*> m_cdcStrawTruthHit_plist;
   std::list<CdcTruthPoint*> m_cdcTruthPoint_plist;
   std::list<CentralDC*> m_centralDC_plist;
   std::list<CereHit*> m_cereHit_plist;
   std::list<CereSection*> m_cereSection_plist;
   std::list<CereTruthPoint*> m_cereTruthPoint_plist;
   std::list<ErrorMatrix*> m_errorMatrix_plist;
   std::list<FcalBlock*> m_fcalBlock_plist;
   std::list<FcalHit*> m_fcalHit_plist;
   std::list<FcalTruthHit*> m_fcalTruthHit_plist;
   std::list<FcalTruthShower*> m_fcalTruthShower_plist;
   std::list<FdcAnodeHit*> m_fdcAnodeHit_plist;
   std::list<FdcAnodeTruthHit*> m_fdcAnodeTruthHit_plist;
   std::list<FdcAnodeWire*> m_fdcAnodeWire_plist;
   std::list<FdcCathodeHit*> m_fdcCathodeHit_plist;
   std::list<FdcCathodeStrip*> m_fdcCathodeStrip_plist;
   std::list<FdcCathodeTruthHit*> m_fdcCathodeTruthHit_plist;
   std::list<FdcChamber*> m_fdcChamber_plist;
   std::list<FdcTruthPoint*> m_fdcTruthPoint_plist;
   std::list<ForwardDC*> m_forwardDC_plist;
   std::list<ForwardEMcal*> m_forwardEMcal_plist;
   std::list<ForwardTOF*> m_forwardTOF_plist;
   std::list<FtofCounter*> m_ftofCounter_plist;
   std::list<FtofMCHit*> m_ftofMCHit_plist;
   std::list<FtofNorthHit*> m_ftofNorthHit_plist;
   std::list<FtofNorthTruthHit*> m_ftofNorthTruthHit_plist;
   std::list<FtofSouthHit*> m_ftofSouthHit_plist;
   std::list<FtofSouthTruthHit*> m_ftofSouthTruthHit_plist;
   std::list<FtofTruthPoint*> m_ftofTruthPoint_plist;
   std::list<GamsClust*> m_gamsClust_plist;
   std::list<GamsEMcal*> m_gamsEMcal_plist;
   std::list<GapEMcal*> m_gapEMcal_plist;
   std::list<GcalCell*> m_gcalCell_plist;
   std::list<GcalHit*> m_gcalHit_plist;
   std::list<GcalTruthShower*> m_gcalTruthShower_plist;
   std::list<Geometry*> m_geometry_plist;
   std::list<HitView*> m_hitView_plist;
   std::list<McTrajectory*> m_mcTrajectory_plist;
   std::list<McTrajectoryPoint*> m_mcTrajectoryPoint_plist;
   std::list<MicroChannel*> m_microChannel_plist;
   std::list<Momentum*> m_momentum_plist;
   std::list<Origin*> m_origin_plist;
   std::list<PhysicsEvent*> m_physicsEvent_plist;
   std::list<Product*> m_product_plist;
   std::list<Properties*> m_properties_plist;
   std::list<Random*> m_random_plist;
   std::list<Reaction*> m_reaction_plist;
   std::list<ReconView*> m_reconView_plist;
   std::list<RichHit*> m_richHit_plist;
   std::list<RichTruthPoint*> m_richTruthPoint_plist;
   std::list<StartCntr*> m_startCntr_plist;
   std::list<StcHit*> m_stcHit_plist;
   std::list<StcPaddle*> m_stcPaddle_plist;
   std::list<StcTruthHit*> m_stcTruthHit_plist;
   std::list<StcTruthPoint*> m_stcTruthPoint_plist;
   std::list<Tagger*> m_tagger_plist;
   std::list<TaggerHit*> m_taggerHit_plist;
   std::list<Target*> m_target_plist;
   std::list<Tracktimebased*> m_tracktimebased_plist;
   std::list<UpstreamEMveto*> m_upstreamEMveto_plist;
   std::list<UpvLeftHit*> m_upvLeftHit_plist;
   std::list<UpvPaddle*> m_upvPaddle_plist;
   std::list<UpvRightHit*> m_upvRightHit_plist;
   std::list<UpvTruthShower*> m_upvTruthShower_plist;
   std::list<Vertex*> m_vertex_plist;
   GeometryLink m_geometry_link;
   PhysicsEventList m_physicsEvent_list;
};

inline void istream::skip(int count) {
   m_events_to_skip = count;
}

inline int istream::getCompression() const {
   return m_status_bits & k_bits_compression;
}

inline int ostream::getCompression() const {
   return m_status_bits & k_bits_compression;
}

inline istream &istream::operator>>(streamable &object) {
   if (m_sequencing) {
      m_codon->m_target.push_back(&object);
   }
   else {
      int size;
      *m_xstr >> size;
      if (size > 0) {
         std::streampos start = m_sstr.tellg();
         sequencer(object);
         m_sstr.seekg(start+(std::streamoff)size);
      }
   }
   return *this;
}

inline void istream::sequencer(streamable &object) {
   m_sequencing = 1;
   m_codon->m_target.clear();
   object.streamer(*this);
   if (m_sequencing) {
      m_sequencing = 0;
      codon &gene = *m_codon;
      streamable null_streamable;
      gene.m_target.push_front(&null_streamable);
      chromosome::iterator iter;
      for (iter = gene.m_sequence.begin();
           iter != gene.m_sequence.end();
           ++iter)
      {
         m_codon = &(*iter);
         *this >> *gene.m_target[iter->m_order];
      }
      m_codon = &gene;
   }
}

inline ostream &ostream::operator<<(HDDM &record) {
   m_sstr.str("");
   *this << (streamable&)record;
   m_ostr << m_sstr.str();
   return *this;
}

inline ostream &ostream::operator<<(streamable &object) {
   *m_xstr << 0;
   std::streampos start = m_sstr.tellp();
   object.streamer(*this);
   std::streampos end = m_sstr.tellp();
   m_sstr.seekp(start-std::streamoff(4));
   *m_xstr << (int)(end-start);
   m_sstr.seekp(end);
   return *this;
}

inline Geometry::Geometry(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_md5reconstruction(""),
   m_md5simulation(""),
   m_md5smear("")
{}

inline Geometry::~Geometry() {}

inline std::string Geometry::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Geometry::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Geometry::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Geometry::getMaxOccurs() const {
   return 1;
}

inline std::string Geometry::getMd5reconstruction() const {
   return m_md5reconstruction;
}

inline void Geometry::setMd5reconstruction(const std::string &md5reconstruction) {
   m_md5reconstruction = md5reconstruction;
}

inline std::string Geometry::getMd5simulation() const {
   return m_md5simulation;
}

inline void Geometry::setMd5simulation(const std::string &md5simulation) {
   m_md5simulation = md5simulation;
}

inline std::string Geometry::getMd5smear() const {
   return m_md5smear;
}

inline void Geometry::setMd5smear(const std::string &md5smear) {
   m_md5smear = md5smear;
}

inline int Geometry::getMinOccurs() const {
   return 0;
}

inline const void *Geometry::getAttribute(const std::string &name) const {
   return (name == "md5reconstruction")? &m_md5reconstruction:
          (name == "md5simulation")? &m_md5simulation:
          (name == "md5smear")? &m_md5smear:
          m_parent->getAttribute(name);
}

inline Momentum::Momentum(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_px(0),
   m_py(0),
   m_pz(0)
{}

inline Momentum::~Momentum() {}

inline std::string Momentum::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Momentum::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Momentum::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Momentum::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string Momentum::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int Momentum::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int Momentum::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline float Momentum::getFOM() const {
   return *(float*)m_parent->getAttribute("FOM");
}

inline int Momentum::getNdof() const {
   return *(int*)m_parent->getAttribute("Ndof");
}

inline int Momentum::getCandidateid() const {
   return *(int*)m_parent->getAttribute("candidateid");
}

inline float Momentum::getChisq() const {
   return *(float*)m_parent->getAttribute("chisq");
}

inline int Momentum::getId() const {
   return *(int*)m_parent->getAttribute("id");
}

inline int Momentum::getTrackid() const {
   return *(int*)m_parent->getAttribute("trackid");
}

inline int Momentum::getType() const {
   return *(int*)m_parent->getAttribute("type");
}

inline float Momentum::getWeight() const {
   return *(float*)m_parent->getAttribute("weight");
}

inline int Momentum::getDecayVertex() const {
   return *(int*)m_parent->getAttribute("decayVertex");
}

inline int Momentum::getMech() const {
   return *(int*)m_parent->getAttribute("mech");
}

inline int Momentum::getParentid() const {
   return *(int*)m_parent->getAttribute("parentid");
}

inline int Momentum::getPdgtype() const {
   return *(int*)m_parent->getAttribute("pdgtype");
}

inline float Momentum::getE() const {
   return m_E;
}

inline void Momentum::setE(float E) {
   m_E = E;
}

inline float Momentum::getPx() const {
   return m_px;
}

inline void Momentum::setPx(float px) {
   m_px = px;
}

inline float Momentum::getPy() const {
   return m_py;
}

inline void Momentum::setPy(float py) {
   m_py = py;
}

inline float Momentum::getPz() const {
   return m_pz;
}

inline void Momentum::setPz(float pz) {
   m_pz = pz;
}

inline const void *Momentum::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          m_parent->getAttribute(name);
}

inline Properties::Properties(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_charge(0),
   m_mass(0)
{}

inline Properties::~Properties() {}

inline std::string Properties::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Properties::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Properties::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Properties::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string Properties::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int Properties::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int Properties::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline float Properties::getFOM() const {
   return *(float*)m_parent->getAttribute("FOM");
}

inline int Properties::getNdof() const {
   return *(int*)m_parent->getAttribute("Ndof");
}

inline int Properties::getCandidateid() const {
   return *(int*)m_parent->getAttribute("candidateid");
}

inline float Properties::getChisq() const {
   return *(float*)m_parent->getAttribute("chisq");
}

inline int Properties::getId() const {
   return *(int*)m_parent->getAttribute("id");
}

inline int Properties::getTrackid() const {
   return *(int*)m_parent->getAttribute("trackid");
}

inline int Properties::getType() const {
   return *(int*)m_parent->getAttribute("type");
}

inline float Properties::getWeight() const {
   return *(float*)m_parent->getAttribute("weight");
}

inline int Properties::getDecayVertex() const {
   return *(int*)m_parent->getAttribute("decayVertex");
}

inline int Properties::getMech() const {
   return *(int*)m_parent->getAttribute("mech");
}

inline int Properties::getParentid() const {
   return *(int*)m_parent->getAttribute("parentid");
}

inline int Properties::getPdgtype() const {
   return *(int*)m_parent->getAttribute("pdgtype");
}

inline int Properties::getCharge() const {
   return m_charge;
}

inline void Properties::setCharge(int charge) {
   m_charge = charge;
}

inline float Properties::getMass() const {
   return m_mass;
}

inline void Properties::setMass(float mass) {
   m_mass = mass;
}

inline const void *Properties::getAttribute(const std::string &name) const {
   return (name == "charge")? &m_charge:
          (name == "mass")? &m_mass:
          m_parent->getAttribute(name);
}

inline Beam::Beam(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_type(0),
   m_momentum_link(&m_host->m_momentum_plist,
               m_host->m_momentum_plist.end(),
               m_host->m_momentum_plist.end(),
               this),
   m_properties_link(&m_host->m_properties_plist,
               m_host->m_properties_plist.end(),
               m_host->m_properties_plist.end(),
               this)
{}

inline Beam::~Beam() {
   deleteMomenta();
   deletePropertiesList();
}

inline std::string Beam::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Beam::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Beam::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Beam::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string Beam::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int Beam::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float Beam::getWeight() const {
   return *(float*)m_parent->getAttribute("weight");
}

inline int Beam::getMinOccurs() const {
   return 0;
}

inline Particle_t Beam::getType() const {
   return (Particle_t)m_type;
}

inline void Beam::setType(Particle_t type) {
   m_type = type;
}

inline const void *Beam::getAttribute(const std::string &name) const {
   return (name == "type")? &m_type:
          m_parent->getAttribute(name);
}

inline Momentum &Beam::getMomentum() {
   return m_momentum_link.front();
}

inline MomentumList &Beam::getMomenta() {
   return m_momentum_link;
}

inline MomentumList Beam::addMomenta(int count, int start) {
   return m_momentum_link.add(count,start);
}

inline void Beam::deleteMomenta(int count, int start) {
   m_momentum_link.del(count,start);
}

inline Properties &Beam::getProperties() {
   return m_properties_link.front();
}

inline PropertiesList &Beam::getPropertiesList() {
   return m_properties_link;
}

inline PropertiesList Beam::addPropertiesList(int count, int start) {
   return m_properties_link.add(count,start);
}

inline void Beam::deletePropertiesList(int count, int start) {
   m_properties_link.del(count,start);
}

inline Target::Target(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_type(0),
   m_momentum_link(&m_host->m_momentum_plist,
               m_host->m_momentum_plist.end(),
               m_host->m_momentum_plist.end(),
               this),
   m_properties_link(&m_host->m_properties_plist,
               m_host->m_properties_plist.end(),
               m_host->m_properties_plist.end(),
               this)
{}

inline Target::~Target() {
   deleteMomenta();
   deletePropertiesList();
}

inline std::string Target::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Target::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Target::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Target::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string Target::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int Target::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float Target::getWeight() const {
   return *(float*)m_parent->getAttribute("weight");
}

inline int Target::getMinOccurs() const {
   return 0;
}

inline Particle_t Target::getType() const {
   return (Particle_t)m_type;
}

inline void Target::setType(Particle_t type) {
   m_type = type;
}

inline const void *Target::getAttribute(const std::string &name) const {
   return (name == "type")? &m_type:
          m_parent->getAttribute(name);
}

inline Momentum &Target::getMomentum() {
   return m_momentum_link.front();
}

inline MomentumList &Target::getMomenta() {
   return m_momentum_link;
}

inline MomentumList Target::addMomenta(int count, int start) {
   return m_momentum_link.add(count,start);
}

inline void Target::deleteMomenta(int count, int start) {
   m_momentum_link.del(count,start);
}

inline Properties &Target::getProperties() {
   return m_properties_link.front();
}

inline PropertiesList &Target::getPropertiesList() {
   return m_properties_link;
}

inline PropertiesList Target::addPropertiesList(int count, int start) {
   return m_properties_link.add(count,start);
}

inline void Target::deletePropertiesList(int count, int start) {
   m_properties_link.del(count,start);
}

inline Product::Product(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_decayVertex(0),
   m_id(0),
   m_mech(0),
   m_parentid(0),
   m_pdgtype(0),
   m_type(0),
   m_momentum_link(&m_host->m_momentum_plist,
               m_host->m_momentum_plist.end(),
               m_host->m_momentum_plist.end(),
               this),
   m_properties_link(&m_host->m_properties_plist,
               m_host->m_properties_plist.end(),
               m_host->m_properties_plist.end(),
               this)
{}

inline Product::~Product() {
   deleteMomenta();
   deletePropertiesList();
}

inline std::string Product::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Product::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Product::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Product::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int Product::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int Product::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline float Product::getWeight() const {
   return *(float*)m_parent->getAttribute("weight");
}

inline int Product::getDecayVertex() const {
   return m_decayVertex;
}

inline void Product::setDecayVertex(int decayVertex) {
   m_decayVertex = decayVertex;
}

inline int Product::getId() const {
   return m_id;
}

inline void Product::setId(int id) {
   m_id = id;
}

inline std::string Product::getMaxOccurs() const {
   return "unbounded";
}

inline int Product::getMech() const {
   return m_mech;
}

inline void Product::setMech(int mech) {
   m_mech = mech;
}

inline int Product::getParentid() const {
   return m_parentid;
}

inline void Product::setParentid(int parentid) {
   m_parentid = parentid;
}

inline int Product::getPdgtype() const {
   return m_pdgtype;
}

inline void Product::setPdgtype(int pdgtype) {
   m_pdgtype = pdgtype;
}

inline Particle_t Product::getType() const {
   return (Particle_t)m_type;
}

inline void Product::setType(Particle_t type) {
   m_type = type;
}

inline const void *Product::getAttribute(const std::string &name) const {
   return (name == "decayVertex")? &m_decayVertex:
          (name == "id")? &m_id:
          (name == "mech")? &m_mech:
          (name == "parentid")? &m_parentid:
          (name == "pdgtype")? &m_pdgtype:
          (name == "type")? &m_type:
          m_parent->getAttribute(name);
}

inline Momentum &Product::getMomentum() {
   return m_momentum_link.front();
}

inline MomentumList &Product::getMomenta() {
   return m_momentum_link;
}

inline MomentumList Product::addMomenta(int count, int start) {
   return m_momentum_link.add(count,start);
}

inline void Product::deleteMomenta(int count, int start) {
   m_momentum_link.del(count,start);
}

inline Properties &Product::getProperties() {
   return m_properties_link.front();
}

inline PropertiesList &Product::getPropertiesList() {
   return m_properties_link;
}

inline PropertiesList Product::addPropertiesList(int count, int start) {
   return m_properties_link.add(count,start);
}

inline void Product::deletePropertiesList(int count, int start) {
   m_properties_link.del(count,start);
}

inline Origin::Origin(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_t(0),
   m_vx(0),
   m_vy(0),
   m_vz(0)
{}

inline Origin::~Origin() {}

inline std::string Origin::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Origin::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Origin::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Origin::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string Origin::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int Origin::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int Origin::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline float Origin::getFOM() const {
   return *(float*)m_parent->getAttribute("FOM");
}

inline int Origin::getNdof() const {
   return *(int*)m_parent->getAttribute("Ndof");
}

inline int Origin::getCandidateid() const {
   return *(int*)m_parent->getAttribute("candidateid");
}

inline float Origin::getChisq() const {
   return *(float*)m_parent->getAttribute("chisq");
}

inline int Origin::getId() const {
   return *(int*)m_parent->getAttribute("id");
}

inline int Origin::getTrackid() const {
   return *(int*)m_parent->getAttribute("trackid");
}

inline int Origin::getType() const {
   return *(int*)m_parent->getAttribute("type");
}

inline float Origin::getWeight() const {
   return *(float*)m_parent->getAttribute("weight");
}

inline float Origin::getT() const {
   return m_t;
}

inline void Origin::setT(float t) {
   m_t = t;
}

inline float Origin::getVx() const {
   return m_vx;
}

inline void Origin::setVx(float vx) {
   m_vx = vx;
}

inline float Origin::getVy() const {
   return m_vy;
}

inline void Origin::setVy(float vy) {
   m_vy = vy;
}

inline float Origin::getVz() const {
   return m_vz;
}

inline void Origin::setVz(float vz) {
   m_vz = vz;
}

inline const void *Origin::getAttribute(const std::string &name) const {
   return (name == "t")? &m_t:
          (name == "vx")? &m_vx:
          (name == "vy")? &m_vy:
          (name == "vz")? &m_vz:
          m_parent->getAttribute(name);
}

inline Vertex::Vertex(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_product_list(&m_host->m_product_plist,
               m_host->m_product_plist.end(),
               m_host->m_product_plist.end(),
               this),
   m_origin_link(&m_host->m_origin_plist,
               m_host->m_origin_plist.end(),
               m_host->m_origin_plist.end(),
               this)
{}

inline Vertex::~Vertex() {
   deleteProducts();
   deleteOrigins();
}

inline std::string Vertex::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Vertex::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Vertex::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Vertex::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int Vertex::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int Vertex::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int Vertex::getType() const {
   return *(int*)m_parent->getAttribute("type");
}

inline float Vertex::getWeight() const {
   return *(float*)m_parent->getAttribute("weight");
}

inline std::string Vertex::getMaxOccurs() const {
   return "unbounded";
}

inline const void *Vertex::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline Product &Vertex::getProduct(int index) {
   return m_product_list(index);
}

inline ProductList &Vertex::getProducts() {
   return m_product_list;
}

inline ProductList Vertex::addProducts(int count, int start) {
   return m_product_list.add(count,start);
}

inline void Vertex::deleteProducts(int count, int start) {
   m_product_list.del(count,start);
}

inline Origin &Vertex::getOrigin() {
   return m_origin_link.front();
}

inline OriginList &Vertex::getOrigins() {
   return m_origin_link;
}

inline OriginList Vertex::addOrigins(int count, int start) {
   return m_origin_link.add(count,start);
}

inline void Vertex::deleteOrigins(int count, int start) {
   m_origin_link.del(count,start);
}

inline Random::Random(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_seed1(0),
   m_seed2(0),
   m_seed_mcsmear1(0),
   m_seed_mcsmear2(0),
   m_seed_mcsmear3(0)
{}

inline Random::~Random() {}

inline std::string Random::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Random::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Random::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Random::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int Random::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int Random::getType() const {
   return *(int*)m_parent->getAttribute("type");
}

inline float Random::getWeight() const {
   return *(float*)m_parent->getAttribute("weight");
}

inline int Random::getMaxOccurs() const {
   return 1;
}

inline int Random::getMinOccurs() const {
   return 0;
}

inline int Random::getSeed1() const {
   return m_seed1;
}

inline void Random::setSeed1(int seed1) {
   m_seed1 = seed1;
}

inline int Random::getSeed2() const {
   return m_seed2;
}

inline void Random::setSeed2(int seed2) {
   m_seed2 = seed2;
}

inline int Random::getSeed_mcsmear1() const {
   return m_seed_mcsmear1;
}

inline void Random::setSeed_mcsmear1(int seed_mcsmear1) {
   m_seed_mcsmear1 = seed_mcsmear1;
}

inline int Random::getSeed_mcsmear2() const {
   return m_seed_mcsmear2;
}

inline void Random::setSeed_mcsmear2(int seed_mcsmear2) {
   m_seed_mcsmear2 = seed_mcsmear2;
}

inline int Random::getSeed_mcsmear3() const {
   return m_seed_mcsmear3;
}

inline void Random::setSeed_mcsmear3(int seed_mcsmear3) {
   m_seed_mcsmear3 = seed_mcsmear3;
}

inline const void *Random::getAttribute(const std::string &name) const {
   return (name == "seed1")? &m_seed1:
          (name == "seed2")? &m_seed2:
          (name == "seed_mcsmear1")? &m_seed_mcsmear1:
          (name == "seed_mcsmear2")? &m_seed_mcsmear2:
          (name == "seed_mcsmear3")? &m_seed_mcsmear3:
          m_parent->getAttribute(name);
}

inline Reaction::Reaction(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_type(0),
   m_weight(0),
   m_beam_link(&m_host->m_beam_plist,
               m_host->m_beam_plist.end(),
               m_host->m_beam_plist.end(),
               this),
   m_target_link(&m_host->m_target_plist,
               m_host->m_target_plist.end(),
               m_host->m_target_plist.end(),
               this),
   m_vertex_list(&m_host->m_vertex_plist,
               m_host->m_vertex_plist.end(),
               m_host->m_vertex_plist.end(),
               this),
   m_random_link(&m_host->m_random_plist,
               m_host->m_random_plist.end(),
               m_host->m_random_plist.end(),
               this)
{}

inline Reaction::~Reaction() {
   deleteBeams();
   deleteTargets();
   deleteVertices();
   deleteRandoms();
}

inline std::string Reaction::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Reaction::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Reaction::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Reaction::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int Reaction::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline std::string Reaction::getMaxOccurs() const {
   return "unbounded";
}

inline int Reaction::getMinOccurs() const {
   return 0;
}

inline int Reaction::getType() const {
   return m_type;
}

inline void Reaction::setType(int type) {
   m_type = type;
}

inline float Reaction::getWeight() const {
   return m_weight;
}

inline void Reaction::setWeight(float weight) {
   m_weight = weight;
}

inline const void *Reaction::getAttribute(const std::string &name) const {
   return (name == "type")? &m_type:
          (name == "weight")? &m_weight:
          m_parent->getAttribute(name);
}

inline Beam &Reaction::getBeam() {
   return m_beam_link.front();
}

inline BeamList &Reaction::getBeams() {
   return m_beam_link;
}

inline BeamList Reaction::addBeams(int count, int start) {
   return m_beam_link.add(count,start);
}

inline void Reaction::deleteBeams(int count, int start) {
   m_beam_link.del(count,start);
}

inline Target &Reaction::getTarget() {
   return m_target_link.front();
}

inline TargetList &Reaction::getTargets() {
   return m_target_link;
}

inline TargetList Reaction::addTargets(int count, int start) {
   return m_target_link.add(count,start);
}

inline void Reaction::deleteTargets(int count, int start) {
   m_target_link.del(count,start);
}

inline Vertex &Reaction::getVertex(int index) {
   return m_vertex_list(index);
}

inline VertexList &Reaction::getVertices() {
   return m_vertex_list;
}

inline VertexList Reaction::addVertices(int count, int start) {
   return m_vertex_list.add(count,start);
}

inline void Reaction::deleteVertices(int count, int start) {
   m_vertex_list.del(count,start);
}

inline Random &Reaction::getRandom() {
   return m_random_link.front();
}

inline RandomList &Reaction::getRandoms() {
   return m_random_link;
}

inline RandomList Reaction::addRandoms(int count, int start) {
   return m_random_link.add(count,start);
}

inline void Reaction::deleteRandoms(int count, int start) {
   m_random_link.del(count,start);
}

inline CdcStrawHit::CdcStrawHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_d(0),
   m_itrack(0),
   m_ptype(0),
   m_q(0),
   m_t(0)
{}

inline CdcStrawHit::~CdcStrawHit() {}

inline std::string CdcStrawHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CdcStrawHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CdcStrawHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CdcStrawHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CdcStrawHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int CdcStrawHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int CdcStrawHit::getRing() const {
   return *(int*)m_parent->getAttribute("ring");
}

inline int CdcStrawHit::getStraw() const {
   return *(int*)m_parent->getAttribute("straw");
}

inline float CdcStrawHit::getD() const {
   return m_d;
}

inline void CdcStrawHit::setD(float d) {
   m_d = d;
}

inline int CdcStrawHit::getItrack() const {
   return m_itrack;
}

inline void CdcStrawHit::setItrack(int itrack) {
   m_itrack = itrack;
}

inline std::string CdcStrawHit::getMaxOccurs() const {
   return "unbounded";
}

inline int CdcStrawHit::getPtype() const {
   return m_ptype;
}

inline void CdcStrawHit::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float CdcStrawHit::getQ() const {
   return m_q;
}

inline void CdcStrawHit::setQ(float q) {
   m_q = q;
}

inline float CdcStrawHit::getT() const {
   return m_t;
}

inline void CdcStrawHit::setT(float t) {
   m_t = t;
}

inline const void *CdcStrawHit::getAttribute(const std::string &name) const {
   return (name == "d")? &m_d:
          (name == "itrack")? &m_itrack:
          (name == "ptype")? &m_ptype:
          (name == "q")? &m_q:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline CdcStrawTruthHit::CdcStrawTruthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_d(0),
   m_itrack(0),
   m_ptype(0),
   m_q(0),
   m_t(0)
{}

inline CdcStrawTruthHit::~CdcStrawTruthHit() {}

inline std::string CdcStrawTruthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CdcStrawTruthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CdcStrawTruthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CdcStrawTruthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CdcStrawTruthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int CdcStrawTruthHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int CdcStrawTruthHit::getRing() const {
   return *(int*)m_parent->getAttribute("ring");
}

inline int CdcStrawTruthHit::getStraw() const {
   return *(int*)m_parent->getAttribute("straw");
}

inline float CdcStrawTruthHit::getD() const {
   return m_d;
}

inline void CdcStrawTruthHit::setD(float d) {
   m_d = d;
}

inline int CdcStrawTruthHit::getItrack() const {
   return m_itrack;
}

inline void CdcStrawTruthHit::setItrack(int itrack) {
   m_itrack = itrack;
}

inline std::string CdcStrawTruthHit::getMaxOccurs() const {
   return "unbounded";
}

inline int CdcStrawTruthHit::getPtype() const {
   return m_ptype;
}

inline void CdcStrawTruthHit::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float CdcStrawTruthHit::getQ() const {
   return m_q;
}

inline void CdcStrawTruthHit::setQ(float q) {
   m_q = q;
}

inline float CdcStrawTruthHit::getT() const {
   return m_t;
}

inline void CdcStrawTruthHit::setT(float t) {
   m_t = t;
}

inline const void *CdcStrawTruthHit::getAttribute(const std::string &name) const {
   return (name == "d")? &m_d:
          (name == "itrack")? &m_itrack:
          (name == "ptype")? &m_ptype:
          (name == "q")? &m_q:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline CdcStraw::CdcStraw(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_ring(0),
   m_straw(0),
   m_cdcStrawHit_list(&m_host->m_cdcStrawHit_plist,
               m_host->m_cdcStrawHit_plist.end(),
               m_host->m_cdcStrawHit_plist.end(),
               this),
   m_cdcStrawTruthHit_list(&m_host->m_cdcStrawTruthHit_plist,
               m_host->m_cdcStrawTruthHit_plist.end(),
               m_host->m_cdcStrawTruthHit_plist.end(),
               this)
{}

inline CdcStraw::~CdcStraw() {
   deleteCdcStrawHits();
   deleteCdcStrawTruthHits();
}

inline std::string CdcStraw::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CdcStraw::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CdcStraw::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CdcStraw::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CdcStraw::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline std::string CdcStraw::getMaxOccurs() const {
   return "unbounded";
}

inline int CdcStraw::getMinOccurs() const {
   return 0;
}

inline int CdcStraw::getRing() const {
   return m_ring;
}

inline void CdcStraw::setRing(int ring) {
   m_ring = ring;
}

inline int CdcStraw::getStraw() const {
   return m_straw;
}

inline void CdcStraw::setStraw(int straw) {
   m_straw = straw;
}

inline const void *CdcStraw::getAttribute(const std::string &name) const {
   return (name == "ring")? &m_ring:
          (name == "straw")? &m_straw:
          m_parent->getAttribute(name);
}

inline CdcStrawHit &CdcStraw::getCdcStrawHit(int index) {
   return m_cdcStrawHit_list(index);
}

inline CdcStrawHitList &CdcStraw::getCdcStrawHits() {
   return m_cdcStrawHit_list;
}

inline CdcStrawHitList CdcStraw::addCdcStrawHits(int count, int start) {
   return m_cdcStrawHit_list.add(count,start);
}

inline void CdcStraw::deleteCdcStrawHits(int count, int start) {
   m_cdcStrawHit_list.del(count,start);
}

inline CdcStrawTruthHit &CdcStraw::getCdcStrawTruthHit(int index) {
   return m_cdcStrawTruthHit_list(index);
}

inline CdcStrawTruthHitList &CdcStraw::getCdcStrawTruthHits() {
   return m_cdcStrawTruthHit_list;
}

inline CdcStrawTruthHitList CdcStraw::addCdcStrawTruthHits(int count, int start) {
   return m_cdcStrawTruthHit_list.add(count,start);
}

inline void CdcStraw::deleteCdcStrawTruthHits(int count, int start) {
   m_cdcStrawTruthHit_list.del(count,start);
}

inline CdcTruthPoint::CdcTruthPoint(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_dEdx(0),
   m_dradius(0),
   m_phi(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_r(0),
   m_t(0),
   m_track(0),
   m_z(0)
{}

inline CdcTruthPoint::~CdcTruthPoint() {}

inline std::string CdcTruthPoint::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CdcTruthPoint::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CdcTruthPoint::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CdcTruthPoint::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CdcTruthPoint::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float CdcTruthPoint::getDEdx() const {
   return m_dEdx;
}

inline void CdcTruthPoint::setDEdx(float dEdx) {
   m_dEdx = dEdx;
}

inline float CdcTruthPoint::getDradius() const {
   return m_dradius;
}

inline void CdcTruthPoint::setDradius(float dradius) {
   m_dradius = dradius;
}

inline std::string CdcTruthPoint::getMaxOccurs() const {
   return "unbounded";
}

inline int CdcTruthPoint::getMinOccurs() const {
   return 0;
}

inline float CdcTruthPoint::getPhi() const {
   return m_phi;
}

inline void CdcTruthPoint::setPhi(float phi) {
   m_phi = phi;
}

inline bool CdcTruthPoint::getPrimary() const {
   return m_primary;
}

inline void CdcTruthPoint::setPrimary(bool primary) {
   m_primary = primary;
}

inline int CdcTruthPoint::getPtype() const {
   return m_ptype;
}

inline void CdcTruthPoint::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float CdcTruthPoint::getPx() const {
   return m_px;
}

inline void CdcTruthPoint::setPx(float px) {
   m_px = px;
}

inline float CdcTruthPoint::getPy() const {
   return m_py;
}

inline void CdcTruthPoint::setPy(float py) {
   m_py = py;
}

inline float CdcTruthPoint::getPz() const {
   return m_pz;
}

inline void CdcTruthPoint::setPz(float pz) {
   m_pz = pz;
}

inline float CdcTruthPoint::getR() const {
   return m_r;
}

inline void CdcTruthPoint::setR(float r) {
   m_r = r;
}

inline float CdcTruthPoint::getT() const {
   return m_t;
}

inline void CdcTruthPoint::setT(float t) {
   m_t = t;
}

inline int CdcTruthPoint::getTrack() const {
   return m_track;
}

inline void CdcTruthPoint::setTrack(int track) {
   m_track = track;
}

inline float CdcTruthPoint::getZ() const {
   return m_z;
}

inline void CdcTruthPoint::setZ(float z) {
   m_z = z;
}

inline const void *CdcTruthPoint::getAttribute(const std::string &name) const {
   return (name == "dEdx")? &m_dEdx:
          (name == "dradius")? &m_dradius:
          (name == "phi")? &m_phi:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "r")? &m_r:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline CentralDC::CentralDC(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_cdcStraw_list(&m_host->m_cdcStraw_plist,
               m_host->m_cdcStraw_plist.end(),
               m_host->m_cdcStraw_plist.end(),
               this),
   m_cdcTruthPoint_list(&m_host->m_cdcTruthPoint_plist,
               m_host->m_cdcTruthPoint_plist.end(),
               m_host->m_cdcTruthPoint_plist.end(),
               this)
{}

inline CentralDC::~CentralDC() {
   deleteCdcStraws();
   deleteCdcTruthPoints();
}

inline std::string CentralDC::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CentralDC::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CentralDC::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CentralDC::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string CentralDC::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int CentralDC::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int CentralDC::getMinOccurs() const {
   return 0;
}

inline const void *CentralDC::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline CdcStraw &CentralDC::getCdcStraw(int index) {
   return m_cdcStraw_list(index);
}

inline CdcStrawList &CentralDC::getCdcStraws() {
   return m_cdcStraw_list;
}

inline CdcStrawList CentralDC::addCdcStraws(int count, int start) {
   return m_cdcStraw_list.add(count,start);
}

inline void CentralDC::deleteCdcStraws(int count, int start) {
   m_cdcStraw_list.del(count,start);
}

inline CdcTruthPoint &CentralDC::getCdcTruthPoint(int index) {
   return m_cdcTruthPoint_list(index);
}

inline CdcTruthPointList &CentralDC::getCdcTruthPoints() {
   return m_cdcTruthPoint_list;
}

inline CdcTruthPointList CentralDC::addCdcTruthPoints(int count, int start) {
   return m_cdcTruthPoint_list.add(count,start);
}

inline void CentralDC::deleteCdcTruthPoints(int count, int start) {
   m_cdcTruthPoint_list.del(count,start);
}

inline FdcAnodeHit::FdcAnodeHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_d(0),
   m_dE(0),
   m_itrack(0),
   m_ptype(0),
   m_t(0)
{}

inline FdcAnodeHit::~FdcAnodeHit() {}

inline std::string FdcAnodeHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FdcAnodeHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FdcAnodeHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FdcAnodeHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FdcAnodeHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FdcAnodeHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int FdcAnodeHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int FdcAnodeHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline int FdcAnodeHit::getWire() const {
   return *(int*)m_parent->getAttribute("wire");
}

inline float FdcAnodeHit::getD() const {
   return m_d;
}

inline void FdcAnodeHit::setD(float d) {
   m_d = d;
}

inline float FdcAnodeHit::getDE() const {
   return m_dE;
}

inline void FdcAnodeHit::setDE(float dE) {
   m_dE = dE;
}

inline int FdcAnodeHit::getItrack() const {
   return m_itrack;
}

inline void FdcAnodeHit::setItrack(int itrack) {
   m_itrack = itrack;
}

inline std::string FdcAnodeHit::getMaxOccurs() const {
   return "unbounded";
}

inline int FdcAnodeHit::getPtype() const {
   return m_ptype;
}

inline void FdcAnodeHit::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float FdcAnodeHit::getT() const {
   return m_t;
}

inline void FdcAnodeHit::setT(float t) {
   m_t = t;
}

inline const void *FdcAnodeHit::getAttribute(const std::string &name) const {
   return (name == "d")? &m_d:
          (name == "dE")? &m_dE:
          (name == "itrack")? &m_itrack:
          (name == "ptype")? &m_ptype:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline FdcAnodeTruthHit::FdcAnodeTruthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_d(0),
   m_dE(0),
   m_itrack(0),
   m_ptype(0),
   m_t(0),
   m_t_unsmeared(0)
{}

inline FdcAnodeTruthHit::~FdcAnodeTruthHit() {}

inline std::string FdcAnodeTruthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FdcAnodeTruthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FdcAnodeTruthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FdcAnodeTruthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FdcAnodeTruthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FdcAnodeTruthHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int FdcAnodeTruthHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int FdcAnodeTruthHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline int FdcAnodeTruthHit::getWire() const {
   return *(int*)m_parent->getAttribute("wire");
}

inline float FdcAnodeTruthHit::getD() const {
   return m_d;
}

inline void FdcAnodeTruthHit::setD(float d) {
   m_d = d;
}

inline float FdcAnodeTruthHit::getDE() const {
   return m_dE;
}

inline void FdcAnodeTruthHit::setDE(float dE) {
   m_dE = dE;
}

inline int FdcAnodeTruthHit::getItrack() const {
   return m_itrack;
}

inline void FdcAnodeTruthHit::setItrack(int itrack) {
   m_itrack = itrack;
}

inline std::string FdcAnodeTruthHit::getMaxOccurs() const {
   return "unbounded";
}

inline int FdcAnodeTruthHit::getPtype() const {
   return m_ptype;
}

inline void FdcAnodeTruthHit::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float FdcAnodeTruthHit::getT() const {
   return m_t;
}

inline void FdcAnodeTruthHit::setT(float t) {
   m_t = t;
}

inline float FdcAnodeTruthHit::getT_unsmeared() const {
   return m_t_unsmeared;
}

inline void FdcAnodeTruthHit::setT_unsmeared(float t_unsmeared) {
   m_t_unsmeared = t_unsmeared;
}

inline const void *FdcAnodeTruthHit::getAttribute(const std::string &name) const {
   return (name == "d")? &m_d:
          (name == "dE")? &m_dE:
          (name == "itrack")? &m_itrack:
          (name == "ptype")? &m_ptype:
          (name == "t")? &m_t:
          (name == "t_unsmeared")? &m_t_unsmeared:
          m_parent->getAttribute(name);
}

inline FdcAnodeWire::FdcAnodeWire(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_wire(0),
   m_fdcAnodeHit_list(&m_host->m_fdcAnodeHit_plist,
               m_host->m_fdcAnodeHit_plist.end(),
               m_host->m_fdcAnodeHit_plist.end(),
               this),
   m_fdcAnodeTruthHit_list(&m_host->m_fdcAnodeTruthHit_plist,
               m_host->m_fdcAnodeTruthHit_plist.end(),
               m_host->m_fdcAnodeTruthHit_plist.end(),
               this)
{}

inline FdcAnodeWire::~FdcAnodeWire() {
   deleteFdcAnodeHits();
   deleteFdcAnodeTruthHits();
}

inline std::string FdcAnodeWire::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FdcAnodeWire::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FdcAnodeWire::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FdcAnodeWire::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FdcAnodeWire::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FdcAnodeWire::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int FdcAnodeWire::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline std::string FdcAnodeWire::getMaxOccurs() const {
   return "unbounded";
}

inline int FdcAnodeWire::getMinOccurs() const {
   return 0;
}

inline int FdcAnodeWire::getWire() const {
   return m_wire;
}

inline void FdcAnodeWire::setWire(int wire) {
   m_wire = wire;
}

inline const void *FdcAnodeWire::getAttribute(const std::string &name) const {
   return (name == "wire")? &m_wire:
          m_parent->getAttribute(name);
}

inline FdcAnodeHit &FdcAnodeWire::getFdcAnodeHit(int index) {
   return m_fdcAnodeHit_list(index);
}

inline FdcAnodeHitList &FdcAnodeWire::getFdcAnodeHits() {
   return m_fdcAnodeHit_list;
}

inline FdcAnodeHitList FdcAnodeWire::addFdcAnodeHits(int count, int start) {
   return m_fdcAnodeHit_list.add(count,start);
}

inline void FdcAnodeWire::deleteFdcAnodeHits(int count, int start) {
   m_fdcAnodeHit_list.del(count,start);
}

inline FdcAnodeTruthHit &FdcAnodeWire::getFdcAnodeTruthHit(int index) {
   return m_fdcAnodeTruthHit_list(index);
}

inline FdcAnodeTruthHitList &FdcAnodeWire::getFdcAnodeTruthHits() {
   return m_fdcAnodeTruthHit_list;
}

inline FdcAnodeTruthHitList FdcAnodeWire::addFdcAnodeTruthHits(int count, int start) {
   return m_fdcAnodeTruthHit_list.add(count,start);
}

inline void FdcAnodeWire::deleteFdcAnodeTruthHits(int count, int start) {
   m_fdcAnodeTruthHit_list.del(count,start);
}

inline FdcCathodeHit::FdcCathodeHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_itrack(0),
   m_ptype(0),
   m_q(0),
   m_t(0)
{}

inline FdcCathodeHit::~FdcCathodeHit() {}

inline std::string FdcCathodeHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FdcCathodeHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FdcCathodeHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FdcCathodeHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FdcCathodeHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FdcCathodeHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int FdcCathodeHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int FdcCathodeHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline int FdcCathodeHit::getPlane() const {
   return *(int*)m_parent->getAttribute("plane");
}

inline int FdcCathodeHit::getStrip() const {
   return *(int*)m_parent->getAttribute("strip");
}

inline int FdcCathodeHit::getItrack() const {
   return m_itrack;
}

inline void FdcCathodeHit::setItrack(int itrack) {
   m_itrack = itrack;
}

inline std::string FdcCathodeHit::getMaxOccurs() const {
   return "unbounded";
}

inline int FdcCathodeHit::getPtype() const {
   return m_ptype;
}

inline void FdcCathodeHit::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float FdcCathodeHit::getQ() const {
   return m_q;
}

inline void FdcCathodeHit::setQ(float q) {
   m_q = q;
}

inline float FdcCathodeHit::getT() const {
   return m_t;
}

inline void FdcCathodeHit::setT(float t) {
   m_t = t;
}

inline const void *FdcCathodeHit::getAttribute(const std::string &name) const {
   return (name == "itrack")? &m_itrack:
          (name == "ptype")? &m_ptype:
          (name == "q")? &m_q:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline FdcCathodeTruthHit::FdcCathodeTruthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_itrack(0),
   m_ptype(0),
   m_q(0),
   m_t(0)
{}

inline FdcCathodeTruthHit::~FdcCathodeTruthHit() {}

inline std::string FdcCathodeTruthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FdcCathodeTruthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FdcCathodeTruthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FdcCathodeTruthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FdcCathodeTruthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FdcCathodeTruthHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int FdcCathodeTruthHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int FdcCathodeTruthHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline int FdcCathodeTruthHit::getPlane() const {
   return *(int*)m_parent->getAttribute("plane");
}

inline int FdcCathodeTruthHit::getStrip() const {
   return *(int*)m_parent->getAttribute("strip");
}

inline int FdcCathodeTruthHit::getItrack() const {
   return m_itrack;
}

inline void FdcCathodeTruthHit::setItrack(int itrack) {
   m_itrack = itrack;
}

inline std::string FdcCathodeTruthHit::getMaxOccurs() const {
   return "unbounded";
}

inline int FdcCathodeTruthHit::getPtype() const {
   return m_ptype;
}

inline void FdcCathodeTruthHit::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float FdcCathodeTruthHit::getQ() const {
   return m_q;
}

inline void FdcCathodeTruthHit::setQ(float q) {
   m_q = q;
}

inline float FdcCathodeTruthHit::getT() const {
   return m_t;
}

inline void FdcCathodeTruthHit::setT(float t) {
   m_t = t;
}

inline const void *FdcCathodeTruthHit::getAttribute(const std::string &name) const {
   return (name == "itrack")? &m_itrack:
          (name == "ptype")? &m_ptype:
          (name == "q")? &m_q:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline FdcCathodeStrip::FdcCathodeStrip(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_plane(0),
   m_strip(0),
   m_fdcCathodeHit_list(&m_host->m_fdcCathodeHit_plist,
               m_host->m_fdcCathodeHit_plist.end(),
               m_host->m_fdcCathodeHit_plist.end(),
               this),
   m_fdcCathodeTruthHit_list(&m_host->m_fdcCathodeTruthHit_plist,
               m_host->m_fdcCathodeTruthHit_plist.end(),
               m_host->m_fdcCathodeTruthHit_plist.end(),
               this)
{}

inline FdcCathodeStrip::~FdcCathodeStrip() {
   deleteFdcCathodeHits();
   deleteFdcCathodeTruthHits();
}

inline std::string FdcCathodeStrip::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FdcCathodeStrip::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FdcCathodeStrip::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FdcCathodeStrip::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FdcCathodeStrip::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FdcCathodeStrip::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int FdcCathodeStrip::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline std::string FdcCathodeStrip::getMaxOccurs() const {
   return "unbounded";
}

inline int FdcCathodeStrip::getMinOccurs() const {
   return 0;
}

inline int FdcCathodeStrip::getPlane() const {
   return m_plane;
}

inline void FdcCathodeStrip::setPlane(int plane) {
   m_plane = plane;
}

inline int FdcCathodeStrip::getStrip() const {
   return m_strip;
}

inline void FdcCathodeStrip::setStrip(int strip) {
   m_strip = strip;
}

inline const void *FdcCathodeStrip::getAttribute(const std::string &name) const {
   return (name == "plane")? &m_plane:
          (name == "strip")? &m_strip:
          m_parent->getAttribute(name);
}

inline FdcCathodeHit &FdcCathodeStrip::getFdcCathodeHit(int index) {
   return m_fdcCathodeHit_list(index);
}

inline FdcCathodeHitList &FdcCathodeStrip::getFdcCathodeHits() {
   return m_fdcCathodeHit_list;
}

inline FdcCathodeHitList FdcCathodeStrip::addFdcCathodeHits(int count, int start) {
   return m_fdcCathodeHit_list.add(count,start);
}

inline void FdcCathodeStrip::deleteFdcCathodeHits(int count, int start) {
   m_fdcCathodeHit_list.del(count,start);
}

inline FdcCathodeTruthHit &FdcCathodeStrip::getFdcCathodeTruthHit(int index) {
   return m_fdcCathodeTruthHit_list(index);
}

inline FdcCathodeTruthHitList &FdcCathodeStrip::getFdcCathodeTruthHits() {
   return m_fdcCathodeTruthHit_list;
}

inline FdcCathodeTruthHitList FdcCathodeStrip::addFdcCathodeTruthHits(int count, int start) {
   return m_fdcCathodeTruthHit_list.add(count,start);
}

inline void FdcCathodeStrip::deleteFdcCathodeTruthHits(int count, int start) {
   m_fdcCathodeTruthHit_list.del(count,start);
}

inline FdcTruthPoint::FdcTruthPoint(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_dEdx(0),
   m_dradius(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_t(0),
   m_track(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline FdcTruthPoint::~FdcTruthPoint() {}

inline std::string FdcTruthPoint::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FdcTruthPoint::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FdcTruthPoint::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FdcTruthPoint::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FdcTruthPoint::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FdcTruthPoint::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int FdcTruthPoint::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline float FdcTruthPoint::getE() const {
   return m_E;
}

inline void FdcTruthPoint::setE(float E) {
   m_E = E;
}

inline float FdcTruthPoint::getDEdx() const {
   return m_dEdx;
}

inline void FdcTruthPoint::setDEdx(float dEdx) {
   m_dEdx = dEdx;
}

inline float FdcTruthPoint::getDradius() const {
   return m_dradius;
}

inline void FdcTruthPoint::setDradius(float dradius) {
   m_dradius = dradius;
}

inline std::string FdcTruthPoint::getMaxOccurs() const {
   return "unbounded";
}

inline int FdcTruthPoint::getMinOccurs() const {
   return 0;
}

inline bool FdcTruthPoint::getPrimary() const {
   return m_primary;
}

inline void FdcTruthPoint::setPrimary(bool primary) {
   m_primary = primary;
}

inline int FdcTruthPoint::getPtype() const {
   return m_ptype;
}

inline void FdcTruthPoint::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float FdcTruthPoint::getPx() const {
   return m_px;
}

inline void FdcTruthPoint::setPx(float px) {
   m_px = px;
}

inline float FdcTruthPoint::getPy() const {
   return m_py;
}

inline void FdcTruthPoint::setPy(float py) {
   m_py = py;
}

inline float FdcTruthPoint::getPz() const {
   return m_pz;
}

inline void FdcTruthPoint::setPz(float pz) {
   m_pz = pz;
}

inline float FdcTruthPoint::getT() const {
   return m_t;
}

inline void FdcTruthPoint::setT(float t) {
   m_t = t;
}

inline int FdcTruthPoint::getTrack() const {
   return m_track;
}

inline void FdcTruthPoint::setTrack(int track) {
   m_track = track;
}

inline float FdcTruthPoint::getX() const {
   return m_x;
}

inline void FdcTruthPoint::setX(float x) {
   m_x = x;
}

inline float FdcTruthPoint::getY() const {
   return m_y;
}

inline void FdcTruthPoint::setY(float y) {
   m_y = y;
}

inline float FdcTruthPoint::getZ() const {
   return m_z;
}

inline void FdcTruthPoint::setZ(float z) {
   m_z = z;
}

inline const void *FdcTruthPoint::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "dEdx")? &m_dEdx:
          (name == "dradius")? &m_dradius:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline FdcChamber::FdcChamber(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_layer(0),
   m_module(0),
   m_fdcAnodeWire_list(&m_host->m_fdcAnodeWire_plist,
               m_host->m_fdcAnodeWire_plist.end(),
               m_host->m_fdcAnodeWire_plist.end(),
               this),
   m_fdcCathodeStrip_list(&m_host->m_fdcCathodeStrip_plist,
               m_host->m_fdcCathodeStrip_plist.end(),
               m_host->m_fdcCathodeStrip_plist.end(),
               this),
   m_fdcTruthPoint_list(&m_host->m_fdcTruthPoint_plist,
               m_host->m_fdcTruthPoint_plist.end(),
               m_host->m_fdcTruthPoint_plist.end(),
               this)
{}

inline FdcChamber::~FdcChamber() {
   deleteFdcAnodeWires();
   deleteFdcCathodeStrips();
   deleteFdcTruthPoints();
}

inline std::string FdcChamber::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FdcChamber::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FdcChamber::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FdcChamber::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FdcChamber::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FdcChamber::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int FdcChamber::getLayer() const {
   return m_layer;
}

inline void FdcChamber::setLayer(int layer) {
   m_layer = layer;
}

inline std::string FdcChamber::getMaxOccurs() const {
   return "unbounded";
}

inline int FdcChamber::getModule() const {
   return m_module;
}

inline void FdcChamber::setModule(int module) {
   m_module = module;
}

inline const void *FdcChamber::getAttribute(const std::string &name) const {
   return (name == "layer")? &m_layer:
          (name == "module")? &m_module:
          m_parent->getAttribute(name);
}

inline FdcAnodeWire &FdcChamber::getFdcAnodeWire(int index) {
   return m_fdcAnodeWire_list(index);
}

inline FdcAnodeWireList &FdcChamber::getFdcAnodeWires() {
   return m_fdcAnodeWire_list;
}

inline FdcAnodeWireList FdcChamber::addFdcAnodeWires(int count, int start) {
   return m_fdcAnodeWire_list.add(count,start);
}

inline void FdcChamber::deleteFdcAnodeWires(int count, int start) {
   m_fdcAnodeWire_list.del(count,start);
}

inline FdcCathodeStrip &FdcChamber::getFdcCathodeStrip(int index) {
   return m_fdcCathodeStrip_list(index);
}

inline FdcCathodeStripList &FdcChamber::getFdcCathodeStrips() {
   return m_fdcCathodeStrip_list;
}

inline FdcCathodeStripList FdcChamber::addFdcCathodeStrips(int count, int start) {
   return m_fdcCathodeStrip_list.add(count,start);
}

inline void FdcChamber::deleteFdcCathodeStrips(int count, int start) {
   m_fdcCathodeStrip_list.del(count,start);
}

inline FdcTruthPoint &FdcChamber::getFdcTruthPoint(int index) {
   return m_fdcTruthPoint_list(index);
}

inline FdcTruthPointList &FdcChamber::getFdcTruthPoints() {
   return m_fdcTruthPoint_list;
}

inline FdcTruthPointList FdcChamber::addFdcTruthPoints(int count, int start) {
   return m_fdcTruthPoint_list.add(count,start);
}

inline void FdcChamber::deleteFdcTruthPoints(int count, int start) {
   m_fdcTruthPoint_list.del(count,start);
}

inline ForwardDC::ForwardDC(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_fdcChamber_list(&m_host->m_fdcChamber_plist,
               m_host->m_fdcChamber_plist.end(),
               m_host->m_fdcChamber_plist.end(),
               this)
{}

inline ForwardDC::~ForwardDC() {
   deleteFdcChambers();
}

inline std::string ForwardDC::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float ForwardDC::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string ForwardDC::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int ForwardDC::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string ForwardDC::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int ForwardDC::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int ForwardDC::getMinOccurs() const {
   return 0;
}

inline const void *ForwardDC::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline FdcChamber &ForwardDC::getFdcChamber(int index) {
   return m_fdcChamber_list(index);
}

inline FdcChamberList &ForwardDC::getFdcChambers() {
   return m_fdcChamber_list;
}

inline FdcChamberList ForwardDC::addFdcChambers(int count, int start) {
   return m_fdcChamber_list.add(count,start);
}

inline void ForwardDC::deleteFdcChambers(int count, int start) {
   m_fdcChamber_list.del(count,start);
}

inline StcHit::StcHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_dE(0),
   m_t(0)
{}

inline StcHit::~StcHit() {}

inline std::string StcHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float StcHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string StcHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int StcHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int StcHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int StcHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int StcHit::getSector() const {
   return *(int*)m_parent->getAttribute("sector");
}

inline float StcHit::getDE() const {
   return m_dE;
}

inline void StcHit::setDE(float dE) {
   m_dE = dE;
}

inline std::string StcHit::getMaxOccurs() const {
   return "unbounded";
}

inline float StcHit::getT() const {
   return m_t;
}

inline void StcHit::setT(float t) {
   m_t = t;
}

inline const void *StcHit::getAttribute(const std::string &name) const {
   return (name == "dE")? &m_dE:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline StcTruthHit::StcTruthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_dE(0),
   m_t(0)
{}

inline StcTruthHit::~StcTruthHit() {}

inline std::string StcTruthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float StcTruthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string StcTruthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int StcTruthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int StcTruthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int StcTruthHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int StcTruthHit::getSector() const {
   return *(int*)m_parent->getAttribute("sector");
}

inline float StcTruthHit::getDE() const {
   return m_dE;
}

inline void StcTruthHit::setDE(float dE) {
   m_dE = dE;
}

inline std::string StcTruthHit::getMaxOccurs() const {
   return "unbounded";
}

inline float StcTruthHit::getT() const {
   return m_t;
}

inline void StcTruthHit::setT(float t) {
   m_t = t;
}

inline const void *StcTruthHit::getAttribute(const std::string &name) const {
   return (name == "dE")? &m_dE:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline StcPaddle::StcPaddle(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_sector(0),
   m_stcHit_list(&m_host->m_stcHit_plist,
               m_host->m_stcHit_plist.end(),
               m_host->m_stcHit_plist.end(),
               this),
   m_stcTruthHit_list(&m_host->m_stcTruthHit_plist,
               m_host->m_stcTruthHit_plist.end(),
               m_host->m_stcTruthHit_plist.end(),
               this)
{}

inline StcPaddle::~StcPaddle() {
   deleteStcHits();
   deleteStcTruthHits();
}

inline std::string StcPaddle::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float StcPaddle::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string StcPaddle::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int StcPaddle::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int StcPaddle::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline std::string StcPaddle::getMaxOccurs() const {
   return "unbounded";
}

inline int StcPaddle::getMinOccurs() const {
   return 0;
}

inline int StcPaddle::getSector() const {
   return m_sector;
}

inline void StcPaddle::setSector(int sector) {
   m_sector = sector;
}

inline const void *StcPaddle::getAttribute(const std::string &name) const {
   return (name == "sector")? &m_sector:
          m_parent->getAttribute(name);
}

inline StcHit &StcPaddle::getStcHit(int index) {
   return m_stcHit_list(index);
}

inline StcHitList &StcPaddle::getStcHits() {
   return m_stcHit_list;
}

inline StcHitList StcPaddle::addStcHits(int count, int start) {
   return m_stcHit_list.add(count,start);
}

inline void StcPaddle::deleteStcHits(int count, int start) {
   m_stcHit_list.del(count,start);
}

inline StcTruthHit &StcPaddle::getStcTruthHit(int index) {
   return m_stcTruthHit_list(index);
}

inline StcTruthHitList &StcPaddle::getStcTruthHits() {
   return m_stcTruthHit_list;
}

inline StcTruthHitList StcPaddle::addStcTruthHits(int count, int start) {
   return m_stcTruthHit_list.add(count,start);
}

inline void StcPaddle::deleteStcTruthHits(int count, int start) {
   m_stcTruthHit_list.del(count,start);
}

inline StcTruthPoint::StcTruthPoint(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_dEdx(0),
   m_phi(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_r(0),
   m_sector(0),
   m_t(0),
   m_track(0),
   m_z(0)
{}

inline StcTruthPoint::~StcTruthPoint() {}

inline std::string StcTruthPoint::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float StcTruthPoint::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string StcTruthPoint::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int StcTruthPoint::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int StcTruthPoint::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float StcTruthPoint::getE() const {
   return m_E;
}

inline void StcTruthPoint::setE(float E) {
   m_E = E;
}

inline float StcTruthPoint::getDEdx() const {
   return m_dEdx;
}

inline void StcTruthPoint::setDEdx(float dEdx) {
   m_dEdx = dEdx;
}

inline std::string StcTruthPoint::getMaxOccurs() const {
   return "unbounded";
}

inline int StcTruthPoint::getMinOccurs() const {
   return 0;
}

inline float StcTruthPoint::getPhi() const {
   return m_phi;
}

inline void StcTruthPoint::setPhi(float phi) {
   m_phi = phi;
}

inline bool StcTruthPoint::getPrimary() const {
   return m_primary;
}

inline void StcTruthPoint::setPrimary(bool primary) {
   m_primary = primary;
}

inline int StcTruthPoint::getPtype() const {
   return m_ptype;
}

inline void StcTruthPoint::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float StcTruthPoint::getPx() const {
   return m_px;
}

inline void StcTruthPoint::setPx(float px) {
   m_px = px;
}

inline float StcTruthPoint::getPy() const {
   return m_py;
}

inline void StcTruthPoint::setPy(float py) {
   m_py = py;
}

inline float StcTruthPoint::getPz() const {
   return m_pz;
}

inline void StcTruthPoint::setPz(float pz) {
   m_pz = pz;
}

inline float StcTruthPoint::getR() const {
   return m_r;
}

inline void StcTruthPoint::setR(float r) {
   m_r = r;
}

inline int StcTruthPoint::getSector() const {
   return m_sector;
}

inline void StcTruthPoint::setSector(int sector) {
   m_sector = sector;
}

inline float StcTruthPoint::getT() const {
   return m_t;
}

inline void StcTruthPoint::setT(float t) {
   m_t = t;
}

inline int StcTruthPoint::getTrack() const {
   return m_track;
}

inline void StcTruthPoint::setTrack(int track) {
   m_track = track;
}

inline float StcTruthPoint::getZ() const {
   return m_z;
}

inline void StcTruthPoint::setZ(float z) {
   m_z = z;
}

inline const void *StcTruthPoint::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "dEdx")? &m_dEdx:
          (name == "phi")? &m_phi:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "r")? &m_r:
          (name == "sector")? &m_sector:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline StartCntr::StartCntr(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_stcPaddle_list(&m_host->m_stcPaddle_plist,
               m_host->m_stcPaddle_plist.end(),
               m_host->m_stcPaddle_plist.end(),
               this),
   m_stcTruthPoint_list(&m_host->m_stcTruthPoint_plist,
               m_host->m_stcTruthPoint_plist.end(),
               m_host->m_stcTruthPoint_plist.end(),
               this)
{}

inline StartCntr::~StartCntr() {
   deleteStcPaddles();
   deleteStcTruthPoints();
}

inline std::string StartCntr::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float StartCntr::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string StartCntr::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int StartCntr::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string StartCntr::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int StartCntr::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int StartCntr::getMinOccurs() const {
   return 0;
}

inline const void *StartCntr::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline StcPaddle &StartCntr::getStcPaddle(int index) {
   return m_stcPaddle_list(index);
}

inline StcPaddleList &StartCntr::getStcPaddles() {
   return m_stcPaddle_list;
}

inline StcPaddleList StartCntr::addStcPaddles(int count, int start) {
   return m_stcPaddle_list.add(count,start);
}

inline void StartCntr::deleteStcPaddles(int count, int start) {
   m_stcPaddle_list.del(count,start);
}

inline StcTruthPoint &StartCntr::getStcTruthPoint(int index) {
   return m_stcTruthPoint_list(index);
}

inline StcTruthPointList &StartCntr::getStcTruthPoints() {
   return m_stcTruthPoint_list;
}

inline StcTruthPointList StartCntr::addStcTruthPoints(int count, int start) {
   return m_stcTruthPoint_list.add(count,start);
}

inline void StartCntr::deleteStcTruthPoints(int count, int start) {
   m_stcTruthPoint_list.del(count,start);
}

inline BcalSiPMUpHit::BcalSiPMUpHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline BcalSiPMUpHit::~BcalSiPMUpHit() {}

inline std::string BcalSiPMUpHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalSiPMUpHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalSiPMUpHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalSiPMUpHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalSiPMUpHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BcalSiPMUpHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int BcalSiPMUpHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline int BcalSiPMUpHit::getSector() const {
   return *(int*)m_parent->getAttribute("sector");
}

inline float BcalSiPMUpHit::getE() const {
   return m_E;
}

inline void BcalSiPMUpHit::setE(float E) {
   m_E = E;
}

inline std::string BcalSiPMUpHit::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalSiPMUpHit::getMinOccurs() const {
   return 0;
}

inline float BcalSiPMUpHit::getT() const {
   return m_t;
}

inline void BcalSiPMUpHit::setT(float t) {
   m_t = t;
}

inline const void *BcalSiPMUpHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline BcalSiPMDownHit::BcalSiPMDownHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline BcalSiPMDownHit::~BcalSiPMDownHit() {}

inline std::string BcalSiPMDownHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalSiPMDownHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalSiPMDownHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalSiPMDownHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalSiPMDownHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BcalSiPMDownHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int BcalSiPMDownHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline int BcalSiPMDownHit::getSector() const {
   return *(int*)m_parent->getAttribute("sector");
}

inline float BcalSiPMDownHit::getE() const {
   return m_E;
}

inline void BcalSiPMDownHit::setE(float E) {
   m_E = E;
}

inline std::string BcalSiPMDownHit::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalSiPMDownHit::getMinOccurs() const {
   return 0;
}

inline float BcalSiPMDownHit::getT() const {
   return m_t;
}

inline void BcalSiPMDownHit::setT(float t) {
   m_t = t;
}

inline const void *BcalSiPMDownHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline BcalHit::BcalHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0),
   m_zLocal(0)
{}

inline BcalHit::~BcalHit() {}

inline std::string BcalHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BcalHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int BcalHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline int BcalHit::getSector() const {
   return *(int*)m_parent->getAttribute("sector");
}

inline float BcalHit::getE() const {
   return m_E;
}

inline void BcalHit::setE(float E) {
   m_E = E;
}

inline std::string BcalHit::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalHit::getMinOccurs() const {
   return 0;
}

inline float BcalHit::getT() const {
   return m_t;
}

inline void BcalHit::setT(float t) {
   m_t = t;
}

inline float BcalHit::getZLocal() const {
   return m_zLocal;
}

inline void BcalHit::setZLocal(float zLocal) {
   m_zLocal = zLocal;
}

inline const void *BcalHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          (name == "zLocal")? &m_zLocal:
          m_parent->getAttribute(name);
}

inline BcalCell::BcalCell(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_layer(0),
   m_module(0),
   m_sector(0),
   m_bcalSiPMUpHit_list(&m_host->m_bcalSiPMUpHit_plist,
               m_host->m_bcalSiPMUpHit_plist.end(),
               m_host->m_bcalSiPMUpHit_plist.end(),
               this),
   m_bcalSiPMDownHit_list(&m_host->m_bcalSiPMDownHit_plist,
               m_host->m_bcalSiPMDownHit_plist.end(),
               m_host->m_bcalSiPMDownHit_plist.end(),
               this),
   m_bcalHit_list(&m_host->m_bcalHit_plist,
               m_host->m_bcalHit_plist.end(),
               m_host->m_bcalHit_plist.end(),
               this)
{}

inline BcalCell::~BcalCell() {
   deleteBcalSiPMUpHits();
   deleteBcalSiPMDownHits();
   deleteBcalHits();
}

inline std::string BcalCell::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalCell::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalCell::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalCell::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalCell::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BcalCell::getLayer() const {
   return m_layer;
}

inline void BcalCell::setLayer(int layer) {
   m_layer = layer;
}

inline std::string BcalCell::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalCell::getMinOccurs() const {
   return 0;
}

inline int BcalCell::getModule() const {
   return m_module;
}

inline void BcalCell::setModule(int module) {
   m_module = module;
}

inline int BcalCell::getSector() const {
   return m_sector;
}

inline void BcalCell::setSector(int sector) {
   m_sector = sector;
}

inline const void *BcalCell::getAttribute(const std::string &name) const {
   return (name == "layer")? &m_layer:
          (name == "module")? &m_module:
          (name == "sector")? &m_sector:
          m_parent->getAttribute(name);
}

inline BcalSiPMUpHit &BcalCell::getBcalSiPMUpHit(int index) {
   return m_bcalSiPMUpHit_list(index);
}

inline BcalSiPMUpHitList &BcalCell::getBcalSiPMUpHits() {
   return m_bcalSiPMUpHit_list;
}

inline BcalSiPMUpHitList BcalCell::addBcalSiPMUpHits(int count, int start) {
   return m_bcalSiPMUpHit_list.add(count,start);
}

inline void BcalCell::deleteBcalSiPMUpHits(int count, int start) {
   m_bcalSiPMUpHit_list.del(count,start);
}

inline BcalSiPMDownHit &BcalCell::getBcalSiPMDownHit(int index) {
   return m_bcalSiPMDownHit_list(index);
}

inline BcalSiPMDownHitList &BcalCell::getBcalSiPMDownHits() {
   return m_bcalSiPMDownHit_list;
}

inline BcalSiPMDownHitList BcalCell::addBcalSiPMDownHits(int count, int start) {
   return m_bcalSiPMDownHit_list.add(count,start);
}

inline void BcalCell::deleteBcalSiPMDownHits(int count, int start) {
   m_bcalSiPMDownHit_list.del(count,start);
}

inline BcalHit &BcalCell::getBcalHit(int index) {
   return m_bcalHit_list(index);
}

inline BcalHitList &BcalCell::getBcalHits() {
   return m_bcalHit_list;
}

inline BcalHitList BcalCell::addBcalHits(int count, int start) {
   return m_bcalHit_list.add(count,start);
}

inline void BcalCell::deleteBcalHits(int count, int start) {
   m_bcalHit_list.del(count,start);
}

inline BcalIncidentParticle::BcalIncidentParticle(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_id(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline BcalIncidentParticle::~BcalIncidentParticle() {}

inline std::string BcalIncidentParticle::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalIncidentParticle::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalIncidentParticle::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalIncidentParticle::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalIncidentParticle::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BcalIncidentParticle::getId() const {
   return m_id;
}

inline void BcalIncidentParticle::setId(int id) {
   m_id = id;
}

inline std::string BcalIncidentParticle::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalIncidentParticle::getMinOccurs() const {
   return 0;
}

inline int BcalIncidentParticle::getPtype() const {
   return m_ptype;
}

inline void BcalIncidentParticle::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float BcalIncidentParticle::getPx() const {
   return m_px;
}

inline void BcalIncidentParticle::setPx(float px) {
   m_px = px;
}

inline float BcalIncidentParticle::getPy() const {
   return m_py;
}

inline void BcalIncidentParticle::setPy(float py) {
   m_py = py;
}

inline float BcalIncidentParticle::getPz() const {
   return m_pz;
}

inline void BcalIncidentParticle::setPz(float pz) {
   m_pz = pz;
}

inline float BcalIncidentParticle::getX() const {
   return m_x;
}

inline void BcalIncidentParticle::setX(float x) {
   m_x = x;
}

inline float BcalIncidentParticle::getY() const {
   return m_y;
}

inline void BcalIncidentParticle::setY(float y) {
   m_y = y;
}

inline float BcalIncidentParticle::getZ() const {
   return m_z;
}

inline void BcalIncidentParticle::setZ(float z) {
   m_z = z;
}

inline const void *BcalIncidentParticle::getAttribute(const std::string &name) const {
   return (name == "id")? &m_id:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline BcalSiPMSpectrum::BcalSiPMSpectrum(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_Etruth(0),
   m_bin_width(0),
   m_end(0),
   m_incident_id(0),
   m_layer(0),
   m_module(0),
   m_sector(0),
   m_tstart(0),
   m_vals("")
{}

inline BcalSiPMSpectrum::~BcalSiPMSpectrum() {}

inline std::string BcalSiPMSpectrum::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalSiPMSpectrum::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalSiPMSpectrum::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalSiPMSpectrum::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalSiPMSpectrum::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float BcalSiPMSpectrum::getEtruth() const {
   return m_Etruth;
}

inline void BcalSiPMSpectrum::setEtruth(float Etruth) {
   m_Etruth = Etruth;
}

inline float BcalSiPMSpectrum::getBin_width() const {
   return m_bin_width;
}

inline void BcalSiPMSpectrum::setBin_width(float bin_width) {
   m_bin_width = bin_width;
}

inline int BcalSiPMSpectrum::getEnd() const {
   return m_end;
}

inline void BcalSiPMSpectrum::setEnd(int end) {
   m_end = end;
}

inline int BcalSiPMSpectrum::getIncident_id() const {
   return m_incident_id;
}

inline void BcalSiPMSpectrum::setIncident_id(int incident_id) {
   m_incident_id = incident_id;
}

inline int BcalSiPMSpectrum::getLayer() const {
   return m_layer;
}

inline void BcalSiPMSpectrum::setLayer(int layer) {
   m_layer = layer;
}

inline std::string BcalSiPMSpectrum::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalSiPMSpectrum::getMinOccurs() const {
   return 0;
}

inline int BcalSiPMSpectrum::getModule() const {
   return m_module;
}

inline void BcalSiPMSpectrum::setModule(int module) {
   m_module = module;
}

inline int BcalSiPMSpectrum::getSector() const {
   return m_sector;
}

inline void BcalSiPMSpectrum::setSector(int sector) {
   m_sector = sector;
}

inline float BcalSiPMSpectrum::getTstart() const {
   return m_tstart;
}

inline void BcalSiPMSpectrum::setTstart(float tstart) {
   m_tstart = tstart;
}

inline std::string BcalSiPMSpectrum::getVals() const {
   return m_vals;
}

inline void BcalSiPMSpectrum::setVals(const std::string &vals) {
   m_vals = vals;
}

inline const void *BcalSiPMSpectrum::getAttribute(const std::string &name) const {
   return (name == "Etruth")? &m_Etruth:
          (name == "bin_width")? &m_bin_width:
          (name == "end")? &m_end:
          (name == "incident_id")? &m_incident_id:
          (name == "layer")? &m_layer:
          (name == "module")? &m_module:
          (name == "sector")? &m_sector:
          (name == "tstart")? &m_tstart:
          (name == "vals")? &m_vals:
          m_parent->getAttribute(name);
}

inline BcalfADCUpHit::BcalfADCUpHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline BcalfADCUpHit::~BcalfADCUpHit() {}

inline std::string BcalfADCUpHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalfADCUpHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalfADCUpHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalfADCUpHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalfADCUpHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BcalfADCUpHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int BcalfADCUpHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline int BcalfADCUpHit::getSector() const {
   return *(int*)m_parent->getAttribute("sector");
}

inline float BcalfADCUpHit::getE() const {
   return m_E;
}

inline void BcalfADCUpHit::setE(float E) {
   m_E = E;
}

inline std::string BcalfADCUpHit::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalfADCUpHit::getMinOccurs() const {
   return 0;
}

inline float BcalfADCUpHit::getT() const {
   return m_t;
}

inline void BcalfADCUpHit::setT(float t) {
   m_t = t;
}

inline const void *BcalfADCUpHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline BcalfADCDownHit::BcalfADCDownHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline BcalfADCDownHit::~BcalfADCDownHit() {}

inline std::string BcalfADCDownHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalfADCDownHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalfADCDownHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalfADCDownHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalfADCDownHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BcalfADCDownHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int BcalfADCDownHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline int BcalfADCDownHit::getSector() const {
   return *(int*)m_parent->getAttribute("sector");
}

inline float BcalfADCDownHit::getE() const {
   return m_E;
}

inline void BcalfADCDownHit::setE(float E) {
   m_E = E;
}

inline std::string BcalfADCDownHit::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalfADCDownHit::getMinOccurs() const {
   return 0;
}

inline float BcalfADCDownHit::getT() const {
   return m_t;
}

inline void BcalfADCDownHit::setT(float t) {
   m_t = t;
}

inline const void *BcalfADCDownHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline BcalfADCCell::BcalfADCCell(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_layer(0),
   m_module(0),
   m_sector(0),
   m_bcalfADCUpHit_list(&m_host->m_bcalfADCUpHit_plist,
               m_host->m_bcalfADCUpHit_plist.end(),
               m_host->m_bcalfADCUpHit_plist.end(),
               this),
   m_bcalfADCDownHit_list(&m_host->m_bcalfADCDownHit_plist,
               m_host->m_bcalfADCDownHit_plist.end(),
               m_host->m_bcalfADCDownHit_plist.end(),
               this)
{}

inline BcalfADCCell::~BcalfADCCell() {
   deleteBcalfADCUpHits();
   deleteBcalfADCDownHits();
}

inline std::string BcalfADCCell::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalfADCCell::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalfADCCell::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalfADCCell::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalfADCCell::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BcalfADCCell::getLayer() const {
   return m_layer;
}

inline void BcalfADCCell::setLayer(int layer) {
   m_layer = layer;
}

inline std::string BcalfADCCell::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalfADCCell::getMinOccurs() const {
   return 0;
}

inline int BcalfADCCell::getModule() const {
   return m_module;
}

inline void BcalfADCCell::setModule(int module) {
   m_module = module;
}

inline int BcalfADCCell::getSector() const {
   return m_sector;
}

inline void BcalfADCCell::setSector(int sector) {
   m_sector = sector;
}

inline const void *BcalfADCCell::getAttribute(const std::string &name) const {
   return (name == "layer")? &m_layer:
          (name == "module")? &m_module:
          (name == "sector")? &m_sector:
          m_parent->getAttribute(name);
}

inline BcalfADCUpHit &BcalfADCCell::getBcalfADCUpHit(int index) {
   return m_bcalfADCUpHit_list(index);
}

inline BcalfADCUpHitList &BcalfADCCell::getBcalfADCUpHits() {
   return m_bcalfADCUpHit_list;
}

inline BcalfADCUpHitList BcalfADCCell::addBcalfADCUpHits(int count, int start) {
   return m_bcalfADCUpHit_list.add(count,start);
}

inline void BcalfADCCell::deleteBcalfADCUpHits(int count, int start) {
   m_bcalfADCUpHit_list.del(count,start);
}

inline BcalfADCDownHit &BcalfADCCell::getBcalfADCDownHit(int index) {
   return m_bcalfADCDownHit_list(index);
}

inline BcalfADCDownHitList &BcalfADCCell::getBcalfADCDownHits() {
   return m_bcalfADCDownHit_list;
}

inline BcalfADCDownHitList BcalfADCCell::addBcalfADCDownHits(int count, int start) {
   return m_bcalfADCDownHit_list.add(count,start);
}

inline void BcalfADCCell::deleteBcalfADCDownHits(int count, int start) {
   m_bcalfADCDownHit_list.del(count,start);
}

inline BcalTDCHit::BcalTDCHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_end(0),
   m_layer(0),
   m_module(0),
   m_sector(0),
   m_t(0)
{}

inline BcalTDCHit::~BcalTDCHit() {}

inline std::string BcalTDCHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalTDCHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalTDCHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalTDCHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalTDCHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BcalTDCHit::getEnd() const {
   return m_end;
}

inline void BcalTDCHit::setEnd(int end) {
   m_end = end;
}

inline int BcalTDCHit::getLayer() const {
   return m_layer;
}

inline void BcalTDCHit::setLayer(int layer) {
   m_layer = layer;
}

inline std::string BcalTDCHit::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalTDCHit::getMinOccurs() const {
   return 0;
}

inline int BcalTDCHit::getModule() const {
   return m_module;
}

inline void BcalTDCHit::setModule(int module) {
   m_module = module;
}

inline int BcalTDCHit::getSector() const {
   return m_sector;
}

inline void BcalTDCHit::setSector(int sector) {
   m_sector = sector;
}

inline float BcalTDCHit::getT() const {
   return m_t;
}

inline void BcalTDCHit::setT(float t) {
   m_t = t;
}

inline const void *BcalTDCHit::getAttribute(const std::string &name) const {
   return (name == "end")? &m_end:
          (name == "layer")? &m_layer:
          (name == "module")? &m_module:
          (name == "sector")? &m_sector:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline BcalTruthShower::BcalTruthShower(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_phi(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_r(0),
   m_t(0),
   m_track(0),
   m_z(0)
{}

inline BcalTruthShower::~BcalTruthShower() {}

inline std::string BcalTruthShower::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BcalTruthShower::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BcalTruthShower::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BcalTruthShower::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int BcalTruthShower::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float BcalTruthShower::getE() const {
   return m_E;
}

inline void BcalTruthShower::setE(float E) {
   m_E = E;
}

inline std::string BcalTruthShower::getMaxOccurs() const {
   return "unbounded";
}

inline int BcalTruthShower::getMinOccurs() const {
   return 0;
}

inline float BcalTruthShower::getPhi() const {
   return m_phi;
}

inline void BcalTruthShower::setPhi(float phi) {
   m_phi = phi;
}

inline bool BcalTruthShower::getPrimary() const {
   return m_primary;
}

inline void BcalTruthShower::setPrimary(bool primary) {
   m_primary = primary;
}

inline int BcalTruthShower::getPtype() const {
   return m_ptype;
}

inline void BcalTruthShower::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float BcalTruthShower::getPx() const {
   return m_px;
}

inline void BcalTruthShower::setPx(float px) {
   m_px = px;
}

inline float BcalTruthShower::getPy() const {
   return m_py;
}

inline void BcalTruthShower::setPy(float py) {
   m_py = py;
}

inline float BcalTruthShower::getPz() const {
   return m_pz;
}

inline void BcalTruthShower::setPz(float pz) {
   m_pz = pz;
}

inline float BcalTruthShower::getR() const {
   return m_r;
}

inline void BcalTruthShower::setR(float r) {
   m_r = r;
}

inline float BcalTruthShower::getT() const {
   return m_t;
}

inline void BcalTruthShower::setT(float t) {
   m_t = t;
}

inline int BcalTruthShower::getTrack() const {
   return m_track;
}

inline void BcalTruthShower::setTrack(int track) {
   m_track = track;
}

inline float BcalTruthShower::getZ() const {
   return m_z;
}

inline void BcalTruthShower::setZ(float z) {
   m_z = z;
}

inline const void *BcalTruthShower::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "phi")? &m_phi:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "r")? &m_r:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline BarrelEMcal::BarrelEMcal(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_bcalCell_list(&m_host->m_bcalCell_plist,
               m_host->m_bcalCell_plist.end(),
               m_host->m_bcalCell_plist.end(),
               this),
   m_bcalIncidentParticle_list(&m_host->m_bcalIncidentParticle_plist,
               m_host->m_bcalIncidentParticle_plist.end(),
               m_host->m_bcalIncidentParticle_plist.end(),
               this),
   m_bcalSiPMSpectrum_list(&m_host->m_bcalSiPMSpectrum_plist,
               m_host->m_bcalSiPMSpectrum_plist.end(),
               m_host->m_bcalSiPMSpectrum_plist.end(),
               this),
   m_bcalfADCCell_list(&m_host->m_bcalfADCCell_plist,
               m_host->m_bcalfADCCell_plist.end(),
               m_host->m_bcalfADCCell_plist.end(),
               this),
   m_bcalTDCHit_list(&m_host->m_bcalTDCHit_plist,
               m_host->m_bcalTDCHit_plist.end(),
               m_host->m_bcalTDCHit_plist.end(),
               this),
   m_bcalTruthShower_list(&m_host->m_bcalTruthShower_plist,
               m_host->m_bcalTruthShower_plist.end(),
               m_host->m_bcalTruthShower_plist.end(),
               this)
{}

inline BarrelEMcal::~BarrelEMcal() {
   deleteBcalCells();
   deleteBcalIncidentParticles();
   deleteBcalSiPMSpectrums();
   deleteBcalfADCCells();
   deleteBcalTDCHits();
   deleteBcalTruthShowers();
}

inline std::string BarrelEMcal::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float BarrelEMcal::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string BarrelEMcal::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int BarrelEMcal::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string BarrelEMcal::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int BarrelEMcal::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int BarrelEMcal::getMinOccurs() const {
   return 0;
}

inline const void *BarrelEMcal::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline BcalCell &BarrelEMcal::getBcalCell(int index) {
   return m_bcalCell_list(index);
}

inline BcalCellList &BarrelEMcal::getBcalCells() {
   return m_bcalCell_list;
}

inline BcalCellList BarrelEMcal::addBcalCells(int count, int start) {
   return m_bcalCell_list.add(count,start);
}

inline void BarrelEMcal::deleteBcalCells(int count, int start) {
   m_bcalCell_list.del(count,start);
}

inline BcalIncidentParticle &BarrelEMcal::getBcalIncidentParticle(int index) {
   return m_bcalIncidentParticle_list(index);
}

inline BcalIncidentParticleList &BarrelEMcal::getBcalIncidentParticles() {
   return m_bcalIncidentParticle_list;
}

inline BcalIncidentParticleList BarrelEMcal::addBcalIncidentParticles(int count, int start) {
   return m_bcalIncidentParticle_list.add(count,start);
}

inline void BarrelEMcal::deleteBcalIncidentParticles(int count, int start) {
   m_bcalIncidentParticle_list.del(count,start);
}

inline BcalSiPMSpectrum &BarrelEMcal::getBcalSiPMSpectrum(int index) {
   return m_bcalSiPMSpectrum_list(index);
}

inline BcalSiPMSpectrumList &BarrelEMcal::getBcalSiPMSpectrums() {
   return m_bcalSiPMSpectrum_list;
}

inline BcalSiPMSpectrumList BarrelEMcal::addBcalSiPMSpectrums(int count, int start) {
   return m_bcalSiPMSpectrum_list.add(count,start);
}

inline void BarrelEMcal::deleteBcalSiPMSpectrums(int count, int start) {
   m_bcalSiPMSpectrum_list.del(count,start);
}

inline BcalfADCCell &BarrelEMcal::getBcalfADCCell(int index) {
   return m_bcalfADCCell_list(index);
}

inline BcalfADCCellList &BarrelEMcal::getBcalfADCCells() {
   return m_bcalfADCCell_list;
}

inline BcalfADCCellList BarrelEMcal::addBcalfADCCells(int count, int start) {
   return m_bcalfADCCell_list.add(count,start);
}

inline void BarrelEMcal::deleteBcalfADCCells(int count, int start) {
   m_bcalfADCCell_list.del(count,start);
}

inline BcalTDCHit &BarrelEMcal::getBcalTDCHit(int index) {
   return m_bcalTDCHit_list(index);
}

inline BcalTDCHitList &BarrelEMcal::getBcalTDCHits() {
   return m_bcalTDCHit_list;
}

inline BcalTDCHitList BarrelEMcal::addBcalTDCHits(int count, int start) {
   return m_bcalTDCHit_list.add(count,start);
}

inline void BarrelEMcal::deleteBcalTDCHits(int count, int start) {
   m_bcalTDCHit_list.del(count,start);
}

inline BcalTruthShower &BarrelEMcal::getBcalTruthShower(int index) {
   return m_bcalTruthShower_list(index);
}

inline BcalTruthShowerList &BarrelEMcal::getBcalTruthShowers() {
   return m_bcalTruthShower_list;
}

inline BcalTruthShowerList BarrelEMcal::addBcalTruthShowers(int count, int start) {
   return m_bcalTruthShower_list.add(count,start);
}

inline void BarrelEMcal::deleteBcalTruthShowers(int count, int start) {
   m_bcalTruthShower_list.del(count,start);
}

inline GcalHit::GcalHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0),
   m_zLocal(0)
{}

inline GcalHit::~GcalHit() {}

inline std::string GcalHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float GcalHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string GcalHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int GcalHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int GcalHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int GcalHit::getModule() const {
   return *(int*)m_parent->getAttribute("module");
}

inline float GcalHit::getE() const {
   return m_E;
}

inline void GcalHit::setE(float E) {
   m_E = E;
}

inline std::string GcalHit::getMaxOccurs() const {
   return "unbounded";
}

inline int GcalHit::getMinOccurs() const {
   return 0;
}

inline float GcalHit::getT() const {
   return m_t;
}

inline void GcalHit::setT(float t) {
   m_t = t;
}

inline float GcalHit::getZLocal() const {
   return m_zLocal;
}

inline void GcalHit::setZLocal(float zLocal) {
   m_zLocal = zLocal;
}

inline const void *GcalHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          (name == "zLocal")? &m_zLocal:
          m_parent->getAttribute(name);
}

inline GcalCell::GcalCell(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_module(0),
   m_gcalHit_list(&m_host->m_gcalHit_plist,
               m_host->m_gcalHit_plist.end(),
               m_host->m_gcalHit_plist.end(),
               this)
{}

inline GcalCell::~GcalCell() {
   deleteGcalHits();
}

inline std::string GcalCell::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float GcalCell::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string GcalCell::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int GcalCell::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int GcalCell::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int GcalCell::getMaxOccurs() const {
   return 48;
}

inline int GcalCell::getMinOccurs() const {
   return 0;
}

inline int GcalCell::getModule() const {
   return m_module;
}

inline void GcalCell::setModule(int module) {
   m_module = module;
}

inline const void *GcalCell::getAttribute(const std::string &name) const {
   return (name == "module")? &m_module:
          m_parent->getAttribute(name);
}

inline GcalHit &GcalCell::getGcalHit(int index) {
   return m_gcalHit_list(index);
}

inline GcalHitList &GcalCell::getGcalHits() {
   return m_gcalHit_list;
}

inline GcalHitList GcalCell::addGcalHits(int count, int start) {
   return m_gcalHit_list.add(count,start);
}

inline void GcalCell::deleteGcalHits(int count, int start) {
   m_gcalHit_list.del(count,start);
}

inline GcalTruthShower::GcalTruthShower(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_phi(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_r(0),
   m_t(0),
   m_track(0),
   m_z(0)
{}

inline GcalTruthShower::~GcalTruthShower() {}

inline std::string GcalTruthShower::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float GcalTruthShower::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string GcalTruthShower::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int GcalTruthShower::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int GcalTruthShower::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float GcalTruthShower::getE() const {
   return m_E;
}

inline void GcalTruthShower::setE(float E) {
   m_E = E;
}

inline std::string GcalTruthShower::getMaxOccurs() const {
   return "unbounded";
}

inline int GcalTruthShower::getMinOccurs() const {
   return 0;
}

inline float GcalTruthShower::getPhi() const {
   return m_phi;
}

inline void GcalTruthShower::setPhi(float phi) {
   m_phi = phi;
}

inline bool GcalTruthShower::getPrimary() const {
   return m_primary;
}

inline void GcalTruthShower::setPrimary(bool primary) {
   m_primary = primary;
}

inline int GcalTruthShower::getPtype() const {
   return m_ptype;
}

inline void GcalTruthShower::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float GcalTruthShower::getPx() const {
   return m_px;
}

inline void GcalTruthShower::setPx(float px) {
   m_px = px;
}

inline float GcalTruthShower::getPy() const {
   return m_py;
}

inline void GcalTruthShower::setPy(float py) {
   m_py = py;
}

inline float GcalTruthShower::getPz() const {
   return m_pz;
}

inline void GcalTruthShower::setPz(float pz) {
   m_pz = pz;
}

inline float GcalTruthShower::getR() const {
   return m_r;
}

inline void GcalTruthShower::setR(float r) {
   m_r = r;
}

inline float GcalTruthShower::getT() const {
   return m_t;
}

inline void GcalTruthShower::setT(float t) {
   m_t = t;
}

inline int GcalTruthShower::getTrack() const {
   return m_track;
}

inline void GcalTruthShower::setTrack(int track) {
   m_track = track;
}

inline float GcalTruthShower::getZ() const {
   return m_z;
}

inline void GcalTruthShower::setZ(float z) {
   m_z = z;
}

inline const void *GcalTruthShower::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "phi")? &m_phi:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "r")? &m_r:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline GapEMcal::GapEMcal(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_gcalCell_list(&m_host->m_gcalCell_plist,
               m_host->m_gcalCell_plist.end(),
               m_host->m_gcalCell_plist.end(),
               this),
   m_gcalTruthShower_list(&m_host->m_gcalTruthShower_plist,
               m_host->m_gcalTruthShower_plist.end(),
               m_host->m_gcalTruthShower_plist.end(),
               this)
{}

inline GapEMcal::~GapEMcal() {
   deleteGcalCells();
   deleteGcalTruthShowers();
}

inline std::string GapEMcal::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float GapEMcal::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string GapEMcal::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int GapEMcal::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string GapEMcal::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int GapEMcal::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int GapEMcal::getMinOccurs() const {
   return 0;
}

inline const void *GapEMcal::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline GcalCell &GapEMcal::getGcalCell(int index) {
   return m_gcalCell_list(index);
}

inline GcalCellList &GapEMcal::getGcalCells() {
   return m_gcalCell_list;
}

inline GcalCellList GapEMcal::addGcalCells(int count, int start) {
   return m_gcalCell_list.add(count,start);
}

inline void GapEMcal::deleteGcalCells(int count, int start) {
   m_gcalCell_list.del(count,start);
}

inline GcalTruthShower &GapEMcal::getGcalTruthShower(int index) {
   return m_gcalTruthShower_list(index);
}

inline GcalTruthShowerList &GapEMcal::getGcalTruthShowers() {
   return m_gcalTruthShower_list;
}

inline GcalTruthShowerList GapEMcal::addGcalTruthShowers(int count, int start) {
   return m_gcalTruthShower_list.add(count,start);
}

inline void GapEMcal::deleteGcalTruthShowers(int count, int start) {
   m_gcalTruthShower_list.del(count,start);
}

inline CereHit::CereHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_pe(0),
   m_t(0)
{}

inline CereHit::~CereHit() {}

inline std::string CereHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CereHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CereHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CereHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CereHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int CereHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int CereHit::getSector() const {
   return *(int*)m_parent->getAttribute("sector");
}

inline std::string CereHit::getMaxOccurs() const {
   return "unbounded";
}

inline float CereHit::getPe() const {
   return m_pe;
}

inline void CereHit::setPe(float pe) {
   m_pe = pe;
}

inline float CereHit::getT() const {
   return m_t;
}

inline void CereHit::setT(float t) {
   m_t = t;
}

inline const void *CereHit::getAttribute(const std::string &name) const {
   return (name == "pe")? &m_pe:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline CereSection::CereSection(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_sector(0),
   m_cereHit_list(&m_host->m_cereHit_plist,
               m_host->m_cereHit_plist.end(),
               m_host->m_cereHit_plist.end(),
               this)
{}

inline CereSection::~CereSection() {
   deleteCereHits();
}

inline std::string CereSection::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CereSection::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CereSection::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CereSection::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CereSection::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline std::string CereSection::getMaxOccurs() const {
   return "unbounded";
}

inline int CereSection::getMinOccurs() const {
   return 0;
}

inline int CereSection::getSector() const {
   return m_sector;
}

inline void CereSection::setSector(int sector) {
   m_sector = sector;
}

inline const void *CereSection::getAttribute(const std::string &name) const {
   return (name == "sector")? &m_sector:
          m_parent->getAttribute(name);
}

inline CereHit &CereSection::getCereHit(int index) {
   return m_cereHit_list(index);
}

inline CereHitList &CereSection::getCereHits() {
   return m_cereHit_list;
}

inline CereHitList CereSection::addCereHits(int count, int start) {
   return m_cereHit_list.add(count,start);
}

inline void CereSection::deleteCereHits(int count, int start) {
   m_cereHit_list.del(count,start);
}

inline CereTruthPoint::CereTruthPoint(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_t(0),
   m_track(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline CereTruthPoint::~CereTruthPoint() {}

inline std::string CereTruthPoint::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CereTruthPoint::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CereTruthPoint::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CereTruthPoint::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CereTruthPoint::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float CereTruthPoint::getE() const {
   return m_E;
}

inline void CereTruthPoint::setE(float E) {
   m_E = E;
}

inline std::string CereTruthPoint::getMaxOccurs() const {
   return "unbounded";
}

inline int CereTruthPoint::getMinOccurs() const {
   return 0;
}

inline bool CereTruthPoint::getPrimary() const {
   return m_primary;
}

inline void CereTruthPoint::setPrimary(bool primary) {
   m_primary = primary;
}

inline int CereTruthPoint::getPtype() const {
   return m_ptype;
}

inline void CereTruthPoint::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float CereTruthPoint::getPx() const {
   return m_px;
}

inline void CereTruthPoint::setPx(float px) {
   m_px = px;
}

inline float CereTruthPoint::getPy() const {
   return m_py;
}

inline void CereTruthPoint::setPy(float py) {
   m_py = py;
}

inline float CereTruthPoint::getPz() const {
   return m_pz;
}

inline void CereTruthPoint::setPz(float pz) {
   m_pz = pz;
}

inline float CereTruthPoint::getT() const {
   return m_t;
}

inline void CereTruthPoint::setT(float t) {
   m_t = t;
}

inline int CereTruthPoint::getTrack() const {
   return m_track;
}

inline void CereTruthPoint::setTrack(int track) {
   m_track = track;
}

inline float CereTruthPoint::getX() const {
   return m_x;
}

inline void CereTruthPoint::setX(float x) {
   m_x = x;
}

inline float CereTruthPoint::getY() const {
   return m_y;
}

inline void CereTruthPoint::setY(float y) {
   m_y = y;
}

inline float CereTruthPoint::getZ() const {
   return m_z;
}

inline void CereTruthPoint::setZ(float z) {
   m_z = z;
}

inline const void *CereTruthPoint::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline Cerenkov::Cerenkov(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_cereSection_list(&m_host->m_cereSection_plist,
               m_host->m_cereSection_plist.end(),
               m_host->m_cereSection_plist.end(),
               this),
   m_cereTruthPoint_list(&m_host->m_cereTruthPoint_plist,
               m_host->m_cereTruthPoint_plist.end(),
               m_host->m_cereTruthPoint_plist.end(),
               this)
{}

inline Cerenkov::~Cerenkov() {
   deleteCereSections();
   deleteCereTruthPoints();
}

inline std::string Cerenkov::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Cerenkov::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Cerenkov::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Cerenkov::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string Cerenkov::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int Cerenkov::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int Cerenkov::getMinOccurs() const {
   return 0;
}

inline const void *Cerenkov::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline CereSection &Cerenkov::getCereSection(int index) {
   return m_cereSection_list(index);
}

inline CereSectionList &Cerenkov::getCereSections() {
   return m_cereSection_list;
}

inline CereSectionList Cerenkov::addCereSections(int count, int start) {
   return m_cereSection_list.add(count,start);
}

inline void Cerenkov::deleteCereSections(int count, int start) {
   m_cereSection_list.del(count,start);
}

inline CereTruthPoint &Cerenkov::getCereTruthPoint(int index) {
   return m_cereTruthPoint_list(index);
}

inline CereTruthPointList &Cerenkov::getCereTruthPoints() {
   return m_cereTruthPoint_list;
}

inline CereTruthPointList Cerenkov::addCereTruthPoints(int count, int start) {
   return m_cereTruthPoint_list.add(count,start);
}

inline void Cerenkov::deleteCereTruthPoints(int count, int start) {
   m_cereTruthPoint_list.del(count,start);
}

inline RichHit::RichHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_t(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline RichHit::~RichHit() {}

inline std::string RichHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float RichHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string RichHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int RichHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int RichHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline std::string RichHit::getMaxOccurs() const {
   return "unbounded";
}

inline int RichHit::getMinOccurs() const {
   return 0;
}

inline float RichHit::getT() const {
   return m_t;
}

inline void RichHit::setT(float t) {
   m_t = t;
}

inline float RichHit::getX() const {
   return m_x;
}

inline void RichHit::setX(float x) {
   m_x = x;
}

inline float RichHit::getY() const {
   return m_y;
}

inline void RichHit::setY(float y) {
   m_y = y;
}

inline float RichHit::getZ() const {
   return m_z;
}

inline void RichHit::setZ(float z) {
   m_z = z;
}

inline const void *RichHit::getAttribute(const std::string &name) const {
   return (name == "t")? &m_t:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline RichTruthPoint::RichTruthPoint(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_t(0),
   m_track(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline RichTruthPoint::~RichTruthPoint() {}

inline std::string RichTruthPoint::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float RichTruthPoint::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string RichTruthPoint::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int RichTruthPoint::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int RichTruthPoint::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float RichTruthPoint::getE() const {
   return m_E;
}

inline void RichTruthPoint::setE(float E) {
   m_E = E;
}

inline std::string RichTruthPoint::getMaxOccurs() const {
   return "unbounded";
}

inline int RichTruthPoint::getMinOccurs() const {
   return 0;
}

inline bool RichTruthPoint::getPrimary() const {
   return m_primary;
}

inline void RichTruthPoint::setPrimary(bool primary) {
   m_primary = primary;
}

inline int RichTruthPoint::getPtype() const {
   return m_ptype;
}

inline void RichTruthPoint::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float RichTruthPoint::getPx() const {
   return m_px;
}

inline void RichTruthPoint::setPx(float px) {
   m_px = px;
}

inline float RichTruthPoint::getPy() const {
   return m_py;
}

inline void RichTruthPoint::setPy(float py) {
   m_py = py;
}

inline float RichTruthPoint::getPz() const {
   return m_pz;
}

inline void RichTruthPoint::setPz(float pz) {
   m_pz = pz;
}

inline float RichTruthPoint::getT() const {
   return m_t;
}

inline void RichTruthPoint::setT(float t) {
   m_t = t;
}

inline int RichTruthPoint::getTrack() const {
   return m_track;
}

inline void RichTruthPoint::setTrack(int track) {
   m_track = track;
}

inline float RichTruthPoint::getX() const {
   return m_x;
}

inline void RichTruthPoint::setX(float x) {
   m_x = x;
}

inline float RichTruthPoint::getY() const {
   return m_y;
}

inline void RichTruthPoint::setY(float y) {
   m_y = y;
}

inline float RichTruthPoint::getZ() const {
   return m_z;
}

inline void RichTruthPoint::setZ(float z) {
   m_z = z;
}

inline const void *RichTruthPoint::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline RICH::RICH(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_richHit_list(&m_host->m_richHit_plist,
               m_host->m_richHit_plist.end(),
               m_host->m_richHit_plist.end(),
               this),
   m_richTruthPoint_list(&m_host->m_richTruthPoint_plist,
               m_host->m_richTruthPoint_plist.end(),
               m_host->m_richTruthPoint_plist.end(),
               this)
{}

inline RICH::~RICH() {
   deleteRichHits();
   deleteRichTruthPoints();
}

inline std::string RICH::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float RICH::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string RICH::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int RICH::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string RICH::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int RICH::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int RICH::getMinOccurs() const {
   return 0;
}

inline const void *RICH::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline RichHit &RICH::getRichHit(int index) {
   return m_richHit_list(index);
}

inline RichHitList &RICH::getRichHits() {
   return m_richHit_list;
}

inline RichHitList RICH::addRichHits(int count, int start) {
   return m_richHit_list.add(count,start);
}

inline void RICH::deleteRichHits(int count, int start) {
   m_richHit_list.del(count,start);
}

inline RichTruthPoint &RICH::getRichTruthPoint(int index) {
   return m_richTruthPoint_list(index);
}

inline RichTruthPointList &RICH::getRichTruthPoints() {
   return m_richTruthPoint_list;
}

inline RichTruthPointList RICH::addRichTruthPoints(int count, int start) {
   return m_richTruthPoint_list.add(count,start);
}

inline void RICH::deleteRichTruthPoints(int count, int start) {
   m_richTruthPoint_list.del(count,start);
}

inline FtofMCHit::FtofMCHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_dist(0),
   m_itrack(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline FtofMCHit::~FtofMCHit() {}

inline std::string FtofMCHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FtofMCHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FtofMCHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FtofMCHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FtofMCHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FtofMCHit::getBar() const {
   return *(int*)m_parent->getAttribute("bar");
}

inline int FtofMCHit::getPlane() const {
   return *(int*)m_parent->getAttribute("plane");
}

inline float FtofMCHit::getDE() const {
   return *(float*)m_parent->getAttribute("dE");
}

inline float FtofMCHit::getT() const {
   return *(float*)m_parent->getAttribute("t");
}

inline float FtofMCHit::getE() const {
   return m_E;
}

inline void FtofMCHit::setE(float E) {
   m_E = E;
}

inline float FtofMCHit::getDist() const {
   return m_dist;
}

inline void FtofMCHit::setDist(float dist) {
   m_dist = dist;
}

inline int FtofMCHit::getItrack() const {
   return m_itrack;
}

inline void FtofMCHit::setItrack(int itrack) {
   m_itrack = itrack;
}

inline std::string FtofMCHit::getMaxOccurs() const {
   return "unbounded";
}

inline int FtofMCHit::getMinOccurs() const {
   return 0;
}

inline int FtofMCHit::getPtype() const {
   return m_ptype;
}

inline void FtofMCHit::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float FtofMCHit::getPx() const {
   return m_px;
}

inline void FtofMCHit::setPx(float px) {
   m_px = px;
}

inline float FtofMCHit::getPy() const {
   return m_py;
}

inline void FtofMCHit::setPy(float py) {
   m_py = py;
}

inline float FtofMCHit::getPz() const {
   return m_pz;
}

inline void FtofMCHit::setPz(float pz) {
   m_pz = pz;
}

inline float FtofMCHit::getX() const {
   return m_x;
}

inline void FtofMCHit::setX(float x) {
   m_x = x;
}

inline float FtofMCHit::getY() const {
   return m_y;
}

inline void FtofMCHit::setY(float y) {
   m_y = y;
}

inline float FtofMCHit::getZ() const {
   return m_z;
}

inline void FtofMCHit::setZ(float z) {
   m_z = z;
}

inline const void *FtofMCHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "dist")? &m_dist:
          (name == "itrack")? &m_itrack:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline FtofNorthTruthHit::FtofNorthTruthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_dE(0),
   m_t(0),
   m_ftofMCHit_list(&m_host->m_ftofMCHit_plist,
               m_host->m_ftofMCHit_plist.end(),
               m_host->m_ftofMCHit_plist.end(),
               this)
{}

inline FtofNorthTruthHit::~FtofNorthTruthHit() {
   deleteFtofMCHits();
}

inline std::string FtofNorthTruthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FtofNorthTruthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FtofNorthTruthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FtofNorthTruthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FtofNorthTruthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FtofNorthTruthHit::getBar() const {
   return *(int*)m_parent->getAttribute("bar");
}

inline int FtofNorthTruthHit::getPlane() const {
   return *(int*)m_parent->getAttribute("plane");
}

inline float FtofNorthTruthHit::getDE() const {
   return m_dE;
}

inline void FtofNorthTruthHit::setDE(float dE) {
   m_dE = dE;
}

inline std::string FtofNorthTruthHit::getMaxOccurs() const {
   return "unbounded";
}

inline int FtofNorthTruthHit::getMinOccurs() const {
   return 0;
}

inline float FtofNorthTruthHit::getT() const {
   return m_t;
}

inline void FtofNorthTruthHit::setT(float t) {
   m_t = t;
}

inline const void *FtofNorthTruthHit::getAttribute(const std::string &name) const {
   return (name == "dE")? &m_dE:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline FtofMCHit &FtofNorthTruthHit::getFtofMCHit(int index) {
   return m_ftofMCHit_list(index);
}

inline FtofMCHitList &FtofNorthTruthHit::getFtofMCHits() {
   return m_ftofMCHit_list;
}

inline FtofMCHitList FtofNorthTruthHit::addFtofMCHits(int count, int start) {
   return m_ftofMCHit_list.add(count,start);
}

inline void FtofNorthTruthHit::deleteFtofMCHits(int count, int start) {
   m_ftofMCHit_list.del(count,start);
}

inline FtofSouthTruthHit::FtofSouthTruthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_dE(0),
   m_t(0),
   m_ftofMCHit_list(&m_host->m_ftofMCHit_plist,
               m_host->m_ftofMCHit_plist.end(),
               m_host->m_ftofMCHit_plist.end(),
               this)
{}

inline FtofSouthTruthHit::~FtofSouthTruthHit() {
   deleteFtofMCHits();
}

inline std::string FtofSouthTruthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FtofSouthTruthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FtofSouthTruthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FtofSouthTruthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FtofSouthTruthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FtofSouthTruthHit::getBar() const {
   return *(int*)m_parent->getAttribute("bar");
}

inline int FtofSouthTruthHit::getPlane() const {
   return *(int*)m_parent->getAttribute("plane");
}

inline float FtofSouthTruthHit::getDE() const {
   return m_dE;
}

inline void FtofSouthTruthHit::setDE(float dE) {
   m_dE = dE;
}

inline std::string FtofSouthTruthHit::getMaxOccurs() const {
   return "unbounded";
}

inline int FtofSouthTruthHit::getMinOccurs() const {
   return 0;
}

inline float FtofSouthTruthHit::getT() const {
   return m_t;
}

inline void FtofSouthTruthHit::setT(float t) {
   m_t = t;
}

inline const void *FtofSouthTruthHit::getAttribute(const std::string &name) const {
   return (name == "dE")? &m_dE:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline FtofMCHit &FtofSouthTruthHit::getFtofMCHit(int index) {
   return m_ftofMCHit_list(index);
}

inline FtofMCHitList &FtofSouthTruthHit::getFtofMCHits() {
   return m_ftofMCHit_list;
}

inline FtofMCHitList FtofSouthTruthHit::addFtofMCHits(int count, int start) {
   return m_ftofMCHit_list.add(count,start);
}

inline void FtofSouthTruthHit::deleteFtofMCHits(int count, int start) {
   m_ftofMCHit_list.del(count,start);
}

inline FtofNorthHit::FtofNorthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_dE(0),
   m_t(0)
{}

inline FtofNorthHit::~FtofNorthHit() {}

inline std::string FtofNorthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FtofNorthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FtofNorthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FtofNorthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FtofNorthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FtofNorthHit::getBar() const {
   return *(int*)m_parent->getAttribute("bar");
}

inline int FtofNorthHit::getPlane() const {
   return *(int*)m_parent->getAttribute("plane");
}

inline float FtofNorthHit::getDE() const {
   return m_dE;
}

inline void FtofNorthHit::setDE(float dE) {
   m_dE = dE;
}

inline std::string FtofNorthHit::getMaxOccurs() const {
   return "unbounded";
}

inline int FtofNorthHit::getMinOccurs() const {
   return 0;
}

inline float FtofNorthHit::getT() const {
   return m_t;
}

inline void FtofNorthHit::setT(float t) {
   m_t = t;
}

inline const void *FtofNorthHit::getAttribute(const std::string &name) const {
   return (name == "dE")? &m_dE:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline FtofSouthHit::FtofSouthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_dE(0),
   m_t(0)
{}

inline FtofSouthHit::~FtofSouthHit() {}

inline std::string FtofSouthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FtofSouthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FtofSouthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FtofSouthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FtofSouthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FtofSouthHit::getBar() const {
   return *(int*)m_parent->getAttribute("bar");
}

inline int FtofSouthHit::getPlane() const {
   return *(int*)m_parent->getAttribute("plane");
}

inline float FtofSouthHit::getDE() const {
   return m_dE;
}

inline void FtofSouthHit::setDE(float dE) {
   m_dE = dE;
}

inline std::string FtofSouthHit::getMaxOccurs() const {
   return "unbounded";
}

inline int FtofSouthHit::getMinOccurs() const {
   return 0;
}

inline float FtofSouthHit::getT() const {
   return m_t;
}

inline void FtofSouthHit::setT(float t) {
   m_t = t;
}

inline const void *FtofSouthHit::getAttribute(const std::string &name) const {
   return (name == "dE")? &m_dE:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline FtofCounter::FtofCounter(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_bar(0),
   m_plane(0),
   m_ftofNorthTruthHit_list(&m_host->m_ftofNorthTruthHit_plist,
               m_host->m_ftofNorthTruthHit_plist.end(),
               m_host->m_ftofNorthTruthHit_plist.end(),
               this),
   m_ftofSouthTruthHit_list(&m_host->m_ftofSouthTruthHit_plist,
               m_host->m_ftofSouthTruthHit_plist.end(),
               m_host->m_ftofSouthTruthHit_plist.end(),
               this),
   m_ftofNorthHit_list(&m_host->m_ftofNorthHit_plist,
               m_host->m_ftofNorthHit_plist.end(),
               m_host->m_ftofNorthHit_plist.end(),
               this),
   m_ftofSouthHit_list(&m_host->m_ftofSouthHit_plist,
               m_host->m_ftofSouthHit_plist.end(),
               m_host->m_ftofSouthHit_plist.end(),
               this)
{}

inline FtofCounter::~FtofCounter() {
   deleteFtofNorthTruthHits();
   deleteFtofSouthTruthHits();
   deleteFtofNorthHits();
   deleteFtofSouthHits();
}

inline std::string FtofCounter::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FtofCounter::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FtofCounter::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FtofCounter::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FtofCounter::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FtofCounter::getBar() const {
   return m_bar;
}

inline void FtofCounter::setBar(int bar) {
   m_bar = bar;
}

inline std::string FtofCounter::getMaxOccurs() const {
   return "unbounded";
}

inline int FtofCounter::getMinOccurs() const {
   return 0;
}

inline int FtofCounter::getPlane() const {
   return m_plane;
}

inline void FtofCounter::setPlane(int plane) {
   m_plane = plane;
}

inline const void *FtofCounter::getAttribute(const std::string &name) const {
   return (name == "bar")? &m_bar:
          (name == "plane")? &m_plane:
          m_parent->getAttribute(name);
}

inline FtofNorthTruthHit &FtofCounter::getFtofNorthTruthHit(int index) {
   return m_ftofNorthTruthHit_list(index);
}

inline FtofNorthTruthHitList &FtofCounter::getFtofNorthTruthHits() {
   return m_ftofNorthTruthHit_list;
}

inline FtofNorthTruthHitList FtofCounter::addFtofNorthTruthHits(int count, int start) {
   return m_ftofNorthTruthHit_list.add(count,start);
}

inline void FtofCounter::deleteFtofNorthTruthHits(int count, int start) {
   m_ftofNorthTruthHit_list.del(count,start);
}

inline FtofSouthTruthHit &FtofCounter::getFtofSouthTruthHit(int index) {
   return m_ftofSouthTruthHit_list(index);
}

inline FtofSouthTruthHitList &FtofCounter::getFtofSouthTruthHits() {
   return m_ftofSouthTruthHit_list;
}

inline FtofSouthTruthHitList FtofCounter::addFtofSouthTruthHits(int count, int start) {
   return m_ftofSouthTruthHit_list.add(count,start);
}

inline void FtofCounter::deleteFtofSouthTruthHits(int count, int start) {
   m_ftofSouthTruthHit_list.del(count,start);
}

inline FtofNorthHit &FtofCounter::getFtofNorthHit(int index) {
   return m_ftofNorthHit_list(index);
}

inline FtofNorthHitList &FtofCounter::getFtofNorthHits() {
   return m_ftofNorthHit_list;
}

inline FtofNorthHitList FtofCounter::addFtofNorthHits(int count, int start) {
   return m_ftofNorthHit_list.add(count,start);
}

inline void FtofCounter::deleteFtofNorthHits(int count, int start) {
   m_ftofNorthHit_list.del(count,start);
}

inline FtofSouthHit &FtofCounter::getFtofSouthHit(int index) {
   return m_ftofSouthHit_list(index);
}

inline FtofSouthHitList &FtofCounter::getFtofSouthHits() {
   return m_ftofSouthHit_list;
}

inline FtofSouthHitList FtofCounter::addFtofSouthHits(int count, int start) {
   return m_ftofSouthHit_list.add(count,start);
}

inline void FtofCounter::deleteFtofSouthHits(int count, int start) {
   m_ftofSouthHit_list.del(count,start);
}

inline FtofTruthPoint::FtofTruthPoint(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_t(0),
   m_track(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline FtofTruthPoint::~FtofTruthPoint() {}

inline std::string FtofTruthPoint::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FtofTruthPoint::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FtofTruthPoint::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FtofTruthPoint::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FtofTruthPoint::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float FtofTruthPoint::getE() const {
   return m_E;
}

inline void FtofTruthPoint::setE(float E) {
   m_E = E;
}

inline std::string FtofTruthPoint::getMaxOccurs() const {
   return "unbounded";
}

inline int FtofTruthPoint::getMinOccurs() const {
   return 0;
}

inline bool FtofTruthPoint::getPrimary() const {
   return m_primary;
}

inline void FtofTruthPoint::setPrimary(bool primary) {
   m_primary = primary;
}

inline int FtofTruthPoint::getPtype() const {
   return m_ptype;
}

inline void FtofTruthPoint::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float FtofTruthPoint::getPx() const {
   return m_px;
}

inline void FtofTruthPoint::setPx(float px) {
   m_px = px;
}

inline float FtofTruthPoint::getPy() const {
   return m_py;
}

inline void FtofTruthPoint::setPy(float py) {
   m_py = py;
}

inline float FtofTruthPoint::getPz() const {
   return m_pz;
}

inline void FtofTruthPoint::setPz(float pz) {
   m_pz = pz;
}

inline float FtofTruthPoint::getT() const {
   return m_t;
}

inline void FtofTruthPoint::setT(float t) {
   m_t = t;
}

inline int FtofTruthPoint::getTrack() const {
   return m_track;
}

inline void FtofTruthPoint::setTrack(int track) {
   m_track = track;
}

inline float FtofTruthPoint::getX() const {
   return m_x;
}

inline void FtofTruthPoint::setX(float x) {
   m_x = x;
}

inline float FtofTruthPoint::getY() const {
   return m_y;
}

inline void FtofTruthPoint::setY(float y) {
   m_y = y;
}

inline float FtofTruthPoint::getZ() const {
   return m_z;
}

inline void FtofTruthPoint::setZ(float z) {
   m_z = z;
}

inline const void *FtofTruthPoint::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline ForwardTOF::ForwardTOF(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_ftofCounter_list(&m_host->m_ftofCounter_plist,
               m_host->m_ftofCounter_plist.end(),
               m_host->m_ftofCounter_plist.end(),
               this),
   m_ftofTruthPoint_list(&m_host->m_ftofTruthPoint_plist,
               m_host->m_ftofTruthPoint_plist.end(),
               m_host->m_ftofTruthPoint_plist.end(),
               this)
{}

inline ForwardTOF::~ForwardTOF() {
   deleteFtofCounters();
   deleteFtofTruthPoints();
}

inline std::string ForwardTOF::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float ForwardTOF::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string ForwardTOF::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int ForwardTOF::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string ForwardTOF::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int ForwardTOF::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int ForwardTOF::getMinOccurs() const {
   return 0;
}

inline const void *ForwardTOF::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline FtofCounter &ForwardTOF::getFtofCounter(int index) {
   return m_ftofCounter_list(index);
}

inline FtofCounterList &ForwardTOF::getFtofCounters() {
   return m_ftofCounter_list;
}

inline FtofCounterList ForwardTOF::addFtofCounters(int count, int start) {
   return m_ftofCounter_list.add(count,start);
}

inline void ForwardTOF::deleteFtofCounters(int count, int start) {
   m_ftofCounter_list.del(count,start);
}

inline FtofTruthPoint &ForwardTOF::getFtofTruthPoint(int index) {
   return m_ftofTruthPoint_list(index);
}

inline FtofTruthPointList &ForwardTOF::getFtofTruthPoints() {
   return m_ftofTruthPoint_list;
}

inline FtofTruthPointList ForwardTOF::addFtofTruthPoints(int count, int start) {
   return m_ftofTruthPoint_list.add(count,start);
}

inline void ForwardTOF::deleteFtofTruthPoints(int count, int start) {
   m_ftofTruthPoint_list.del(count,start);
}

inline FcalHit::FcalHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline FcalHit::~FcalHit() {}

inline std::string FcalHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FcalHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FcalHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FcalHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FcalHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FcalHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int FcalHit::getColumn() const {
   return *(int*)m_parent->getAttribute("column");
}

inline int FcalHit::getRow() const {
   return *(int*)m_parent->getAttribute("row");
}

inline float FcalHit::getE() const {
   return m_E;
}

inline void FcalHit::setE(float E) {
   m_E = E;
}

inline std::string FcalHit::getMaxOccurs() const {
   return "unbounded";
}

inline float FcalHit::getT() const {
   return m_t;
}

inline void FcalHit::setT(float t) {
   m_t = t;
}

inline const void *FcalHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline FcalTruthHit::FcalTruthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline FcalTruthHit::~FcalTruthHit() {}

inline std::string FcalTruthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FcalTruthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FcalTruthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FcalTruthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FcalTruthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FcalTruthHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int FcalTruthHit::getColumn() const {
   return *(int*)m_parent->getAttribute("column");
}

inline int FcalTruthHit::getRow() const {
   return *(int*)m_parent->getAttribute("row");
}

inline float FcalTruthHit::getE() const {
   return m_E;
}

inline void FcalTruthHit::setE(float E) {
   m_E = E;
}

inline std::string FcalTruthHit::getMaxOccurs() const {
   return "unbounded";
}

inline float FcalTruthHit::getT() const {
   return m_t;
}

inline void FcalTruthHit::setT(float t) {
   m_t = t;
}

inline const void *FcalTruthHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline FcalBlock::FcalBlock(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_column(0),
   m_row(0),
   m_fcalHit_list(&m_host->m_fcalHit_plist,
               m_host->m_fcalHit_plist.end(),
               m_host->m_fcalHit_plist.end(),
               this),
   m_fcalTruthHit_list(&m_host->m_fcalTruthHit_plist,
               m_host->m_fcalTruthHit_plist.end(),
               m_host->m_fcalTruthHit_plist.end(),
               this)
{}

inline FcalBlock::~FcalBlock() {
   deleteFcalHits();
   deleteFcalTruthHits();
}

inline std::string FcalBlock::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FcalBlock::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FcalBlock::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FcalBlock::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FcalBlock::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int FcalBlock::getColumn() const {
   return m_column;
}

inline void FcalBlock::setColumn(int column) {
   m_column = column;
}

inline std::string FcalBlock::getMaxOccurs() const {
   return "unbounded";
}

inline int FcalBlock::getMinOccurs() const {
   return 0;
}

inline int FcalBlock::getRow() const {
   return m_row;
}

inline void FcalBlock::setRow(int row) {
   m_row = row;
}

inline const void *FcalBlock::getAttribute(const std::string &name) const {
   return (name == "column")? &m_column:
          (name == "row")? &m_row:
          m_parent->getAttribute(name);
}

inline FcalHit &FcalBlock::getFcalHit(int index) {
   return m_fcalHit_list(index);
}

inline FcalHitList &FcalBlock::getFcalHits() {
   return m_fcalHit_list;
}

inline FcalHitList FcalBlock::addFcalHits(int count, int start) {
   return m_fcalHit_list.add(count,start);
}

inline void FcalBlock::deleteFcalHits(int count, int start) {
   m_fcalHit_list.del(count,start);
}

inline FcalTruthHit &FcalBlock::getFcalTruthHit(int index) {
   return m_fcalTruthHit_list(index);
}

inline FcalTruthHitList &FcalBlock::getFcalTruthHits() {
   return m_fcalTruthHit_list;
}

inline FcalTruthHitList FcalBlock::addFcalTruthHits(int count, int start) {
   return m_fcalTruthHit_list.add(count,start);
}

inline void FcalBlock::deleteFcalTruthHits(int count, int start) {
   m_fcalTruthHit_list.del(count,start);
}

inline FcalTruthShower::FcalTruthShower(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_t(0),
   m_track(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline FcalTruthShower::~FcalTruthShower() {}

inline std::string FcalTruthShower::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float FcalTruthShower::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string FcalTruthShower::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int FcalTruthShower::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int FcalTruthShower::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float FcalTruthShower::getE() const {
   return m_E;
}

inline void FcalTruthShower::setE(float E) {
   m_E = E;
}

inline std::string FcalTruthShower::getMaxOccurs() const {
   return "unbounded";
}

inline int FcalTruthShower::getMinOccurs() const {
   return 0;
}

inline bool FcalTruthShower::getPrimary() const {
   return m_primary;
}

inline void FcalTruthShower::setPrimary(bool primary) {
   m_primary = primary;
}

inline int FcalTruthShower::getPtype() const {
   return m_ptype;
}

inline void FcalTruthShower::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float FcalTruthShower::getPx() const {
   return m_px;
}

inline void FcalTruthShower::setPx(float px) {
   m_px = px;
}

inline float FcalTruthShower::getPy() const {
   return m_py;
}

inline void FcalTruthShower::setPy(float py) {
   m_py = py;
}

inline float FcalTruthShower::getPz() const {
   return m_pz;
}

inline void FcalTruthShower::setPz(float pz) {
   m_pz = pz;
}

inline float FcalTruthShower::getT() const {
   return m_t;
}

inline void FcalTruthShower::setT(float t) {
   m_t = t;
}

inline int FcalTruthShower::getTrack() const {
   return m_track;
}

inline void FcalTruthShower::setTrack(int track) {
   m_track = track;
}

inline float FcalTruthShower::getX() const {
   return m_x;
}

inline void FcalTruthShower::setX(float x) {
   m_x = x;
}

inline float FcalTruthShower::getY() const {
   return m_y;
}

inline void FcalTruthShower::setY(float y) {
   m_y = y;
}

inline float FcalTruthShower::getZ() const {
   return m_z;
}

inline void FcalTruthShower::setZ(float z) {
   m_z = z;
}

inline const void *FcalTruthShower::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline ForwardEMcal::ForwardEMcal(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_fcalBlock_list(&m_host->m_fcalBlock_plist,
               m_host->m_fcalBlock_plist.end(),
               m_host->m_fcalBlock_plist.end(),
               this),
   m_fcalTruthShower_list(&m_host->m_fcalTruthShower_plist,
               m_host->m_fcalTruthShower_plist.end(),
               m_host->m_fcalTruthShower_plist.end(),
               this)
{}

inline ForwardEMcal::~ForwardEMcal() {
   deleteFcalBlocks();
   deleteFcalTruthShowers();
}

inline std::string ForwardEMcal::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float ForwardEMcal::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string ForwardEMcal::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int ForwardEMcal::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string ForwardEMcal::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int ForwardEMcal::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int ForwardEMcal::getMinOccurs() const {
   return 0;
}

inline const void *ForwardEMcal::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline FcalBlock &ForwardEMcal::getFcalBlock(int index) {
   return m_fcalBlock_list(index);
}

inline FcalBlockList &ForwardEMcal::getFcalBlocks() {
   return m_fcalBlock_list;
}

inline FcalBlockList ForwardEMcal::addFcalBlocks(int count, int start) {
   return m_fcalBlock_list.add(count,start);
}

inline void ForwardEMcal::deleteFcalBlocks(int count, int start) {
   m_fcalBlock_list.del(count,start);
}

inline FcalTruthShower &ForwardEMcal::getFcalTruthShower(int index) {
   return m_fcalTruthShower_list(index);
}

inline FcalTruthShowerList &ForwardEMcal::getFcalTruthShowers() {
   return m_fcalTruthShower_list;
}

inline FcalTruthShowerList ForwardEMcal::addFcalTruthShowers(int count, int start) {
   return m_fcalTruthShower_list.add(count,start);
}

inline void ForwardEMcal::deleteFcalTruthShowers(int count, int start) {
   m_fcalTruthShower_list.del(count,start);
}

inline CcalHit::CcalHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline CcalHit::~CcalHit() {}

inline std::string CcalHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CcalHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CcalHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CcalHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CcalHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int CcalHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int CcalHit::getColumn() const {
   return *(int*)m_parent->getAttribute("column");
}

inline int CcalHit::getRow() const {
   return *(int*)m_parent->getAttribute("row");
}

inline float CcalHit::getE() const {
   return m_E;
}

inline void CcalHit::setE(float E) {
   m_E = E;
}

inline std::string CcalHit::getMaxOccurs() const {
   return "unbounded";
}

inline float CcalHit::getT() const {
   return m_t;
}

inline void CcalHit::setT(float t) {
   m_t = t;
}

inline const void *CcalHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline CcalTruthHit::CcalTruthHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline CcalTruthHit::~CcalTruthHit() {}

inline std::string CcalTruthHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CcalTruthHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CcalTruthHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CcalTruthHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CcalTruthHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int CcalTruthHit::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline int CcalTruthHit::getColumn() const {
   return *(int*)m_parent->getAttribute("column");
}

inline int CcalTruthHit::getRow() const {
   return *(int*)m_parent->getAttribute("row");
}

inline float CcalTruthHit::getE() const {
   return m_E;
}

inline void CcalTruthHit::setE(float E) {
   m_E = E;
}

inline std::string CcalTruthHit::getMaxOccurs() const {
   return "unbounded";
}

inline float CcalTruthHit::getT() const {
   return m_t;
}

inline void CcalTruthHit::setT(float t) {
   m_t = t;
}

inline const void *CcalTruthHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline CcalBlock::CcalBlock(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_column(0),
   m_row(0),
   m_ccalHit_list(&m_host->m_ccalHit_plist,
               m_host->m_ccalHit_plist.end(),
               m_host->m_ccalHit_plist.end(),
               this),
   m_ccalTruthHit_list(&m_host->m_ccalTruthHit_plist,
               m_host->m_ccalTruthHit_plist.end(),
               m_host->m_ccalTruthHit_plist.end(),
               this)
{}

inline CcalBlock::~CcalBlock() {
   deleteCcalHits();
   deleteCcalTruthHits();
}

inline std::string CcalBlock::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CcalBlock::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CcalBlock::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CcalBlock::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CcalBlock::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int CcalBlock::getColumn() const {
   return m_column;
}

inline void CcalBlock::setColumn(int column) {
   m_column = column;
}

inline std::string CcalBlock::getMaxOccurs() const {
   return "unbounded";
}

inline int CcalBlock::getMinOccurs() const {
   return 0;
}

inline int CcalBlock::getRow() const {
   return m_row;
}

inline void CcalBlock::setRow(int row) {
   m_row = row;
}

inline const void *CcalBlock::getAttribute(const std::string &name) const {
   return (name == "column")? &m_column:
          (name == "row")? &m_row:
          m_parent->getAttribute(name);
}

inline CcalHit &CcalBlock::getCcalHit(int index) {
   return m_ccalHit_list(index);
}

inline CcalHitList &CcalBlock::getCcalHits() {
   return m_ccalHit_list;
}

inline CcalHitList CcalBlock::addCcalHits(int count, int start) {
   return m_ccalHit_list.add(count,start);
}

inline void CcalBlock::deleteCcalHits(int count, int start) {
   m_ccalHit_list.del(count,start);
}

inline CcalTruthHit &CcalBlock::getCcalTruthHit(int index) {
   return m_ccalTruthHit_list(index);
}

inline CcalTruthHitList &CcalBlock::getCcalTruthHits() {
   return m_ccalTruthHit_list;
}

inline CcalTruthHitList CcalBlock::addCcalTruthHits(int count, int start) {
   return m_ccalTruthHit_list.add(count,start);
}

inline void CcalBlock::deleteCcalTruthHits(int count, int start) {
   m_ccalTruthHit_list.del(count,start);
}

inline CcalTruthShower::CcalTruthShower(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_t(0),
   m_track(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline CcalTruthShower::~CcalTruthShower() {}

inline std::string CcalTruthShower::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float CcalTruthShower::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string CcalTruthShower::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int CcalTruthShower::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int CcalTruthShower::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float CcalTruthShower::getE() const {
   return m_E;
}

inline void CcalTruthShower::setE(float E) {
   m_E = E;
}

inline std::string CcalTruthShower::getMaxOccurs() const {
   return "unbounded";
}

inline int CcalTruthShower::getMinOccurs() const {
   return 0;
}

inline bool CcalTruthShower::getPrimary() const {
   return m_primary;
}

inline void CcalTruthShower::setPrimary(bool primary) {
   m_primary = primary;
}

inline int CcalTruthShower::getPtype() const {
   return m_ptype;
}

inline void CcalTruthShower::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float CcalTruthShower::getPx() const {
   return m_px;
}

inline void CcalTruthShower::setPx(float px) {
   m_px = px;
}

inline float CcalTruthShower::getPy() const {
   return m_py;
}

inline void CcalTruthShower::setPy(float py) {
   m_py = py;
}

inline float CcalTruthShower::getPz() const {
   return m_pz;
}

inline void CcalTruthShower::setPz(float pz) {
   m_pz = pz;
}

inline float CcalTruthShower::getT() const {
   return m_t;
}

inline void CcalTruthShower::setT(float t) {
   m_t = t;
}

inline int CcalTruthShower::getTrack() const {
   return m_track;
}

inline void CcalTruthShower::setTrack(int track) {
   m_track = track;
}

inline float CcalTruthShower::getX() const {
   return m_x;
}

inline void CcalTruthShower::setX(float x) {
   m_x = x;
}

inline float CcalTruthShower::getY() const {
   return m_y;
}

inline void CcalTruthShower::setY(float y) {
   m_y = y;
}

inline float CcalTruthShower::getZ() const {
   return m_z;
}

inline void CcalTruthShower::setZ(float z) {
   m_z = z;
}

inline const void *CcalTruthShower::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline ComptonEMcal::ComptonEMcal(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_ccalBlock_list(&m_host->m_ccalBlock_plist,
               m_host->m_ccalBlock_plist.end(),
               m_host->m_ccalBlock_plist.end(),
               this),
   m_ccalTruthShower_list(&m_host->m_ccalTruthShower_plist,
               m_host->m_ccalTruthShower_plist.end(),
               m_host->m_ccalTruthShower_plist.end(),
               this)
{}

inline ComptonEMcal::~ComptonEMcal() {
   deleteCcalBlocks();
   deleteCcalTruthShowers();
}

inline std::string ComptonEMcal::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float ComptonEMcal::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string ComptonEMcal::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int ComptonEMcal::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string ComptonEMcal::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int ComptonEMcal::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int ComptonEMcal::getMinOccurs() const {
   return 0;
}

inline const void *ComptonEMcal::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline CcalBlock &ComptonEMcal::getCcalBlock(int index) {
   return m_ccalBlock_list(index);
}

inline CcalBlockList &ComptonEMcal::getCcalBlocks() {
   return m_ccalBlock_list;
}

inline CcalBlockList ComptonEMcal::addCcalBlocks(int count, int start) {
   return m_ccalBlock_list.add(count,start);
}

inline void ComptonEMcal::deleteCcalBlocks(int count, int start) {
   m_ccalBlock_list.del(count,start);
}

inline CcalTruthShower &ComptonEMcal::getCcalTruthShower(int index) {
   return m_ccalTruthShower_list(index);
}

inline CcalTruthShowerList &ComptonEMcal::getCcalTruthShowers() {
   return m_ccalTruthShower_list;
}

inline CcalTruthShowerList ComptonEMcal::addCcalTruthShowers(int count, int start) {
   return m_ccalTruthShower_list.add(count,start);
}

inline void ComptonEMcal::deleteCcalTruthShowers(int count, int start) {
   m_ccalTruthShower_list.del(count,start);
}

inline GamsClust::GamsClust(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_chi2(0),
   m_dime(0),
   m_id(0),
   m_t(0),
   m_type(0),
   m_x(0),
   m_xc(0),
   m_y(0),
   m_yc(0),
   m_z(0)
{}

inline GamsClust::~GamsClust() {}

inline std::string GamsClust::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float GamsClust::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string GamsClust::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int GamsClust::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int GamsClust::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float GamsClust::getE() const {
   return m_E;
}

inline void GamsClust::setE(float E) {
   m_E = E;
}

inline float GamsClust::getChi2() const {
   return m_chi2;
}

inline void GamsClust::setChi2(float chi2) {
   m_chi2 = chi2;
}

inline int GamsClust::getDime() const {
   return m_dime;
}

inline void GamsClust::setDime(int dime) {
   m_dime = dime;
}

inline int GamsClust::getId() const {
   return m_id;
}

inline void GamsClust::setId(int id) {
   m_id = id;
}

inline std::string GamsClust::getMaxOccurs() const {
   return "unbounded";
}

inline int GamsClust::getMinOccurs() const {
   return 0;
}

inline float GamsClust::getT() const {
   return m_t;
}

inline void GamsClust::setT(float t) {
   m_t = t;
}

inline int GamsClust::getType() const {
   return m_type;
}

inline void GamsClust::setType(int type) {
   m_type = type;
}

inline float GamsClust::getX() const {
   return m_x;
}

inline void GamsClust::setX(float x) {
   m_x = x;
}

inline float GamsClust::getXc() const {
   return m_xc;
}

inline void GamsClust::setXc(float xc) {
   m_xc = xc;
}

inline float GamsClust::getY() const {
   return m_y;
}

inline void GamsClust::setY(float y) {
   m_y = y;
}

inline float GamsClust::getYc() const {
   return m_yc;
}

inline void GamsClust::setYc(float yc) {
   m_yc = yc;
}

inline float GamsClust::getZ() const {
   return m_z;
}

inline void GamsClust::setZ(float z) {
   m_z = z;
}

inline const void *GamsClust::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "chi2")? &m_chi2:
          (name == "dime")? &m_dime:
          (name == "id")? &m_id:
          (name == "t")? &m_t:
          (name == "type")? &m_type:
          (name == "x")? &m_x:
          (name == "xc")? &m_xc:
          (name == "y")? &m_y:
          (name == "yc")? &m_yc:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline GamsEMcal::GamsEMcal(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_gamsClust_list(&m_host->m_gamsClust_plist,
               m_host->m_gamsClust_plist.end(),
               m_host->m_gamsClust_plist.end(),
               this)
{}

inline GamsEMcal::~GamsEMcal() {
   deleteGamsClusts();
}

inline std::string GamsEMcal::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float GamsEMcal::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string GamsEMcal::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int GamsEMcal::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string GamsEMcal::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int GamsEMcal::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int GamsEMcal::getMinOccurs() const {
   return 0;
}

inline const void *GamsEMcal::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline GamsClust &GamsEMcal::getGamsClust(int index) {
   return m_gamsClust_list(index);
}

inline GamsClustList &GamsEMcal::getGamsClusts() {
   return m_gamsClust_list;
}

inline GamsClustList GamsEMcal::addGamsClusts(int count, int start) {
   return m_gamsClust_list.add(count,start);
}

inline void GamsEMcal::deleteGamsClusts(int count, int start) {
   m_gamsClust_list.del(count,start);
}

inline UpvLeftHit::UpvLeftHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline UpvLeftHit::~UpvLeftHit() {}

inline std::string UpvLeftHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float UpvLeftHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string UpvLeftHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int UpvLeftHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int UpvLeftHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int UpvLeftHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int UpvLeftHit::getRow() const {
   return *(int*)m_parent->getAttribute("row");
}

inline float UpvLeftHit::getE() const {
   return m_E;
}

inline void UpvLeftHit::setE(float E) {
   m_E = E;
}

inline std::string UpvLeftHit::getMaxOccurs() const {
   return "unbounded";
}

inline int UpvLeftHit::getMinOccurs() const {
   return 0;
}

inline float UpvLeftHit::getT() const {
   return m_t;
}

inline void UpvLeftHit::setT(float t) {
   m_t = t;
}

inline const void *UpvLeftHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline UpvRightHit::UpvRightHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_t(0)
{}

inline UpvRightHit::~UpvRightHit() {}

inline std::string UpvRightHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float UpvRightHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string UpvRightHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int UpvRightHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int UpvRightHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int UpvRightHit::getLayer() const {
   return *(int*)m_parent->getAttribute("layer");
}

inline int UpvRightHit::getRow() const {
   return *(int*)m_parent->getAttribute("row");
}

inline float UpvRightHit::getE() const {
   return m_E;
}

inline void UpvRightHit::setE(float E) {
   m_E = E;
}

inline std::string UpvRightHit::getMaxOccurs() const {
   return "unbounded";
}

inline int UpvRightHit::getMinOccurs() const {
   return 0;
}

inline float UpvRightHit::getT() const {
   return m_t;
}

inline void UpvRightHit::setT(float t) {
   m_t = t;
}

inline const void *UpvRightHit::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline UpvPaddle::UpvPaddle(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_layer(0),
   m_row(0),
   m_upvLeftHit_list(&m_host->m_upvLeftHit_plist,
               m_host->m_upvLeftHit_plist.end(),
               m_host->m_upvLeftHit_plist.end(),
               this),
   m_upvRightHit_list(&m_host->m_upvRightHit_plist,
               m_host->m_upvRightHit_plist.end(),
               m_host->m_upvRightHit_plist.end(),
               this)
{}

inline UpvPaddle::~UpvPaddle() {
   deleteUpvLeftHits();
   deleteUpvRightHits();
}

inline std::string UpvPaddle::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float UpvPaddle::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string UpvPaddle::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int UpvPaddle::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int UpvPaddle::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int UpvPaddle::getLayer() const {
   return m_layer;
}

inline void UpvPaddle::setLayer(int layer) {
   m_layer = layer;
}

inline std::string UpvPaddle::getMaxOccurs() const {
   return "unbounded";
}

inline int UpvPaddle::getMinOccurs() const {
   return 0;
}

inline int UpvPaddle::getRow() const {
   return m_row;
}

inline void UpvPaddle::setRow(int row) {
   m_row = row;
}

inline const void *UpvPaddle::getAttribute(const std::string &name) const {
   return (name == "layer")? &m_layer:
          (name == "row")? &m_row:
          m_parent->getAttribute(name);
}

inline UpvLeftHit &UpvPaddle::getUpvLeftHit(int index) {
   return m_upvLeftHit_list(index);
}

inline UpvLeftHitList &UpvPaddle::getUpvLeftHits() {
   return m_upvLeftHit_list;
}

inline UpvLeftHitList UpvPaddle::addUpvLeftHits(int count, int start) {
   return m_upvLeftHit_list.add(count,start);
}

inline void UpvPaddle::deleteUpvLeftHits(int count, int start) {
   m_upvLeftHit_list.del(count,start);
}

inline UpvRightHit &UpvPaddle::getUpvRightHit(int index) {
   return m_upvRightHit_list(index);
}

inline UpvRightHitList &UpvPaddle::getUpvRightHits() {
   return m_upvRightHit_list;
}

inline UpvRightHitList UpvPaddle::addUpvRightHits(int count, int start) {
   return m_upvRightHit_list.add(count,start);
}

inline void UpvPaddle::deleteUpvRightHits(int count, int start) {
   m_upvRightHit_list.del(count,start);
}

inline UpvTruthShower::UpvTruthShower(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_primary(0),
   m_ptype(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_t(0),
   m_track(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline UpvTruthShower::~UpvTruthShower() {}

inline std::string UpvTruthShower::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float UpvTruthShower::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string UpvTruthShower::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int UpvTruthShower::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int UpvTruthShower::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float UpvTruthShower::getE() const {
   return m_E;
}

inline void UpvTruthShower::setE(float E) {
   m_E = E;
}

inline std::string UpvTruthShower::getMaxOccurs() const {
   return "unbounded";
}

inline int UpvTruthShower::getMinOccurs() const {
   return 0;
}

inline bool UpvTruthShower::getPrimary() const {
   return m_primary;
}

inline void UpvTruthShower::setPrimary(bool primary) {
   m_primary = primary;
}

inline int UpvTruthShower::getPtype() const {
   return m_ptype;
}

inline void UpvTruthShower::setPtype(int ptype) {
   m_ptype = ptype;
}

inline float UpvTruthShower::getPx() const {
   return m_px;
}

inline void UpvTruthShower::setPx(float px) {
   m_px = px;
}

inline float UpvTruthShower::getPy() const {
   return m_py;
}

inline void UpvTruthShower::setPy(float py) {
   m_py = py;
}

inline float UpvTruthShower::getPz() const {
   return m_pz;
}

inline void UpvTruthShower::setPz(float pz) {
   m_pz = pz;
}

inline float UpvTruthShower::getT() const {
   return m_t;
}

inline void UpvTruthShower::setT(float t) {
   m_t = t;
}

inline int UpvTruthShower::getTrack() const {
   return m_track;
}

inline void UpvTruthShower::setTrack(int track) {
   m_track = track;
}

inline float UpvTruthShower::getX() const {
   return m_x;
}

inline void UpvTruthShower::setX(float x) {
   m_x = x;
}

inline float UpvTruthShower::getY() const {
   return m_y;
}

inline void UpvTruthShower::setY(float y) {
   m_y = y;
}

inline float UpvTruthShower::getZ() const {
   return m_z;
}

inline void UpvTruthShower::setZ(float z) {
   m_z = z;
}

inline const void *UpvTruthShower::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "primary")? &m_primary:
          (name == "ptype")? &m_ptype:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline UpstreamEMveto::UpstreamEMveto(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_upvPaddle_list(&m_host->m_upvPaddle_plist,
               m_host->m_upvPaddle_plist.end(),
               m_host->m_upvPaddle_plist.end(),
               this),
   m_upvTruthShower_list(&m_host->m_upvTruthShower_plist,
               m_host->m_upvTruthShower_plist.end(),
               m_host->m_upvTruthShower_plist.end(),
               this)
{}

inline UpstreamEMveto::~UpstreamEMveto() {
   deleteUpvPaddles();
   deleteUpvTruthShowers();
}

inline std::string UpstreamEMveto::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float UpstreamEMveto::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string UpstreamEMveto::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int UpstreamEMveto::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string UpstreamEMveto::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int UpstreamEMveto::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int UpstreamEMveto::getMinOccurs() const {
   return 0;
}

inline const void *UpstreamEMveto::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline UpvPaddle &UpstreamEMveto::getUpvPaddle(int index) {
   return m_upvPaddle_list(index);
}

inline UpvPaddleList &UpstreamEMveto::getUpvPaddles() {
   return m_upvPaddle_list;
}

inline UpvPaddleList UpstreamEMveto::addUpvPaddles(int count, int start) {
   return m_upvPaddle_list.add(count,start);
}

inline void UpstreamEMveto::deleteUpvPaddles(int count, int start) {
   m_upvPaddle_list.del(count,start);
}

inline UpvTruthShower &UpstreamEMveto::getUpvTruthShower(int index) {
   return m_upvTruthShower_list(index);
}

inline UpvTruthShowerList &UpstreamEMveto::getUpvTruthShowers() {
   return m_upvTruthShower_list;
}

inline UpvTruthShowerList UpstreamEMveto::addUpvTruthShowers(int count, int start) {
   return m_upvTruthShower_list.add(count,start);
}

inline void UpstreamEMveto::deleteUpvTruthShowers(int count, int start) {
   m_upvTruthShower_list.del(count,start);
}

inline TaggerHit::TaggerHit(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_t(0)
{}

inline TaggerHit::~TaggerHit() {}

inline std::string TaggerHit::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float TaggerHit::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string TaggerHit::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int TaggerHit::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int TaggerHit::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float TaggerHit::getE() const {
   return *(float*)m_parent->getAttribute("E");
}

inline int TaggerHit::getColumn() const {
   return *(int*)m_parent->getAttribute("column");
}

inline int TaggerHit::getRow() const {
   return *(int*)m_parent->getAttribute("row");
}

inline std::string TaggerHit::getMaxOccurs() const {
   return "unbounded";
}

inline int TaggerHit::getMinOccurs() const {
   return 0;
}

inline float TaggerHit::getT() const {
   return m_t;
}

inline void TaggerHit::setT(float t) {
   m_t = t;
}

inline const void *TaggerHit::getAttribute(const std::string &name) const {
   return (name == "t")? &m_t:
          m_parent->getAttribute(name);
}

inline MicroChannel::MicroChannel(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_column(0),
   m_row(0),
   m_taggerHit_list(&m_host->m_taggerHit_plist,
               m_host->m_taggerHit_plist.end(),
               m_host->m_taggerHit_plist.end(),
               this)
{}

inline MicroChannel::~MicroChannel() {
   deleteTaggerHits();
}

inline std::string MicroChannel::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float MicroChannel::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string MicroChannel::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int MicroChannel::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int MicroChannel::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float MicroChannel::getE() const {
   return m_E;
}

inline void MicroChannel::setE(float E) {
   m_E = E;
}

inline int MicroChannel::getColumn() const {
   return m_column;
}

inline void MicroChannel::setColumn(int column) {
   m_column = column;
}

inline std::string MicroChannel::getMaxOccurs() const {
   return "unbounded";
}

inline int MicroChannel::getMinOccurs() const {
   return 0;
}

inline int MicroChannel::getRow() const {
   return m_row;
}

inline void MicroChannel::setRow(int row) {
   m_row = row;
}

inline const void *MicroChannel::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "column")? &m_column:
          (name == "row")? &m_row:
          m_parent->getAttribute(name);
}

inline TaggerHit &MicroChannel::getTaggerHit(int index) {
   return m_taggerHit_list(index);
}

inline TaggerHitList &MicroChannel::getTaggerHits() {
   return m_taggerHit_list;
}

inline TaggerHitList MicroChannel::addTaggerHits(int count, int start) {
   return m_taggerHit_list.add(count,start);
}

inline void MicroChannel::deleteTaggerHits(int count, int start) {
   m_taggerHit_list.del(count,start);
}

inline Tagger::Tagger(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_microChannel_list(&m_host->m_microChannel_plist,
               m_host->m_microChannel_plist.end(),
               m_host->m_microChannel_plist.end(),
               this)
{}

inline Tagger::~Tagger() {
   deleteMicroChannels();
}

inline std::string Tagger::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Tagger::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Tagger::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Tagger::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string Tagger::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int Tagger::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int Tagger::getMinOccurs() const {
   return 0;
}

inline const void *Tagger::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline MicroChannel &Tagger::getMicroChannel(int index) {
   return m_microChannel_list(index);
}

inline MicroChannelList &Tagger::getMicroChannels() {
   return m_microChannel_list;
}

inline MicroChannelList Tagger::addMicroChannels(int count, int start) {
   return m_microChannel_list.add(count,start);
}

inline void Tagger::deleteMicroChannels(int count, int start) {
   m_microChannel_list.del(count,start);
}

inline McTrajectoryPoint::McTrajectoryPoint(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_E(0),
   m_dE(0),
   m_mech(0),
   m_part(0),
   m_primary_track(0),
   m_px(0),
   m_py(0),
   m_pz(0),
   m_radlen(0),
   m_step(0),
   m_t(0),
   m_track(0),
   m_x(0),
   m_y(0),
   m_z(0)
{}

inline McTrajectoryPoint::~McTrajectoryPoint() {}

inline std::string McTrajectoryPoint::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float McTrajectoryPoint::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string McTrajectoryPoint::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int McTrajectoryPoint::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int McTrajectoryPoint::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float McTrajectoryPoint::getE() const {
   return m_E;
}

inline void McTrajectoryPoint::setE(float E) {
   m_E = E;
}

inline float McTrajectoryPoint::getDE() const {
   return m_dE;
}

inline void McTrajectoryPoint::setDE(float dE) {
   m_dE = dE;
}

inline std::string McTrajectoryPoint::getMaxOccurs() const {
   return "unbounded";
}

inline int McTrajectoryPoint::getMech() const {
   return m_mech;
}

inline void McTrajectoryPoint::setMech(int mech) {
   m_mech = mech;
}

inline int McTrajectoryPoint::getMinOccurs() const {
   return 0;
}

inline int McTrajectoryPoint::getPart() const {
   return m_part;
}

inline void McTrajectoryPoint::setPart(int part) {
   m_part = part;
}

inline int McTrajectoryPoint::getPrimary_track() const {
   return m_primary_track;
}

inline void McTrajectoryPoint::setPrimary_track(int primary_track) {
   m_primary_track = primary_track;
}

inline float McTrajectoryPoint::getPx() const {
   return m_px;
}

inline void McTrajectoryPoint::setPx(float px) {
   m_px = px;
}

inline float McTrajectoryPoint::getPy() const {
   return m_py;
}

inline void McTrajectoryPoint::setPy(float py) {
   m_py = py;
}

inline float McTrajectoryPoint::getPz() const {
   return m_pz;
}

inline void McTrajectoryPoint::setPz(float pz) {
   m_pz = pz;
}

inline float McTrajectoryPoint::getRadlen() const {
   return m_radlen;
}

inline void McTrajectoryPoint::setRadlen(float radlen) {
   m_radlen = radlen;
}

inline float McTrajectoryPoint::getStep() const {
   return m_step;
}

inline void McTrajectoryPoint::setStep(float step) {
   m_step = step;
}

inline float McTrajectoryPoint::getT() const {
   return m_t;
}

inline void McTrajectoryPoint::setT(float t) {
   m_t = t;
}

inline int McTrajectoryPoint::getTrack() const {
   return m_track;
}

inline void McTrajectoryPoint::setTrack(int track) {
   m_track = track;
}

inline float McTrajectoryPoint::getX() const {
   return m_x;
}

inline void McTrajectoryPoint::setX(float x) {
   m_x = x;
}

inline float McTrajectoryPoint::getY() const {
   return m_y;
}

inline void McTrajectoryPoint::setY(float y) {
   m_y = y;
}

inline float McTrajectoryPoint::getZ() const {
   return m_z;
}

inline void McTrajectoryPoint::setZ(float z) {
   m_z = z;
}

inline const void *McTrajectoryPoint::getAttribute(const std::string &name) const {
   return (name == "E")? &m_E:
          (name == "dE")? &m_dE:
          (name == "mech")? &m_mech:
          (name == "part")? &m_part:
          (name == "primary_track")? &m_primary_track:
          (name == "px")? &m_px:
          (name == "py")? &m_py:
          (name == "pz")? &m_pz:
          (name == "radlen")? &m_radlen:
          (name == "step")? &m_step:
          (name == "t")? &m_t:
          (name == "track")? &m_track:
          (name == "x")? &m_x:
          (name == "y")? &m_y:
          (name == "z")? &m_z:
          m_parent->getAttribute(name);
}

inline McTrajectory::McTrajectory(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_mcTrajectoryPoint_list(&m_host->m_mcTrajectoryPoint_plist,
               m_host->m_mcTrajectoryPoint_plist.end(),
               m_host->m_mcTrajectoryPoint_plist.end(),
               this)
{}

inline McTrajectory::~McTrajectory() {
   deleteMcTrajectoryPoints();
}

inline std::string McTrajectory::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float McTrajectory::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string McTrajectory::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int McTrajectory::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string McTrajectory::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int McTrajectory::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int McTrajectory::getMinOccurs() const {
   return 0;
}

inline const void *McTrajectory::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline McTrajectoryPoint &McTrajectory::getMcTrajectoryPoint(int index) {
   return m_mcTrajectoryPoint_list(index);
}

inline McTrajectoryPointList &McTrajectory::getMcTrajectoryPoints() {
   return m_mcTrajectoryPoint_list;
}

inline McTrajectoryPointList McTrajectory::addMcTrajectoryPoints(int count, int start) {
   return m_mcTrajectoryPoint_list.add(count,start);
}

inline void McTrajectory::deleteMcTrajectoryPoints(int count, int start) {
   m_mcTrajectoryPoint_list.del(count,start);
}

inline HitView::HitView(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_centralDC_link(&m_host->m_centralDC_plist,
               m_host->m_centralDC_plist.end(),
               m_host->m_centralDC_plist.end(),
               this),
   m_forwardDC_link(&m_host->m_forwardDC_plist,
               m_host->m_forwardDC_plist.end(),
               m_host->m_forwardDC_plist.end(),
               this),
   m_startCntr_link(&m_host->m_startCntr_plist,
               m_host->m_startCntr_plist.end(),
               m_host->m_startCntr_plist.end(),
               this),
   m_barrelEMcal_link(&m_host->m_barrelEMcal_plist,
               m_host->m_barrelEMcal_plist.end(),
               m_host->m_barrelEMcal_plist.end(),
               this),
   m_gapEMcal_link(&m_host->m_gapEMcal_plist,
               m_host->m_gapEMcal_plist.end(),
               m_host->m_gapEMcal_plist.end(),
               this),
   m_Cerenkov_link(&m_host->m_Cerenkov_plist,
               m_host->m_Cerenkov_plist.end(),
               m_host->m_Cerenkov_plist.end(),
               this),
   m_RICH_link(&m_host->m_RICH_plist,
               m_host->m_RICH_plist.end(),
               m_host->m_RICH_plist.end(),
               this),
   m_forwardTOF_link(&m_host->m_forwardTOF_plist,
               m_host->m_forwardTOF_plist.end(),
               m_host->m_forwardTOF_plist.end(),
               this),
   m_forwardEMcal_link(&m_host->m_forwardEMcal_plist,
               m_host->m_forwardEMcal_plist.end(),
               m_host->m_forwardEMcal_plist.end(),
               this),
   m_ComptonEMcal_link(&m_host->m_ComptonEMcal_plist,
               m_host->m_ComptonEMcal_plist.end(),
               m_host->m_ComptonEMcal_plist.end(),
               this),
   m_gamsEMcal_link(&m_host->m_gamsEMcal_plist,
               m_host->m_gamsEMcal_plist.end(),
               m_host->m_gamsEMcal_plist.end(),
               this),
   m_upstreamEMveto_link(&m_host->m_upstreamEMveto_plist,
               m_host->m_upstreamEMveto_plist.end(),
               m_host->m_upstreamEMveto_plist.end(),
               this),
   m_tagger_link(&m_host->m_tagger_plist,
               m_host->m_tagger_plist.end(),
               m_host->m_tagger_plist.end(),
               this),
   m_mcTrajectory_link(&m_host->m_mcTrajectory_plist,
               m_host->m_mcTrajectory_plist.end(),
               m_host->m_mcTrajectory_plist.end(),
               this)
{}

inline HitView::~HitView() {
   deleteCentralDCs();
   deleteForwardDCs();
   deleteStartCntrs();
   deleteBarrelEMcals();
   deleteGapEMcals();
   deleteCerenkovs();
   deleteRICHs();
   deleteForwardTOFs();
   deleteForwardEMcals();
   deleteComptonEMcals();
   deleteGamsEMcals();
   deleteUpstreamEMvetos();
   deleteTaggers();
   deleteMcTrajectorys();
}

inline std::string HitView::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline std::string HitView::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int HitView::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string HitView::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int HitView::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int HitView::getMinOccurs() const {
   return 0;
}

inline float HitView::getVersion() const {
   return 2.0;
}

inline const void *HitView::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline CentralDC &HitView::getCentralDC() {
   return m_centralDC_link.front();
}

inline CentralDCList &HitView::getCentralDCs() {
   return m_centralDC_link;
}

inline CentralDCList HitView::addCentralDCs(int count, int start) {
   return m_centralDC_link.add(count,start);
}

inline void HitView::deleteCentralDCs(int count, int start) {
   m_centralDC_link.del(count,start);
}

inline ForwardDC &HitView::getForwardDC() {
   return m_forwardDC_link.front();
}

inline ForwardDCList &HitView::getForwardDCs() {
   return m_forwardDC_link;
}

inline ForwardDCList HitView::addForwardDCs(int count, int start) {
   return m_forwardDC_link.add(count,start);
}

inline void HitView::deleteForwardDCs(int count, int start) {
   m_forwardDC_link.del(count,start);
}

inline StartCntr &HitView::getStartCntr() {
   return m_startCntr_link.front();
}

inline StartCntrList &HitView::getStartCntrs() {
   return m_startCntr_link;
}

inline StartCntrList HitView::addStartCntrs(int count, int start) {
   return m_startCntr_link.add(count,start);
}

inline void HitView::deleteStartCntrs(int count, int start) {
   m_startCntr_link.del(count,start);
}

inline BarrelEMcal &HitView::getBarrelEMcal() {
   return m_barrelEMcal_link.front();
}

inline BarrelEMcalList &HitView::getBarrelEMcals() {
   return m_barrelEMcal_link;
}

inline BarrelEMcalList HitView::addBarrelEMcals(int count, int start) {
   return m_barrelEMcal_link.add(count,start);
}

inline void HitView::deleteBarrelEMcals(int count, int start) {
   m_barrelEMcal_link.del(count,start);
}

inline GapEMcal &HitView::getGapEMcal() {
   return m_gapEMcal_link.front();
}

inline GapEMcalList &HitView::getGapEMcals() {
   return m_gapEMcal_link;
}

inline GapEMcalList HitView::addGapEMcals(int count, int start) {
   return m_gapEMcal_link.add(count,start);
}

inline void HitView::deleteGapEMcals(int count, int start) {
   m_gapEMcal_link.del(count,start);
}

inline Cerenkov &HitView::getCerenkov() {
   return m_Cerenkov_link.front();
}

inline CerenkovList &HitView::getCerenkovs() {
   return m_Cerenkov_link;
}

inline CerenkovList HitView::addCerenkovs(int count, int start) {
   return m_Cerenkov_link.add(count,start);
}

inline void HitView::deleteCerenkovs(int count, int start) {
   m_Cerenkov_link.del(count,start);
}

inline RICH &HitView::getRICH() {
   return m_RICH_link.front();
}

inline RICHList &HitView::getRICHs() {
   return m_RICH_link;
}

inline RICHList HitView::addRICHs(int count, int start) {
   return m_RICH_link.add(count,start);
}

inline void HitView::deleteRICHs(int count, int start) {
   m_RICH_link.del(count,start);
}

inline ForwardTOF &HitView::getForwardTOF() {
   return m_forwardTOF_link.front();
}

inline ForwardTOFList &HitView::getForwardTOFs() {
   return m_forwardTOF_link;
}

inline ForwardTOFList HitView::addForwardTOFs(int count, int start) {
   return m_forwardTOF_link.add(count,start);
}

inline void HitView::deleteForwardTOFs(int count, int start) {
   m_forwardTOF_link.del(count,start);
}

inline ForwardEMcal &HitView::getForwardEMcal() {
   return m_forwardEMcal_link.front();
}

inline ForwardEMcalList &HitView::getForwardEMcals() {
   return m_forwardEMcal_link;
}

inline ForwardEMcalList HitView::addForwardEMcals(int count, int start) {
   return m_forwardEMcal_link.add(count,start);
}

inline void HitView::deleteForwardEMcals(int count, int start) {
   m_forwardEMcal_link.del(count,start);
}

inline ComptonEMcal &HitView::getComptonEMcal() {
   return m_ComptonEMcal_link.front();
}

inline ComptonEMcalList &HitView::getComptonEMcals() {
   return m_ComptonEMcal_link;
}

inline ComptonEMcalList HitView::addComptonEMcals(int count, int start) {
   return m_ComptonEMcal_link.add(count,start);
}

inline void HitView::deleteComptonEMcals(int count, int start) {
   m_ComptonEMcal_link.del(count,start);
}

inline GamsEMcal &HitView::getGamsEMcal() {
   return m_gamsEMcal_link.front();
}

inline GamsEMcalList &HitView::getGamsEMcals() {
   return m_gamsEMcal_link;
}

inline GamsEMcalList HitView::addGamsEMcals(int count, int start) {
   return m_gamsEMcal_link.add(count,start);
}

inline void HitView::deleteGamsEMcals(int count, int start) {
   m_gamsEMcal_link.del(count,start);
}

inline UpstreamEMveto &HitView::getUpstreamEMveto() {
   return m_upstreamEMveto_link.front();
}

inline UpstreamEMvetoList &HitView::getUpstreamEMvetos() {
   return m_upstreamEMveto_link;
}

inline UpstreamEMvetoList HitView::addUpstreamEMvetos(int count, int start) {
   return m_upstreamEMveto_link.add(count,start);
}

inline void HitView::deleteUpstreamEMvetos(int count, int start) {
   m_upstreamEMveto_link.del(count,start);
}

inline Tagger &HitView::getTagger() {
   return m_tagger_link.front();
}

inline TaggerList &HitView::getTaggers() {
   return m_tagger_link;
}

inline TaggerList HitView::addTaggers(int count, int start) {
   return m_tagger_link.add(count,start);
}

inline void HitView::deleteTaggers(int count, int start) {
   m_tagger_link.del(count,start);
}

inline McTrajectory &HitView::getMcTrajectory() {
   return m_mcTrajectory_link.front();
}

inline McTrajectoryList &HitView::getMcTrajectorys() {
   return m_mcTrajectory_link;
}

inline McTrajectoryList HitView::addMcTrajectorys(int count, int start) {
   return m_mcTrajectory_link.add(count,start);
}

inline void HitView::deleteMcTrajectorys(int count, int start) {
   m_mcTrajectory_link.del(count,start);
}

inline ErrorMatrix::ErrorMatrix(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_Ncols(0),
   m_Nrows(0),
   m_type(""),
   m_vals("")
{}

inline ErrorMatrix::~ErrorMatrix() {}

inline std::string ErrorMatrix::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float ErrorMatrix::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string ErrorMatrix::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int ErrorMatrix::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string ErrorMatrix::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int ErrorMatrix::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int ErrorMatrix::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline float ErrorMatrix::getFOM() const {
   return *(float*)m_parent->getAttribute("FOM");
}

inline int ErrorMatrix::getNdof() const {
   return *(int*)m_parent->getAttribute("Ndof");
}

inline int ErrorMatrix::getCandidateid() const {
   return *(int*)m_parent->getAttribute("candidateid");
}

inline float ErrorMatrix::getChisq() const {
   return *(float*)m_parent->getAttribute("chisq");
}

inline int ErrorMatrix::getId() const {
   return *(int*)m_parent->getAttribute("id");
}

inline int ErrorMatrix::getTrackid() const {
   return *(int*)m_parent->getAttribute("trackid");
}

inline int ErrorMatrix::getNcols() const {
   return m_Ncols;
}

inline void ErrorMatrix::setNcols(int Ncols) {
   m_Ncols = Ncols;
}

inline int ErrorMatrix::getNrows() const {
   return m_Nrows;
}

inline void ErrorMatrix::setNrows(int Nrows) {
   m_Nrows = Nrows;
}

inline std::string ErrorMatrix::getType() const {
   return m_type;
}

inline void ErrorMatrix::setType(const std::string &type) {
   m_type = type;
}

inline std::string ErrorMatrix::getVals() const {
   return m_vals;
}

inline void ErrorMatrix::setVals(const std::string &vals) {
   m_vals = vals;
}

inline const void *ErrorMatrix::getAttribute(const std::string &name) const {
   return (name == "Ncols")? &m_Ncols:
          (name == "Nrows")? &m_Nrows:
          (name == "type")? &m_type:
          (name == "vals")? &m_vals:
          m_parent->getAttribute(name);
}

inline TrackingErrorMatrix::TrackingErrorMatrix(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_Ncols(0),
   m_Nrows(0),
   m_type(""),
   m_vals("")
{}

inline TrackingErrorMatrix::~TrackingErrorMatrix() {}

inline std::string TrackingErrorMatrix::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float TrackingErrorMatrix::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string TrackingErrorMatrix::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int TrackingErrorMatrix::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string TrackingErrorMatrix::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int TrackingErrorMatrix::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int TrackingErrorMatrix::getMinOccurs() const {
   return *(int*)m_parent->getAttribute("minOccurs");
}

inline float TrackingErrorMatrix::getFOM() const {
   return *(float*)m_parent->getAttribute("FOM");
}

inline int TrackingErrorMatrix::getNdof() const {
   return *(int*)m_parent->getAttribute("Ndof");
}

inline int TrackingErrorMatrix::getCandidateid() const {
   return *(int*)m_parent->getAttribute("candidateid");
}

inline float TrackingErrorMatrix::getChisq() const {
   return *(float*)m_parent->getAttribute("chisq");
}

inline int TrackingErrorMatrix::getId() const {
   return *(int*)m_parent->getAttribute("id");
}

inline int TrackingErrorMatrix::getTrackid() const {
   return *(int*)m_parent->getAttribute("trackid");
}

inline int TrackingErrorMatrix::getNcols() const {
   return m_Ncols;
}

inline void TrackingErrorMatrix::setNcols(int Ncols) {
   m_Ncols = Ncols;
}

inline int TrackingErrorMatrix::getNrows() const {
   return m_Nrows;
}

inline void TrackingErrorMatrix::setNrows(int Nrows) {
   m_Nrows = Nrows;
}

inline std::string TrackingErrorMatrix::getType() const {
   return m_type;
}

inline void TrackingErrorMatrix::setType(const std::string &type) {
   m_type = type;
}

inline std::string TrackingErrorMatrix::getVals() const {
   return m_vals;
}

inline void TrackingErrorMatrix::setVals(const std::string &vals) {
   m_vals = vals;
}

inline const void *TrackingErrorMatrix::getAttribute(const std::string &name) const {
   return (name == "Ncols")? &m_Ncols:
          (name == "Nrows")? &m_Nrows:
          (name == "type")? &m_type:
          (name == "vals")? &m_vals:
          m_parent->getAttribute(name);
}

inline Tracktimebased::Tracktimebased(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_FOM(0),
   m_Ndof(0),
   m_candidateid(0),
   m_chisq(0),
   m_id(0),
   m_trackid(0),
   m_momentum_link(&m_host->m_momentum_plist,
               m_host->m_momentum_plist.end(),
               m_host->m_momentum_plist.end(),
               this),
   m_properties_link(&m_host->m_properties_plist,
               m_host->m_properties_plist.end(),
               m_host->m_properties_plist.end(),
               this),
   m_origin_link(&m_host->m_origin_plist,
               m_host->m_origin_plist.end(),
               m_host->m_origin_plist.end(),
               this),
   m_errorMatrix_link(&m_host->m_errorMatrix_plist,
               m_host->m_errorMatrix_plist.end(),
               m_host->m_errorMatrix_plist.end(),
               this),
   m_TrackingErrorMatrix_link(&m_host->m_TrackingErrorMatrix_plist,
               m_host->m_TrackingErrorMatrix_plist.end(),
               m_host->m_TrackingErrorMatrix_plist.end(),
               this)
{}

inline Tracktimebased::~Tracktimebased() {
   deleteMomenta();
   deletePropertiesList();
   deleteOrigins();
   deleteErrorMatrixs();
   deleteTrackingErrorMatrixs();
}

inline std::string Tracktimebased::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float Tracktimebased::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string Tracktimebased::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int Tracktimebased::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline int Tracktimebased::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline float Tracktimebased::getFOM() const {
   return m_FOM;
}

inline void Tracktimebased::setFOM(float FOM) {
   m_FOM = FOM;
}

inline int Tracktimebased::getNdof() const {
   return m_Ndof;
}

inline void Tracktimebased::setNdof(int Ndof) {
   m_Ndof = Ndof;
}

inline int Tracktimebased::getCandidateid() const {
   return m_candidateid;
}

inline void Tracktimebased::setCandidateid(int candidateid) {
   m_candidateid = candidateid;
}

inline float Tracktimebased::getChisq() const {
   return m_chisq;
}

inline void Tracktimebased::setChisq(float chisq) {
   m_chisq = chisq;
}

inline int Tracktimebased::getId() const {
   return m_id;
}

inline void Tracktimebased::setId(int id) {
   m_id = id;
}

inline std::string Tracktimebased::getMaxOccurs() const {
   return "unbounded";
}

inline int Tracktimebased::getMinOccurs() const {
   return 0;
}

inline int Tracktimebased::getTrackid() const {
   return m_trackid;
}

inline void Tracktimebased::setTrackid(int trackid) {
   m_trackid = trackid;
}

inline const void *Tracktimebased::getAttribute(const std::string &name) const {
   return (name == "FOM")? &m_FOM:
          (name == "Ndof")? &m_Ndof:
          (name == "candidateid")? &m_candidateid:
          (name == "chisq")? &m_chisq:
          (name == "id")? &m_id:
          (name == "trackid")? &m_trackid:
          m_parent->getAttribute(name);
}

inline Momentum &Tracktimebased::getMomentum() {
   return m_momentum_link.front();
}

inline MomentumList &Tracktimebased::getMomenta() {
   return m_momentum_link;
}

inline MomentumList Tracktimebased::addMomenta(int count, int start) {
   return m_momentum_link.add(count,start);
}

inline void Tracktimebased::deleteMomenta(int count, int start) {
   m_momentum_link.del(count,start);
}

inline Properties &Tracktimebased::getProperties() {
   return m_properties_link.front();
}

inline PropertiesList &Tracktimebased::getPropertiesList() {
   return m_properties_link;
}

inline PropertiesList Tracktimebased::addPropertiesList(int count, int start) {
   return m_properties_link.add(count,start);
}

inline void Tracktimebased::deletePropertiesList(int count, int start) {
   m_properties_link.del(count,start);
}

inline Origin &Tracktimebased::getOrigin() {
   return m_origin_link.front();
}

inline OriginList &Tracktimebased::getOrigins() {
   return m_origin_link;
}

inline OriginList Tracktimebased::addOrigins(int count, int start) {
   return m_origin_link.add(count,start);
}

inline void Tracktimebased::deleteOrigins(int count, int start) {
   m_origin_link.del(count,start);
}

inline ErrorMatrix &Tracktimebased::getErrorMatrix() {
   return m_errorMatrix_link.front();
}

inline ErrorMatrixList &Tracktimebased::getErrorMatrixs() {
   return m_errorMatrix_link;
}

inline ErrorMatrixList Tracktimebased::addErrorMatrixs(int count, int start) {
   return m_errorMatrix_link.add(count,start);
}

inline void Tracktimebased::deleteErrorMatrixs(int count, int start) {
   m_errorMatrix_link.del(count,start);
}

inline TrackingErrorMatrix &Tracktimebased::getTrackingErrorMatrix() {
   return m_TrackingErrorMatrix_link.front();
}

inline TrackingErrorMatrixList &Tracktimebased::getTrackingErrorMatrixs() {
   return m_TrackingErrorMatrix_link;
}

inline TrackingErrorMatrixList Tracktimebased::addTrackingErrorMatrixs(int count, int start) {
   return m_TrackingErrorMatrix_link.add(count,start);
}

inline void Tracktimebased::deleteTrackingErrorMatrixs(int count, int start) {
   m_TrackingErrorMatrix_link.del(count,start);
}

inline ReconView::ReconView(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_tracktimebased_list(&m_host->m_tracktimebased_plist,
               m_host->m_tracktimebased_plist.end(),
               m_host->m_tracktimebased_plist.end(),
               this)
{}

inline ReconView::~ReconView() {
   deleteTracktimebaseds();
}

inline std::string ReconView::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline std::string ReconView::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int ReconView::getEventNo() const {
   return *(int*)m_parent->getAttribute("eventNo");
}

inline std::string ReconView::getMaxOccurs() const {
   return *(std::string*)m_parent->getAttribute("maxOccurs");
}

inline int ReconView::getRunNo() const {
   return *(int*)m_parent->getAttribute("runNo");
}

inline int ReconView::getMinOccurs() const {
   return 0;
}

inline float ReconView::getVersion() const {
   return 1.0;
}

inline const void *ReconView::getAttribute(const std::string &name) const {
   return m_parent->getAttribute(name);
}

inline Tracktimebased &ReconView::getTracktimebased(int index) {
   return m_tracktimebased_list(index);
}

inline TracktimebasedList &ReconView::getTracktimebaseds() {
   return m_tracktimebased_list;
}

inline TracktimebasedList ReconView::addTracktimebaseds(int count, int start) {
   return m_tracktimebased_list.add(count,start);
}

inline void ReconView::deleteTracktimebaseds(int count, int start) {
   m_tracktimebased_list.del(count,start);
}

inline PhysicsEvent::PhysicsEvent(HDDM_Element *parent)
 : HDDM_Element(parent),
   m_eventNo(0),
   m_runNo(0),
   m_reaction_list(&m_host->m_reaction_plist,
               m_host->m_reaction_plist.end(),
               m_host->m_reaction_plist.end(),
               this),
   m_hitView_link(&m_host->m_hitView_plist,
               m_host->m_hitView_plist.end(),
               m_host->m_hitView_plist.end(),
               this),
   m_reconView_link(&m_host->m_reconView_plist,
               m_host->m_reconView_plist.end(),
               m_host->m_reconView_plist.end(),
               this)
{}

inline PhysicsEvent::~PhysicsEvent() {
   deleteReactions();
   deleteHitViews();
   deleteReconViews();
}

inline std::string PhysicsEvent::getClass() const {
   return *(std::string*)m_parent->getAttribute("class");
}

inline float PhysicsEvent::getVersion() const {
   return *(float*)m_parent->getAttribute("version");
}

inline std::string PhysicsEvent::getXmlns() const {
   return *(std::string*)m_parent->getAttribute("xmlns");
}

inline int PhysicsEvent::getEventNo() const {
   return m_eventNo;
}

inline void PhysicsEvent::setEventNo(int eventNo) {
   m_eventNo = eventNo;
}

inline std::string PhysicsEvent::getMaxOccurs() const {
   return "unbounded";
}

inline int PhysicsEvent::getRunNo() const {
   return m_runNo;
}

inline void PhysicsEvent::setRunNo(int runNo) {
   m_runNo = runNo;
}

inline const void *PhysicsEvent::getAttribute(const std::string &name) const {
   return (name == "eventNo")? &m_eventNo:
          (name == "runNo")? &m_runNo:
          m_parent->getAttribute(name);
}

inline Reaction &PhysicsEvent::getReaction(int index) {
   return m_reaction_list(index);
}

inline ReactionList &PhysicsEvent::getReactions() {
   return m_reaction_list;
}

inline ReactionList PhysicsEvent::addReactions(int count, int start) {
   return m_reaction_list.add(count,start);
}

inline void PhysicsEvent::deleteReactions(int count, int start) {
   m_reaction_list.del(count,start);
}

inline HitView &PhysicsEvent::getHitView() {
   return m_hitView_link.front();
}

inline HitViewList &PhysicsEvent::getHitViews() {
   return m_hitView_link;
}

inline HitViewList PhysicsEvent::addHitViews(int count, int start) {
   return m_hitView_link.add(count,start);
}

inline void PhysicsEvent::deleteHitViews(int count, int start) {
   m_hitView_link.del(count,start);
}

inline ReconView &PhysicsEvent::getReconView() {
   return m_reconView_link.front();
}

inline ReconViewList &PhysicsEvent::getReconViews() {
   return m_reconView_link;
}

inline ReconViewList PhysicsEvent::addReconViews(int count, int start) {
   return m_reconView_link.add(count,start);
}

inline void PhysicsEvent::deleteReconViews(int count, int start) {
   m_reconView_link.del(count,start);
}

inline HDDM::HDDM()
 : HDDM_Element(),
   m_geometry_plist(),
   m_physicsEvent_plist(),
   m_geometry_link(&this->m_geometry_plist,
               this->m_geometry_plist.end(),
               this->m_geometry_plist.end(),
               this),
   m_physicsEvent_list(&this->m_physicsEvent_plist,
               this->m_physicsEvent_plist.end(),
               this->m_physicsEvent_plist.end(),
               this)
{
   m_host = this;
}

inline HDDM::~HDDM() {
   deleteGeometrys();
   deletePhysicsEvents();
}

inline std::string HDDM::getClass() const {
   return "s";
}

inline float HDDM::getVersion() const {
   return 1.0;
}

inline std::string HDDM::getXmlns() const {
   return "http://www.gluex.org/hddm";
}

inline void HDDM::clear() {
   deleteGeometrys();
   deletePhysicsEvents();
}

inline Geometry &HDDM::getGeometry() {
   return m_geometry_link.front();
}

inline GeometryList &HDDM::getGeometrys() {
   return m_geometry_link;
}

inline GeometryList HDDM::addGeometrys(int count, int start) {
   return m_geometry_link.add(count,start);
}

inline void HDDM::deleteGeometrys(int count, int start) {
   m_geometry_link.del(count,start);
}

inline PhysicsEvent &HDDM::getPhysicsEvent(int index) {
   return m_physicsEvent_list(index);
}

inline PhysicsEventList &HDDM::getPhysicsEvents() {
   return m_physicsEvent_list;
}

inline PhysicsEventList HDDM::addPhysicsEvents(int count, int start) {
   return m_physicsEvent_list.add(count,start);
}

inline void HDDM::deletePhysicsEvents(int count, int start) {
   m_physicsEvent_list.del(count,start);
}

inline CerenkovList HDDM::getCerenkovs() {
   return CerenkovList(&m_Cerenkov_plist,
                   m_Cerenkov_plist.begin(),
                   m_Cerenkov_plist.end());
}

inline ComptonEMcalList HDDM::getComptonEMcals() {
   return ComptonEMcalList(&m_ComptonEMcal_plist,
                   m_ComptonEMcal_plist.begin(),
                   m_ComptonEMcal_plist.end());
}

inline RICHList HDDM::getRICHs() {
   return RICHList(&m_RICH_plist,
                   m_RICH_plist.begin(),
                   m_RICH_plist.end());
}

inline TrackingErrorMatrixList HDDM::getTrackingErrorMatrixs() {
   return TrackingErrorMatrixList(&m_TrackingErrorMatrix_plist,
                   m_TrackingErrorMatrix_plist.begin(),
                   m_TrackingErrorMatrix_plist.end());
}

inline BarrelEMcalList HDDM::getBarrelEMcals() {
   return BarrelEMcalList(&m_barrelEMcal_plist,
                   m_barrelEMcal_plist.begin(),
                   m_barrelEMcal_plist.end());
}

inline BcalCellList HDDM::getBcalCells() {
   return BcalCellList(&m_bcalCell_plist,
                   m_bcalCell_plist.begin(),
                   m_bcalCell_plist.end());
}

inline BcalHitList HDDM::getBcalHits() {
   return BcalHitList(&m_bcalHit_plist,
                   m_bcalHit_plist.begin(),
                   m_bcalHit_plist.end());
}

inline BcalIncidentParticleList HDDM::getBcalIncidentParticles() {
   return BcalIncidentParticleList(&m_bcalIncidentParticle_plist,
                   m_bcalIncidentParticle_plist.begin(),
                   m_bcalIncidentParticle_plist.end());
}

inline BcalSiPMDownHitList HDDM::getBcalSiPMDownHits() {
   return BcalSiPMDownHitList(&m_bcalSiPMDownHit_plist,
                   m_bcalSiPMDownHit_plist.begin(),
                   m_bcalSiPMDownHit_plist.end());
}

inline BcalSiPMSpectrumList HDDM::getBcalSiPMSpectrums() {
   return BcalSiPMSpectrumList(&m_bcalSiPMSpectrum_plist,
                   m_bcalSiPMSpectrum_plist.begin(),
                   m_bcalSiPMSpectrum_plist.end());
}

inline BcalSiPMUpHitList HDDM::getBcalSiPMUpHits() {
   return BcalSiPMUpHitList(&m_bcalSiPMUpHit_plist,
                   m_bcalSiPMUpHit_plist.begin(),
                   m_bcalSiPMUpHit_plist.end());
}

inline BcalTDCHitList HDDM::getBcalTDCHits() {
   return BcalTDCHitList(&m_bcalTDCHit_plist,
                   m_bcalTDCHit_plist.begin(),
                   m_bcalTDCHit_plist.end());
}

inline BcalTruthShowerList HDDM::getBcalTruthShowers() {
   return BcalTruthShowerList(&m_bcalTruthShower_plist,
                   m_bcalTruthShower_plist.begin(),
                   m_bcalTruthShower_plist.end());
}

inline BcalfADCCellList HDDM::getBcalfADCCells() {
   return BcalfADCCellList(&m_bcalfADCCell_plist,
                   m_bcalfADCCell_plist.begin(),
                   m_bcalfADCCell_plist.end());
}

inline BcalfADCDownHitList HDDM::getBcalfADCDownHits() {
   return BcalfADCDownHitList(&m_bcalfADCDownHit_plist,
                   m_bcalfADCDownHit_plist.begin(),
                   m_bcalfADCDownHit_plist.end());
}

inline BcalfADCUpHitList HDDM::getBcalfADCUpHits() {
   return BcalfADCUpHitList(&m_bcalfADCUpHit_plist,
                   m_bcalfADCUpHit_plist.begin(),
                   m_bcalfADCUpHit_plist.end());
}

inline BeamList HDDM::getBeams() {
   return BeamList(&m_beam_plist,
                   m_beam_plist.begin(),
                   m_beam_plist.end());
}

inline CcalBlockList HDDM::getCcalBlocks() {
   return CcalBlockList(&m_ccalBlock_plist,
                   m_ccalBlock_plist.begin(),
                   m_ccalBlock_plist.end());
}

inline CcalHitList HDDM::getCcalHits() {
   return CcalHitList(&m_ccalHit_plist,
                   m_ccalHit_plist.begin(),
                   m_ccalHit_plist.end());
}

inline CcalTruthHitList HDDM::getCcalTruthHits() {
   return CcalTruthHitList(&m_ccalTruthHit_plist,
                   m_ccalTruthHit_plist.begin(),
                   m_ccalTruthHit_plist.end());
}

inline CcalTruthShowerList HDDM::getCcalTruthShowers() {
   return CcalTruthShowerList(&m_ccalTruthShower_plist,
                   m_ccalTruthShower_plist.begin(),
                   m_ccalTruthShower_plist.end());
}

inline CdcStrawList HDDM::getCdcStraws() {
   return CdcStrawList(&m_cdcStraw_plist,
                   m_cdcStraw_plist.begin(),
                   m_cdcStraw_plist.end());
}

inline CdcStrawHitList HDDM::getCdcStrawHits() {
   return CdcStrawHitList(&m_cdcStrawHit_plist,
                   m_cdcStrawHit_plist.begin(),
                   m_cdcStrawHit_plist.end());
}

inline CdcStrawTruthHitList HDDM::getCdcStrawTruthHits() {
   return CdcStrawTruthHitList(&m_cdcStrawTruthHit_plist,
                   m_cdcStrawTruthHit_plist.begin(),
                   m_cdcStrawTruthHit_plist.end());
}

inline CdcTruthPointList HDDM::getCdcTruthPoints() {
   return CdcTruthPointList(&m_cdcTruthPoint_plist,
                   m_cdcTruthPoint_plist.begin(),
                   m_cdcTruthPoint_plist.end());
}

inline CentralDCList HDDM::getCentralDCs() {
   return CentralDCList(&m_centralDC_plist,
                   m_centralDC_plist.begin(),
                   m_centralDC_plist.end());
}

inline CereHitList HDDM::getCereHits() {
   return CereHitList(&m_cereHit_plist,
                   m_cereHit_plist.begin(),
                   m_cereHit_plist.end());
}

inline CereSectionList HDDM::getCereSections() {
   return CereSectionList(&m_cereSection_plist,
                   m_cereSection_plist.begin(),
                   m_cereSection_plist.end());
}

inline CereTruthPointList HDDM::getCereTruthPoints() {
   return CereTruthPointList(&m_cereTruthPoint_plist,
                   m_cereTruthPoint_plist.begin(),
                   m_cereTruthPoint_plist.end());
}

inline ErrorMatrixList HDDM::getErrorMatrixs() {
   return ErrorMatrixList(&m_errorMatrix_plist,
                   m_errorMatrix_plist.begin(),
                   m_errorMatrix_plist.end());
}

inline FcalBlockList HDDM::getFcalBlocks() {
   return FcalBlockList(&m_fcalBlock_plist,
                   m_fcalBlock_plist.begin(),
                   m_fcalBlock_plist.end());
}

inline FcalHitList HDDM::getFcalHits() {
   return FcalHitList(&m_fcalHit_plist,
                   m_fcalHit_plist.begin(),
                   m_fcalHit_plist.end());
}

inline FcalTruthHitList HDDM::getFcalTruthHits() {
   return FcalTruthHitList(&m_fcalTruthHit_plist,
                   m_fcalTruthHit_plist.begin(),
                   m_fcalTruthHit_plist.end());
}

inline FcalTruthShowerList HDDM::getFcalTruthShowers() {
   return FcalTruthShowerList(&m_fcalTruthShower_plist,
                   m_fcalTruthShower_plist.begin(),
                   m_fcalTruthShower_plist.end());
}

inline FdcAnodeHitList HDDM::getFdcAnodeHits() {
   return FdcAnodeHitList(&m_fdcAnodeHit_plist,
                   m_fdcAnodeHit_plist.begin(),
                   m_fdcAnodeHit_plist.end());
}

inline FdcAnodeTruthHitList HDDM::getFdcAnodeTruthHits() {
   return FdcAnodeTruthHitList(&m_fdcAnodeTruthHit_plist,
                   m_fdcAnodeTruthHit_plist.begin(),
                   m_fdcAnodeTruthHit_plist.end());
}

inline FdcAnodeWireList HDDM::getFdcAnodeWires() {
   return FdcAnodeWireList(&m_fdcAnodeWire_plist,
                   m_fdcAnodeWire_plist.begin(),
                   m_fdcAnodeWire_plist.end());
}

inline FdcCathodeHitList HDDM::getFdcCathodeHits() {
   return FdcCathodeHitList(&m_fdcCathodeHit_plist,
                   m_fdcCathodeHit_plist.begin(),
                   m_fdcCathodeHit_plist.end());
}

inline FdcCathodeStripList HDDM::getFdcCathodeStrips() {
   return FdcCathodeStripList(&m_fdcCathodeStrip_plist,
                   m_fdcCathodeStrip_plist.begin(),
                   m_fdcCathodeStrip_plist.end());
}

inline FdcCathodeTruthHitList HDDM::getFdcCathodeTruthHits() {
   return FdcCathodeTruthHitList(&m_fdcCathodeTruthHit_plist,
                   m_fdcCathodeTruthHit_plist.begin(),
                   m_fdcCathodeTruthHit_plist.end());
}

inline FdcChamberList HDDM::getFdcChambers() {
   return FdcChamberList(&m_fdcChamber_plist,
                   m_fdcChamber_plist.begin(),
                   m_fdcChamber_plist.end());
}

inline FdcTruthPointList HDDM::getFdcTruthPoints() {
   return FdcTruthPointList(&m_fdcTruthPoint_plist,
                   m_fdcTruthPoint_plist.begin(),
                   m_fdcTruthPoint_plist.end());
}

inline ForwardDCList HDDM::getForwardDCs() {
   return ForwardDCList(&m_forwardDC_plist,
                   m_forwardDC_plist.begin(),
                   m_forwardDC_plist.end());
}

inline ForwardEMcalList HDDM::getForwardEMcals() {
   return ForwardEMcalList(&m_forwardEMcal_plist,
                   m_forwardEMcal_plist.begin(),
                   m_forwardEMcal_plist.end());
}

inline ForwardTOFList HDDM::getForwardTOFs() {
   return ForwardTOFList(&m_forwardTOF_plist,
                   m_forwardTOF_plist.begin(),
                   m_forwardTOF_plist.end());
}

inline FtofCounterList HDDM::getFtofCounters() {
   return FtofCounterList(&m_ftofCounter_plist,
                   m_ftofCounter_plist.begin(),
                   m_ftofCounter_plist.end());
}

inline FtofMCHitList HDDM::getFtofMCHits() {
   return FtofMCHitList(&m_ftofMCHit_plist,
                   m_ftofMCHit_plist.begin(),
                   m_ftofMCHit_plist.end());
}

inline FtofNorthHitList HDDM::getFtofNorthHits() {
   return FtofNorthHitList(&m_ftofNorthHit_plist,
                   m_ftofNorthHit_plist.begin(),
                   m_ftofNorthHit_plist.end());
}

inline FtofNorthTruthHitList HDDM::getFtofNorthTruthHits() {
   return FtofNorthTruthHitList(&m_ftofNorthTruthHit_plist,
                   m_ftofNorthTruthHit_plist.begin(),
                   m_ftofNorthTruthHit_plist.end());
}

inline FtofSouthHitList HDDM::getFtofSouthHits() {
   return FtofSouthHitList(&m_ftofSouthHit_plist,
                   m_ftofSouthHit_plist.begin(),
                   m_ftofSouthHit_plist.end());
}

inline FtofSouthTruthHitList HDDM::getFtofSouthTruthHits() {
   return FtofSouthTruthHitList(&m_ftofSouthTruthHit_plist,
                   m_ftofSouthTruthHit_plist.begin(),
                   m_ftofSouthTruthHit_plist.end());
}

inline FtofTruthPointList HDDM::getFtofTruthPoints() {
   return FtofTruthPointList(&m_ftofTruthPoint_plist,
                   m_ftofTruthPoint_plist.begin(),
                   m_ftofTruthPoint_plist.end());
}

inline GamsClustList HDDM::getGamsClusts() {
   return GamsClustList(&m_gamsClust_plist,
                   m_gamsClust_plist.begin(),
                   m_gamsClust_plist.end());
}

inline GamsEMcalList HDDM::getGamsEMcals() {
   return GamsEMcalList(&m_gamsEMcal_plist,
                   m_gamsEMcal_plist.begin(),
                   m_gamsEMcal_plist.end());
}

inline GapEMcalList HDDM::getGapEMcals() {
   return GapEMcalList(&m_gapEMcal_plist,
                   m_gapEMcal_plist.begin(),
                   m_gapEMcal_plist.end());
}

inline GcalCellList HDDM::getGcalCells() {
   return GcalCellList(&m_gcalCell_plist,
                   m_gcalCell_plist.begin(),
                   m_gcalCell_plist.end());
}

inline GcalHitList HDDM::getGcalHits() {
   return GcalHitList(&m_gcalHit_plist,
                   m_gcalHit_plist.begin(),
                   m_gcalHit_plist.end());
}

inline GcalTruthShowerList HDDM::getGcalTruthShowers() {
   return GcalTruthShowerList(&m_gcalTruthShower_plist,
                   m_gcalTruthShower_plist.begin(),
                   m_gcalTruthShower_plist.end());
}

inline HitViewList HDDM::getHitViews() {
   return HitViewList(&m_hitView_plist,
                   m_hitView_plist.begin(),
                   m_hitView_plist.end());
}

inline McTrajectoryList HDDM::getMcTrajectorys() {
   return McTrajectoryList(&m_mcTrajectory_plist,
                   m_mcTrajectory_plist.begin(),
                   m_mcTrajectory_plist.end());
}

inline McTrajectoryPointList HDDM::getMcTrajectoryPoints() {
   return McTrajectoryPointList(&m_mcTrajectoryPoint_plist,
                   m_mcTrajectoryPoint_plist.begin(),
                   m_mcTrajectoryPoint_plist.end());
}

inline MicroChannelList HDDM::getMicroChannels() {
   return MicroChannelList(&m_microChannel_plist,
                   m_microChannel_plist.begin(),
                   m_microChannel_plist.end());
}

inline MomentumList HDDM::getMomenta() {
   return MomentumList(&m_momentum_plist,
                   m_momentum_plist.begin(),
                   m_momentum_plist.end());
}

inline OriginList HDDM::getOrigins() {
   return OriginList(&m_origin_plist,
                   m_origin_plist.begin(),
                   m_origin_plist.end());
}

inline ProductList HDDM::getProducts() {
   return ProductList(&m_product_plist,
                   m_product_plist.begin(),
                   m_product_plist.end());
}

inline PropertiesList HDDM::getPropertiesList() {
   return PropertiesList(&m_properties_plist,
                   m_properties_plist.begin(),
                   m_properties_plist.end());
}

inline RandomList HDDM::getRandoms() {
   return RandomList(&m_random_plist,
                   m_random_plist.begin(),
                   m_random_plist.end());
}

inline ReactionList HDDM::getReactions() {
   return ReactionList(&m_reaction_plist,
                   m_reaction_plist.begin(),
                   m_reaction_plist.end());
}

inline ReconViewList HDDM::getReconViews() {
   return ReconViewList(&m_reconView_plist,
                   m_reconView_plist.begin(),
                   m_reconView_plist.end());
}

inline RichHitList HDDM::getRichHits() {
   return RichHitList(&m_richHit_plist,
                   m_richHit_plist.begin(),
                   m_richHit_plist.end());
}

inline RichTruthPointList HDDM::getRichTruthPoints() {
   return RichTruthPointList(&m_richTruthPoint_plist,
                   m_richTruthPoint_plist.begin(),
                   m_richTruthPoint_plist.end());
}

inline StartCntrList HDDM::getStartCntrs() {
   return StartCntrList(&m_startCntr_plist,
                   m_startCntr_plist.begin(),
                   m_startCntr_plist.end());
}

inline StcHitList HDDM::getStcHits() {
   return StcHitList(&m_stcHit_plist,
                   m_stcHit_plist.begin(),
                   m_stcHit_plist.end());
}

inline StcPaddleList HDDM::getStcPaddles() {
   return StcPaddleList(&m_stcPaddle_plist,
                   m_stcPaddle_plist.begin(),
                   m_stcPaddle_plist.end());
}

inline StcTruthHitList HDDM::getStcTruthHits() {
   return StcTruthHitList(&m_stcTruthHit_plist,
                   m_stcTruthHit_plist.begin(),
                   m_stcTruthHit_plist.end());
}

inline StcTruthPointList HDDM::getStcTruthPoints() {
   return StcTruthPointList(&m_stcTruthPoint_plist,
                   m_stcTruthPoint_plist.begin(),
                   m_stcTruthPoint_plist.end());
}

inline TaggerList HDDM::getTaggers() {
   return TaggerList(&m_tagger_plist,
                   m_tagger_plist.begin(),
                   m_tagger_plist.end());
}

inline TaggerHitList HDDM::getTaggerHits() {
   return TaggerHitList(&m_taggerHit_plist,
                   m_taggerHit_plist.begin(),
                   m_taggerHit_plist.end());
}

inline TargetList HDDM::getTargets() {
   return TargetList(&m_target_plist,
                   m_target_plist.begin(),
                   m_target_plist.end());
}

inline TracktimebasedList HDDM::getTracktimebaseds() {
   return TracktimebasedList(&m_tracktimebased_plist,
                   m_tracktimebased_plist.begin(),
                   m_tracktimebased_plist.end());
}

inline UpstreamEMvetoList HDDM::getUpstreamEMvetos() {
   return UpstreamEMvetoList(&m_upstreamEMveto_plist,
                   m_upstreamEMveto_plist.begin(),
                   m_upstreamEMveto_plist.end());
}

inline UpvLeftHitList HDDM::getUpvLeftHits() {
   return UpvLeftHitList(&m_upvLeftHit_plist,
                   m_upvLeftHit_plist.begin(),
                   m_upvLeftHit_plist.end());
}

inline UpvPaddleList HDDM::getUpvPaddles() {
   return UpvPaddleList(&m_upvPaddle_plist,
                   m_upvPaddle_plist.begin(),
                   m_upvPaddle_plist.end());
}

inline UpvRightHitList HDDM::getUpvRightHits() {
   return UpvRightHitList(&m_upvRightHit_plist,
                   m_upvRightHit_plist.begin(),
                   m_upvRightHit_plist.end());
}

inline UpvTruthShowerList HDDM::getUpvTruthShowers() {
   return UpvTruthShowerList(&m_upvTruthShower_plist,
                   m_upvTruthShower_plist.begin(),
                   m_upvTruthShower_plist.end());
}

inline VertexList HDDM::getVertices() {
   return VertexList(&m_vertex_plist,
                   m_vertex_plist.begin(),
                   m_vertex_plist.end());
}

inline void Geometry::streamer(istream &istr) {
   *istr.m_xstr >> m_md5reconstruction >> m_md5simulation >> m_md5smear;
}

inline void Geometry::streamer(ostream &ostr) {
   *ostr.m_xstr << m_md5reconstruction << m_md5simulation << m_md5smear;
}

inline void Momentum::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_px >> m_py >> m_pz;
}

inline void Momentum::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_px << m_py << m_pz;
}

inline void Properties::streamer(istream &istr) {
   *istr.m_xstr >> m_charge >> m_mass;
}

inline void Properties::streamer(ostream &ostr) {
   *ostr.m_xstr << m_charge << m_mass;
}

inline void Beam::streamer(istream &istr) {
   *istr.m_xstr >> m_type;
   istr >> m_momentum_link >> m_properties_link;
}

inline void Beam::streamer(ostream &ostr) {
   *ostr.m_xstr << m_type;
   ostr << m_momentum_link << m_properties_link;
}

inline void Target::streamer(istream &istr) {
   *istr.m_xstr >> m_type;
   istr >> m_momentum_link >> m_properties_link;
}

inline void Target::streamer(ostream &ostr) {
   *ostr.m_xstr << m_type;
   ostr << m_momentum_link << m_properties_link;
}

inline void Product::streamer(istream &istr) {
   *istr.m_xstr >> m_decayVertex >> m_id >> m_mech >> m_parentid >> m_pdgtype >> m_type;
   istr >> m_momentum_link >> m_properties_link;
}

inline void Product::streamer(ostream &ostr) {
   *ostr.m_xstr << m_decayVertex << m_id << m_mech << m_parentid << m_pdgtype << m_type;
   ostr << m_momentum_link << m_properties_link;
}

inline void Origin::streamer(istream &istr) {
   *istr.m_xstr >> m_t >> m_vx >> m_vy >> m_vz;
}

inline void Origin::streamer(ostream &ostr) {
   *ostr.m_xstr << m_t << m_vx << m_vy << m_vz;
}

inline void Vertex::streamer(istream &istr) {
   istr >> m_product_list >> m_origin_link;
}

inline void Vertex::streamer(ostream &ostr) {
   ostr << m_product_list << m_origin_link;
}

inline void Random::streamer(istream &istr) {
   *istr.m_xstr >> m_seed1 >> m_seed2 >> m_seed_mcsmear1 >> m_seed_mcsmear2 >> m_seed_mcsmear3;
}

inline void Random::streamer(ostream &ostr) {
   *ostr.m_xstr << m_seed1 << m_seed2 << m_seed_mcsmear1 << m_seed_mcsmear2 << m_seed_mcsmear3;
}

inline void Reaction::streamer(istream &istr) {
   *istr.m_xstr >> m_type >> m_weight;
   istr >> m_beam_link >> m_target_link >> m_vertex_list >> m_random_link;
}

inline void Reaction::streamer(ostream &ostr) {
   *ostr.m_xstr << m_type << m_weight;
   ostr << m_beam_link << m_target_link << m_vertex_list << m_random_link;
}

inline void CdcStrawHit::streamer(istream &istr) {
   *istr.m_xstr >> m_d >> m_itrack >> m_ptype >> m_q >> m_t;
}

inline void CdcStrawHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_d << m_itrack << m_ptype << m_q << m_t;
}

inline void CdcStrawTruthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_d >> m_itrack >> m_ptype >> m_q >> m_t;
}

inline void CdcStrawTruthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_d << m_itrack << m_ptype << m_q << m_t;
}

inline void CdcStraw::streamer(istream &istr) {
   *istr.m_xstr >> m_ring >> m_straw;
   istr >> m_cdcStrawHit_list >> m_cdcStrawTruthHit_list;
}

inline void CdcStraw::streamer(ostream &ostr) {
   *ostr.m_xstr << m_ring << m_straw;
   ostr << m_cdcStrawHit_list << m_cdcStrawTruthHit_list;
}

inline void CdcTruthPoint::streamer(istream &istr) {
   *istr.m_xstr >> m_dEdx >> m_dradius >> m_phi >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_r >> m_t >> m_track >> m_z;
}

inline void CdcTruthPoint::streamer(ostream &ostr) {
   *ostr.m_xstr << m_dEdx << m_dradius << m_phi << m_primary << m_ptype << m_px << m_py << m_pz << m_r << m_t << m_track << m_z;
}

inline void CentralDC::streamer(istream &istr) {
   istr >> m_cdcStraw_list >> m_cdcTruthPoint_list;
}

inline void CentralDC::streamer(ostream &ostr) {
   ostr << m_cdcStraw_list << m_cdcTruthPoint_list;
}

inline void FdcAnodeHit::streamer(istream &istr) {
   *istr.m_xstr >> m_d >> m_dE >> m_itrack >> m_ptype >> m_t;
}

inline void FdcAnodeHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_d << m_dE << m_itrack << m_ptype << m_t;
}

inline void FdcAnodeTruthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_d >> m_dE >> m_itrack >> m_ptype >> m_t >> m_t_unsmeared;
}

inline void FdcAnodeTruthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_d << m_dE << m_itrack << m_ptype << m_t << m_t_unsmeared;
}

inline void FdcAnodeWire::streamer(istream &istr) {
   *istr.m_xstr >> m_wire;
   istr >> m_fdcAnodeHit_list >> m_fdcAnodeTruthHit_list;
}

inline void FdcAnodeWire::streamer(ostream &ostr) {
   *ostr.m_xstr << m_wire;
   ostr << m_fdcAnodeHit_list << m_fdcAnodeTruthHit_list;
}

inline void FdcCathodeHit::streamer(istream &istr) {
   *istr.m_xstr >> m_itrack >> m_ptype >> m_q >> m_t;
}

inline void FdcCathodeHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_itrack << m_ptype << m_q << m_t;
}

inline void FdcCathodeTruthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_itrack >> m_ptype >> m_q >> m_t;
}

inline void FdcCathodeTruthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_itrack << m_ptype << m_q << m_t;
}

inline void FdcCathodeStrip::streamer(istream &istr) {
   *istr.m_xstr >> m_plane >> m_strip;
   istr >> m_fdcCathodeHit_list >> m_fdcCathodeTruthHit_list;
}

inline void FdcCathodeStrip::streamer(ostream &ostr) {
   *ostr.m_xstr << m_plane << m_strip;
   ostr << m_fdcCathodeHit_list << m_fdcCathodeTruthHit_list;
}

inline void FdcTruthPoint::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_dEdx >> m_dradius >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_t >> m_track >> m_x >> m_y >> m_z;
}

inline void FdcTruthPoint::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_dEdx << m_dradius << m_primary << m_ptype << m_px << m_py << m_pz << m_t << m_track << m_x << m_y << m_z;
}

inline void FdcChamber::streamer(istream &istr) {
   *istr.m_xstr >> m_layer >> m_module;
   istr >> m_fdcAnodeWire_list >> m_fdcCathodeStrip_list >> m_fdcTruthPoint_list;
}

inline void FdcChamber::streamer(ostream &ostr) {
   *ostr.m_xstr << m_layer << m_module;
   ostr << m_fdcAnodeWire_list << m_fdcCathodeStrip_list << m_fdcTruthPoint_list;
}

inline void ForwardDC::streamer(istream &istr) {
   istr >> m_fdcChamber_list;
}

inline void ForwardDC::streamer(ostream &ostr) {
   ostr << m_fdcChamber_list;
}

inline void StcHit::streamer(istream &istr) {
   *istr.m_xstr >> m_dE >> m_t;
}

inline void StcHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_dE << m_t;
}

inline void StcTruthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_dE >> m_t;
}

inline void StcTruthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_dE << m_t;
}

inline void StcPaddle::streamer(istream &istr) {
   *istr.m_xstr >> m_sector;
   istr >> m_stcHit_list >> m_stcTruthHit_list;
}

inline void StcPaddle::streamer(ostream &ostr) {
   *ostr.m_xstr << m_sector;
   ostr << m_stcHit_list << m_stcTruthHit_list;
}

inline void StcTruthPoint::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_dEdx >> m_phi >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_r >> m_sector >> m_t >> m_track >> m_z;
}

inline void StcTruthPoint::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_dEdx << m_phi << m_primary << m_ptype << m_px << m_py << m_pz << m_r << m_sector << m_t << m_track << m_z;
}

inline void StartCntr::streamer(istream &istr) {
   istr >> m_stcPaddle_list >> m_stcTruthPoint_list;
}

inline void StartCntr::streamer(ostream &ostr) {
   ostr << m_stcPaddle_list << m_stcTruthPoint_list;
}

inline void BcalSiPMUpHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void BcalSiPMUpHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void BcalSiPMDownHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void BcalSiPMDownHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void BcalHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t >> m_zLocal;
}

inline void BcalHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t << m_zLocal;
}

inline void BcalCell::streamer(istream &istr) {
   *istr.m_xstr >> m_layer >> m_module >> m_sector;
   istr >> m_bcalSiPMUpHit_list >> m_bcalSiPMDownHit_list >> m_bcalHit_list;
}

inline void BcalCell::streamer(ostream &ostr) {
   *ostr.m_xstr << m_layer << m_module << m_sector;
   ostr << m_bcalSiPMUpHit_list << m_bcalSiPMDownHit_list << m_bcalHit_list;
}

inline void BcalIncidentParticle::streamer(istream &istr) {
   *istr.m_xstr >> m_id >> m_ptype >> m_px >> m_py >> m_pz >> m_x >> m_y >> m_z;
}

inline void BcalIncidentParticle::streamer(ostream &ostr) {
   *ostr.m_xstr << m_id << m_ptype << m_px << m_py << m_pz << m_x << m_y << m_z;
}

inline void BcalSiPMSpectrum::streamer(istream &istr) {
   *istr.m_xstr >> m_Etruth >> m_bin_width >> m_end >> m_incident_id >> m_layer >> m_module >> m_sector >> m_tstart >> m_vals;
}

inline void BcalSiPMSpectrum::streamer(ostream &ostr) {
   *ostr.m_xstr << m_Etruth << m_bin_width << m_end << m_incident_id << m_layer << m_module << m_sector << m_tstart << m_vals;
}

inline void BcalfADCUpHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void BcalfADCUpHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void BcalfADCDownHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void BcalfADCDownHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void BcalfADCCell::streamer(istream &istr) {
   *istr.m_xstr >> m_layer >> m_module >> m_sector;
   istr >> m_bcalfADCUpHit_list >> m_bcalfADCDownHit_list;
}

inline void BcalfADCCell::streamer(ostream &ostr) {
   *ostr.m_xstr << m_layer << m_module << m_sector;
   ostr << m_bcalfADCUpHit_list << m_bcalfADCDownHit_list;
}

inline void BcalTDCHit::streamer(istream &istr) {
   *istr.m_xstr >> m_end >> m_layer >> m_module >> m_sector >> m_t;
}

inline void BcalTDCHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_end << m_layer << m_module << m_sector << m_t;
}

inline void BcalTruthShower::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_phi >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_r >> m_t >> m_track >> m_z;
}

inline void BcalTruthShower::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_phi << m_primary << m_ptype << m_px << m_py << m_pz << m_r << m_t << m_track << m_z;
}

inline void BarrelEMcal::streamer(istream &istr) {
   istr >> m_bcalCell_list >> m_bcalIncidentParticle_list >> m_bcalSiPMSpectrum_list >> m_bcalfADCCell_list >> m_bcalTDCHit_list >> m_bcalTruthShower_list;
}

inline void BarrelEMcal::streamer(ostream &ostr) {
   ostr << m_bcalCell_list << m_bcalIncidentParticle_list << m_bcalSiPMSpectrum_list << m_bcalfADCCell_list << m_bcalTDCHit_list << m_bcalTruthShower_list;
}

inline void GcalHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t >> m_zLocal;
}

inline void GcalHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t << m_zLocal;
}

inline void GcalCell::streamer(istream &istr) {
   *istr.m_xstr >> m_module;
   istr >> m_gcalHit_list;
}

inline void GcalCell::streamer(ostream &ostr) {
   *ostr.m_xstr << m_module;
   ostr << m_gcalHit_list;
}

inline void GcalTruthShower::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_phi >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_r >> m_t >> m_track >> m_z;
}

inline void GcalTruthShower::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_phi << m_primary << m_ptype << m_px << m_py << m_pz << m_r << m_t << m_track << m_z;
}

inline void GapEMcal::streamer(istream &istr) {
   istr >> m_gcalCell_list >> m_gcalTruthShower_list;
}

inline void GapEMcal::streamer(ostream &ostr) {
   ostr << m_gcalCell_list << m_gcalTruthShower_list;
}

inline void CereHit::streamer(istream &istr) {
   *istr.m_xstr >> m_pe >> m_t;
}

inline void CereHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_pe << m_t;
}

inline void CereSection::streamer(istream &istr) {
   *istr.m_xstr >> m_sector;
   istr >> m_cereHit_list;
}

inline void CereSection::streamer(ostream &ostr) {
   *ostr.m_xstr << m_sector;
   ostr << m_cereHit_list;
}

inline void CereTruthPoint::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_t >> m_track >> m_x >> m_y >> m_z;
}

inline void CereTruthPoint::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_primary << m_ptype << m_px << m_py << m_pz << m_t << m_track << m_x << m_y << m_z;
}

inline void Cerenkov::streamer(istream &istr) {
   istr >> m_cereSection_list >> m_cereTruthPoint_list;
}

inline void Cerenkov::streamer(ostream &ostr) {
   ostr << m_cereSection_list << m_cereTruthPoint_list;
}

inline void RichHit::streamer(istream &istr) {
   *istr.m_xstr >> m_t >> m_x >> m_y >> m_z;
}

inline void RichHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_t << m_x << m_y << m_z;
}

inline void RichTruthPoint::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_t >> m_track >> m_x >> m_y >> m_z;
}

inline void RichTruthPoint::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_primary << m_ptype << m_px << m_py << m_pz << m_t << m_track << m_x << m_y << m_z;
}

inline void RICH::streamer(istream &istr) {
   istr >> m_richHit_list >> m_richTruthPoint_list;
}

inline void RICH::streamer(ostream &ostr) {
   ostr << m_richHit_list << m_richTruthPoint_list;
}

inline void FtofMCHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_dist >> m_itrack >> m_ptype >> m_px >> m_py >> m_pz >> m_x >> m_y >> m_z;
}

inline void FtofMCHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_dist << m_itrack << m_ptype << m_px << m_py << m_pz << m_x << m_y << m_z;
}

inline void FtofNorthTruthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_dE >> m_t;
   istr >> m_ftofMCHit_list;
}

inline void FtofNorthTruthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_dE << m_t;
   ostr << m_ftofMCHit_list;
}

inline void FtofSouthTruthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_dE >> m_t;
   istr >> m_ftofMCHit_list;
}

inline void FtofSouthTruthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_dE << m_t;
   ostr << m_ftofMCHit_list;
}

inline void FtofNorthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_dE >> m_t;
}

inline void FtofNorthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_dE << m_t;
}

inline void FtofSouthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_dE >> m_t;
}

inline void FtofSouthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_dE << m_t;
}

inline void FtofCounter::streamer(istream &istr) {
   *istr.m_xstr >> m_bar >> m_plane;
   istr >> m_ftofNorthTruthHit_list >> m_ftofSouthTruthHit_list >> m_ftofNorthHit_list >> m_ftofSouthHit_list;
}

inline void FtofCounter::streamer(ostream &ostr) {
   *ostr.m_xstr << m_bar << m_plane;
   ostr << m_ftofNorthTruthHit_list << m_ftofSouthTruthHit_list << m_ftofNorthHit_list << m_ftofSouthHit_list;
}

inline void FtofTruthPoint::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_t >> m_track >> m_x >> m_y >> m_z;
}

inline void FtofTruthPoint::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_primary << m_ptype << m_px << m_py << m_pz << m_t << m_track << m_x << m_y << m_z;
}

inline void ForwardTOF::streamer(istream &istr) {
   istr >> m_ftofCounter_list >> m_ftofTruthPoint_list;
}

inline void ForwardTOF::streamer(ostream &ostr) {
   ostr << m_ftofCounter_list << m_ftofTruthPoint_list;
}

inline void FcalHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void FcalHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void FcalTruthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void FcalTruthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void FcalBlock::streamer(istream &istr) {
   *istr.m_xstr >> m_column >> m_row;
   istr >> m_fcalHit_list >> m_fcalTruthHit_list;
}

inline void FcalBlock::streamer(ostream &ostr) {
   *ostr.m_xstr << m_column << m_row;
   ostr << m_fcalHit_list << m_fcalTruthHit_list;
}

inline void FcalTruthShower::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_t >> m_track >> m_x >> m_y >> m_z;
}

inline void FcalTruthShower::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_primary << m_ptype << m_px << m_py << m_pz << m_t << m_track << m_x << m_y << m_z;
}

inline void ForwardEMcal::streamer(istream &istr) {
   istr >> m_fcalBlock_list >> m_fcalTruthShower_list;
}

inline void ForwardEMcal::streamer(ostream &ostr) {
   ostr << m_fcalBlock_list << m_fcalTruthShower_list;
}

inline void CcalHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void CcalHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void CcalTruthHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void CcalTruthHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void CcalBlock::streamer(istream &istr) {
   *istr.m_xstr >> m_column >> m_row;
   istr >> m_ccalHit_list >> m_ccalTruthHit_list;
}

inline void CcalBlock::streamer(ostream &ostr) {
   *ostr.m_xstr << m_column << m_row;
   ostr << m_ccalHit_list << m_ccalTruthHit_list;
}

inline void CcalTruthShower::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_t >> m_track >> m_x >> m_y >> m_z;
}

inline void CcalTruthShower::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_primary << m_ptype << m_px << m_py << m_pz << m_t << m_track << m_x << m_y << m_z;
}

inline void ComptonEMcal::streamer(istream &istr) {
   istr >> m_ccalBlock_list >> m_ccalTruthShower_list;
}

inline void ComptonEMcal::streamer(ostream &ostr) {
   ostr << m_ccalBlock_list << m_ccalTruthShower_list;
}

inline void GamsClust::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_chi2 >> m_dime >> m_id >> m_t >> m_type >> m_x >> m_xc >> m_y >> m_yc >> m_z;
}

inline void GamsClust::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_chi2 << m_dime << m_id << m_t << m_type << m_x << m_xc << m_y << m_yc << m_z;
}

inline void GamsEMcal::streamer(istream &istr) {
   istr >> m_gamsClust_list;
}

inline void GamsEMcal::streamer(ostream &ostr) {
   ostr << m_gamsClust_list;
}

inline void UpvLeftHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void UpvLeftHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void UpvRightHit::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_t;
}

inline void UpvRightHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_t;
}

inline void UpvPaddle::streamer(istream &istr) {
   *istr.m_xstr >> m_layer >> m_row;
   istr >> m_upvLeftHit_list >> m_upvRightHit_list;
}

inline void UpvPaddle::streamer(ostream &ostr) {
   *ostr.m_xstr << m_layer << m_row;
   ostr << m_upvLeftHit_list << m_upvRightHit_list;
}

inline void UpvTruthShower::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_primary >> m_ptype >> m_px >> m_py >> m_pz >> m_t >> m_track >> m_x >> m_y >> m_z;
}

inline void UpvTruthShower::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_primary << m_ptype << m_px << m_py << m_pz << m_t << m_track << m_x << m_y << m_z;
}

inline void UpstreamEMveto::streamer(istream &istr) {
   istr >> m_upvPaddle_list >> m_upvTruthShower_list;
}

inline void UpstreamEMveto::streamer(ostream &ostr) {
   ostr << m_upvPaddle_list << m_upvTruthShower_list;
}

inline void TaggerHit::streamer(istream &istr) {
   *istr.m_xstr >> m_t;
}

inline void TaggerHit::streamer(ostream &ostr) {
   *ostr.m_xstr << m_t;
}

inline void MicroChannel::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_column >> m_row;
   istr >> m_taggerHit_list;
}

inline void MicroChannel::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_column << m_row;
   ostr << m_taggerHit_list;
}

inline void Tagger::streamer(istream &istr) {
   istr >> m_microChannel_list;
}

inline void Tagger::streamer(ostream &ostr) {
   ostr << m_microChannel_list;
}

inline void McTrajectoryPoint::streamer(istream &istr) {
   *istr.m_xstr >> m_E >> m_dE >> m_mech >> m_part >> m_primary_track >> m_px >> m_py >> m_pz >> m_radlen >> m_step >> m_t >> m_track >> m_x >> m_y >> m_z;
}

inline void McTrajectoryPoint::streamer(ostream &ostr) {
   *ostr.m_xstr << m_E << m_dE << m_mech << m_part << m_primary_track << m_px << m_py << m_pz << m_radlen << m_step << m_t << m_track << m_x << m_y << m_z;
}

inline void McTrajectory::streamer(istream &istr) {
   istr >> m_mcTrajectoryPoint_list;
}

inline void McTrajectory::streamer(ostream &ostr) {
   ostr << m_mcTrajectoryPoint_list;
}

inline void HitView::streamer(istream &istr) {
   istr >> m_centralDC_link >> m_forwardDC_link >> m_startCntr_link >> m_barrelEMcal_link >> m_gapEMcal_link >> m_Cerenkov_link >> m_RICH_link >> m_forwardTOF_link >> m_forwardEMcal_link >> m_ComptonEMcal_link >> m_gamsEMcal_link >> m_upstreamEMveto_link >> m_tagger_link >> m_mcTrajectory_link;
}

inline void HitView::streamer(ostream &ostr) {
   ostr << m_centralDC_link << m_forwardDC_link << m_startCntr_link << m_barrelEMcal_link << m_gapEMcal_link << m_Cerenkov_link << m_RICH_link << m_forwardTOF_link << m_forwardEMcal_link << m_ComptonEMcal_link << m_gamsEMcal_link << m_upstreamEMveto_link << m_tagger_link << m_mcTrajectory_link;
}

inline void ErrorMatrix::streamer(istream &istr) {
   *istr.m_xstr >> m_Ncols >> m_Nrows >> m_type >> m_vals;
}

inline void ErrorMatrix::streamer(ostream &ostr) {
   *ostr.m_xstr << m_Ncols << m_Nrows << m_type << m_vals;
}

inline void TrackingErrorMatrix::streamer(istream &istr) {
   *istr.m_xstr >> m_Ncols >> m_Nrows >> m_type >> m_vals;
}

inline void TrackingErrorMatrix::streamer(ostream &ostr) {
   *ostr.m_xstr << m_Ncols << m_Nrows << m_type << m_vals;
}

inline void Tracktimebased::streamer(istream &istr) {
   *istr.m_xstr >> m_FOM >> m_Ndof >> m_candidateid >> m_chisq >> m_id >> m_trackid;
   istr >> m_momentum_link >> m_properties_link >> m_origin_link >> m_errorMatrix_link >> m_TrackingErrorMatrix_link;
}

inline void Tracktimebased::streamer(ostream &ostr) {
   *ostr.m_xstr << m_FOM << m_Ndof << m_candidateid << m_chisq << m_id << m_trackid;
   ostr << m_momentum_link << m_properties_link << m_origin_link << m_errorMatrix_link << m_TrackingErrorMatrix_link;
}

inline void ReconView::streamer(istream &istr) {
   istr >> m_tracktimebased_list;
}

inline void ReconView::streamer(ostream &ostr) {
   ostr << m_tracktimebased_list;
}

inline void PhysicsEvent::streamer(istream &istr) {
   *istr.m_xstr >> m_eventNo >> m_runNo;
   istr >> m_reaction_list >> m_hitView_link >> m_reconView_link;
}

inline void PhysicsEvent::streamer(ostream &ostr) {
   *ostr.m_xstr << m_eventNo << m_runNo;
   ostr << m_reaction_list << m_hitView_link << m_reconView_link;
}

inline void HDDM::streamer(istream &istr) {
   istr >> m_geometry_link >> m_physicsEvent_list;
}

inline void HDDM::streamer(ostream &ostr) {
   ostr << m_geometry_link << m_physicsEvent_list;
}

inline std::string HDDM::DocumentString() {
   return std::string(
"<HDDM class=\"s\" version=\"1.0\" xmlns=\"http://www.gluex.org/hddm\">\n"
"  <geometry maxOccurs=\"1\" md5reconstruction=\"string\" md5simulation=\"string\" md5smear=\"string\" minOccurs=\"0\" />\n"
"  <physicsEvent eventNo=\"int\" maxOccurs=\"unbounded\" runNo=\"int\">\n"
"    <reaction maxOccurs=\"unbounded\" minOccurs=\"0\" type=\"int\" weight=\"float\">\n"
"      <beam minOccurs=\"0\" type=\"Particle_t\">\n"
"        <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
"        <properties charge=\"int\" mass=\"float\" />\n"
"      </beam>\n"
"      <target minOccurs=\"0\" type=\"Particle_t\">\n"
"        <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
"        <properties charge=\"int\" mass=\"float\" />\n"
"      </target>\n"
"      <vertex maxOccurs=\"unbounded\">\n"
"        <product decayVertex=\"int\" id=\"int\" maxOccurs=\"unbounded\" mech=\"int\" parentid=\"int\" pdgtype=\"int\" type=\"Particle_t\">\n"
"          <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
"          <properties charge=\"int\" mass=\"float\" minOccurs=\"0\" />\n"
"        </product>\n"
"        <origin t=\"float\" vx=\"float\" vy=\"float\" vz=\"float\" />\n"
"      </vertex>\n"
"      <random maxOccurs=\"1\" minOccurs=\"0\" seed1=\"int\" seed2=\"int\" seed_mcsmear1=\"int\" seed_mcsmear2=\"int\" seed_mcsmear3=\"int\" />\n"
"    </reaction>\n"
"    <hitView minOccurs=\"0\" version=\"2.0\">\n"
"      <centralDC minOccurs=\"0\">\n"
"        <cdcStraw maxOccurs=\"unbounded\" minOccurs=\"0\" ring=\"int\" straw=\"int\">\n"
"          <cdcStrawHit d=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" q=\"float\" t=\"float\" />\n"
"          <cdcStrawTruthHit d=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" q=\"float\" t=\"float\" />\n"
"        </cdcStraw>\n"
"        <cdcTruthPoint dEdx=\"float\" dradius=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" t=\"float\" track=\"int\" z=\"float\" />\n"
"      </centralDC>\n"
"      <forwardDC minOccurs=\"0\">\n"
"        <fdcChamber layer=\"int\" maxOccurs=\"unbounded\" module=\"int\">\n"
"          <fdcAnodeWire maxOccurs=\"unbounded\" minOccurs=\"0\" wire=\"int\">\n"
"            <fdcAnodeHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" />\n"
"            <fdcAnodeTruthHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" t_unsmeared=\"float\" />\n"
"          </fdcAnodeWire>\n"
"          <fdcCathodeStrip maxOccurs=\"unbounded\" minOccurs=\"0\" plane=\"int\" strip=\"int\">\n"
"            <fdcCathodeHit itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" q=\"float\" t=\"float\" />\n"
"            <fdcCathodeTruthHit itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" q=\"float\" t=\"float\" />\n"
"          </fdcCathodeStrip>\n"
"          <fdcTruthPoint E=\"float\" dEdx=\"float\" dradius=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"        </fdcChamber>\n"
"      </forwardDC>\n"
"      <startCntr minOccurs=\"0\">\n"
"        <stcPaddle maxOccurs=\"unbounded\" minOccurs=\"0\" sector=\"int\">\n"
"          <stcHit dE=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"          <stcTruthHit dE=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"        </stcPaddle>\n"
"        <stcTruthPoint E=\"float\" dEdx=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" sector=\"int\" t=\"float\" track=\"int\" z=\"float\" />\n"
"      </startCntr>\n"
"      <barrelEMcal minOccurs=\"0\">\n"
"        <bcalCell layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\">\n"
"          <bcalSiPMUpHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <bcalSiPMDownHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <bcalHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" zLocal=\"float\" />\n"
"        </bcalCell>\n"
"        <bcalIncidentParticle id=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
"        <bcalSiPMSpectrum Etruth=\"float\" bin_width=\"float\" end=\"int\" incident_id=\"int\" layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\" tstart=\"float\" vals=\"string\" />\n"
"        <bcalfADCCell layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\">\n"
"          <bcalfADCUpHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <bcalfADCDownHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"        </bcalfADCCell>\n"
"        <bcalTDCHit end=\"int\" layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\" t=\"float\" />\n"
"        <bcalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" t=\"float\" track=\"int\" z=\"float\" />\n"
"      </barrelEMcal>\n"
"      <gapEMcal minOccurs=\"0\">\n"
"        <gcalCell maxOccurs=\"48\" minOccurs=\"0\" module=\"int\">\n"
"          <gcalHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" zLocal=\"float\" />\n"
"        </gcalCell>\n"
"        <gcalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" t=\"float\" track=\"int\" z=\"float\" />\n"
"      </gapEMcal>\n"
"      <Cerenkov minOccurs=\"0\">\n"
"        <cereSection maxOccurs=\"unbounded\" minOccurs=\"0\" sector=\"int\">\n"
"          <cereHit maxOccurs=\"unbounded\" pe=\"float\" t=\"float\" />\n"
"        </cereSection>\n"
"        <cereTruthPoint E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </Cerenkov>\n"
"      <RICH minOccurs=\"0\">\n"
"        <richHit maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
"        <richTruthPoint E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </RICH>\n"
"      <forwardTOF minOccurs=\"0\">\n"
"        <ftofCounter bar=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" plane=\"int\">\n"
"          <ftofNorthTruthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\">\n"
"            <ftofMCHit E=\"float\" dist=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
"          </ftofNorthTruthHit>\n"
"          <ftofSouthTruthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\">\n"
"            <ftofMCHit E=\"float\" dist=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
"          </ftofSouthTruthHit>\n"
"          <ftofNorthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <ftofSouthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"        </ftofCounter>\n"
"        <ftofTruthPoint E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </forwardTOF>\n"
"      <forwardEMcal minOccurs=\"0\">\n"
"        <fcalBlock column=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
"          <fcalHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"          <fcalTruthHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"        </fcalBlock>\n"
"        <fcalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </forwardEMcal>\n"
"      <ComptonEMcal minOccurs=\"0\">\n"
"        <ccalBlock column=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
"          <ccalHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"          <ccalTruthHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"        </ccalBlock>\n"
"        <ccalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </ComptonEMcal>\n"
"      <gamsEMcal minOccurs=\"0\">\n"
"        <gamsClust E=\"float\" chi2=\"float\" dime=\"int\" id=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" type=\"int\" x=\"float\" xc=\"float\" y=\"float\" yc=\"float\" z=\"float\" />\n"
"      </gamsEMcal>\n"
"      <upstreamEMveto minOccurs=\"0\">\n"
"        <upvPaddle layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
"          <upvLeftHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <upvRightHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"        </upvPaddle>\n"
"        <upvTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </upstreamEMveto>\n"
"      <tagger minOccurs=\"0\">\n"
"        <microChannel E=\"float\" column=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
"          <taggerHit maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"        </microChannel>\n"
"      </tagger>\n"
"      <mcTrajectory minOccurs=\"0\">\n"
"        <mcTrajectoryPoint E=\"float\" dE=\"float\" maxOccurs=\"unbounded\" mech=\"int\" minOccurs=\"0\" part=\"int\" primary_track=\"int\" px=\"float\" py=\"float\" pz=\"float\" radlen=\"float\" step=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </mcTrajectory>\n"
"    </hitView>\n"
"    <reconView minOccurs=\"0\" version=\"1.0\">\n"
"      <tracktimebased FOM=\"float\" Ndof=\"int\" candidateid=\"int\" chisq=\"float\" id=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" trackid=\"int\">\n"
"        <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
"        <properties charge=\"int\" mass=\"float\" />\n"
"        <origin t=\"float\" vx=\"float\" vy=\"float\" vz=\"float\" />\n"
"        <errorMatrix Ncols=\"int\" Nrows=\"int\" type=\"string\" vals=\"string\" />\n"
"        <TrackingErrorMatrix Ncols=\"int\" Nrows=\"int\" type=\"string\" vals=\"string\" />\n"
"      </tracktimebased>\n"
"    </reconView>\n"
"  </physicsEvent>\n"
"</HDDM>\n"
   );
}

}
#endif /* SAW_s_HDDM */