---

Particle.h

#ifndef PARTICLE_CLASS_PARTICLE_H
#define PARTICLE_CLASS_PARTICLE_H

#include <string>

#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Vector/LorentzVector.h"

#include "particle/Ptype.h"
#include "particle/Momentum.h"
#include "particle/Relation.h"
#include "particle/PID.h"
#include "particle/constant.h"

class ParticleUserInfo;

class Particle {
  
public:
  Particle();
  
  Particle(const Particle &);
  
  Particle(const HepLorentzVector &, const Ptype &);

  Particle(const Momentum &, const Ptype &);

  Particle(const double &eta,
           const double &phi,
           const double &pt,
           const Ptype &);

  virtual ~Particle();

  virtual const std::string & name(void) const;

  virtual const std::string & name(const std::string &);

  virtual std::string className(void){ return std::string("Particle"); }
  
  virtual void dump(const std::string & keyword = std::string("mass momentum"),
                    const std::string & prefix = std::string("")) const;

  virtual const Momentum & momentum(void) const;
  
  virtual Momentum & momentum(void);
  
  virtual const Momentum & momentum(const Momentum &);
  
  virtual const HepLorentzVector & p(void) const;

  virtual const HepPoint3D & x(void) const;

  virtual double eta(void) const;

  virtual double phi(void) const;

  virtual double pt(void) const;

  virtual double e(void) const;

  virtual double mass(void) const;

  virtual const PID & pId(void) const;

  virtual PID & pId(void);

  virtual const PID & pId(const PID &);

  virtual const Ptype & pType(void) const;

  virtual Ptype & pType(void);
  
  virtual const Ptype & pType(const Ptype &);
  
  virtual int pdgid(void) const;

  virtual const Relation & relation(void) const;

  virtual Relation & relation(void);
  
  virtual const Relation & relation(const Relation &);
  
  virtual const Particle * mother(void) const;
  
  virtual unsigned nChildren(void) const;

  virtual const Particle * child(unsigned i) const;

  virtual Particle * child(unsigned i);
 
  virtual const Particle * gen(void) const;

  virtual Particle * gen(void);

  virtual const ParticleUserInfo * userInfo(void) const;

  virtual ParticleUserInfo * userInfo(void);

  virtual const ParticleUserInfo * userInfo(const ParticleUserInfo &);

  virtual Particle & operator = (const Particle &);

  virtual operator bool() const { return m_usable; }
  
  virtual bool operator ! () const { return !m_usable; }

  virtual bool isUsable(void){ return m_usable; }

  virtual bool setUsable(const bool &);

  virtual Particle deepCopy(void);

  virtual void deepDelete(void);

  virtual void setObjectID(const int &v) { m_objectID = v; }
  
  virtual int getObjectID(void) const { return m_objectID; }

protected:
  bool m_usable; 

  std::string m_name;

  Momentum         *m_momentum;
  Relation         *m_relation;
  Ptype            *m_pType;
  PID              *m_pId;
  ParticleUserInfo *m_userInfo;

  int m_objectID;
  // id to keep the relation between
  // a Particle Class Object and
  // a ROOT(Ntuple) index.
  // If a user does not set this ID,
  // this ID is always -999.
};
#endif // PARTICLE_CLASS_PARTICLE_H

---