[u/mrichter/AliRoot.git] / TEvtGen / HepMC / HeavyIon.h

//--------------------------------------------------------------------------
#ifndef HEPMC_HEAVY_ION_H
#define HEPMC_HEAVY_ION_H

//////////////////////////////////////////////////////////////////////////
// garren@fnal.gov, February 2006
//
// Additional information storage for Heavy Ion generators
//////////////////////////////////////////////////////////////////////////
//
//      int   Ncoll_hard          // Number of hard scatterings
//      int   Npart_proj          // Number of projectile participants
//      int   Npart_targ          // Number of target participants
//      int   Ncoll               // Number of NN (nucleon-nucleon) collisions
//      int   N_Nwounded_collisions        // Number of N-Nwounded collisions
//      int   Nwounded_N_collisions        // Number of Nwounded-N collisons
//      int   Nwounded_Nwounded_collisions // Number of Nwounded-Nwounded collisions
//      int   spectator_neutrons           // Number of spectator neutrons
//      int   spectator_protons            // Number of spectator protons
//      float impact_parameter        // Impact Parameter(fm) of collision
//      float event_plane_angle       // Azimuthal angle of event plane
//      float eccentricity            // eccentricity of participating nucleons
//                                        in the transverse plane 
//                                        (as in phobos nucl-ex/0510031) 
//      float sigma_inel_NN           // nucleon-nucleon inelastic 
//                                        (including diffractive) cross-section
//
//////////////////////////////////////////////////////////////////////////
// Feb. 17, 2006: adjust names according to suggestions from Heavy Ion users
// Feb.  7, 2006: first pass at making method names consistent with existing
//                HepMC code
//////////////////////////////////////////////////////////////////////////

namespace HepMC {


//! The HeavyIon class stores information about heavy ions

///
/// \class  HeavyIon
/// HepMC::HeavyIon provides
/// additional information storage for Heavy Ion generators in GenEvent.
/// Creation and use of this information is optional. 
///
class HeavyIon {

public:
  // ---  birth/death:
  //
  /// default constructor
  HeavyIon()
    : m_Ncoll_hard(0), 
      m_Npart_proj(0),
      m_Npart_targ(0),
      m_Ncoll(0),
      m_spectator_neutrons(0),
      m_spectator_protons(0),
      m_N_Nwounded_collisions(0),
      m_Nwounded_N_collisions(0),
      m_Nwounded_Nwounded_collisions(0),
      m_impact_parameter(0),
      m_event_plane_angle(0),
      m_eccentricity(0),
      m_sigma_inel_NN(0)
    {}

  /// The first 6 values must be provided.
  HeavyIon( int nh, int np, int nt, int nc, int ns, int nsp,
                   int nnw=0, int nwn=0, int nwnw=0, 
		   float im=0., float pl=0., float ec=0., float s=0. );

  ~HeavyIon() {}
    
  // ---  copying:
  //
  HeavyIon( HeavyIon const & orig );	//!< copy constructor
  HeavyIon &  operator = ( HeavyIon const & rhs ); //!< make a copy
  void swap( HeavyIon & other );	//!< swap two HeavyIon objects

  // ---  equivalence:
  //
  bool    operator==( const HeavyIon& ) const; //!< check for equality
  bool    operator!=( const HeavyIon& ) const; //!< check for inequality

  // ---  accessors:
    /// Number of hard scatterings
    int   Ncoll_hard()                   const { return m_Ncoll_hard; }
    /// Number of projectile participants
    int   Npart_proj()                   const { return m_Npart_proj; }
    /// Number of target participants
    int   Npart_targ()                   const { return m_Npart_targ; }
    /// Number of NN (nucleon-nucleon) collisions
    int   Ncoll()                        const { return m_Ncoll; }
    /// Number of spectator neutrons
    int   spectator_neutrons()           const { return m_spectator_neutrons; }
    /// Number of spectator protons
    int   spectator_protons()            const { return m_spectator_protons; }
    /// Number of N-Nwounded collisions
    int   N_Nwounded_collisions()        const { return m_N_Nwounded_collisions; }
    /// Number of Nwounded-N collisons
    int   Nwounded_N_collisions()        const { return m_Nwounded_N_collisions; }
    /// Number of Nwounded-Nwounded collisions
    int   Nwounded_Nwounded_collisions() const { return m_Nwounded_Nwounded_collisions; }
    /// Impact Parameter(in fm) of collision
    float impact_parameter()             const { return m_impact_parameter; }
    /// Azimuthal angle of event plane
    float event_plane_angle()            const { return m_event_plane_angle; }
    /// eccentricity of participating nucleons in the transverse plane 
    /// (as in phobos nucl-ex/0510031)
    float eccentricity()                 const { return m_eccentricity;  }
    /// nucleon-nucleon inelastic (including diffractive) cross-section
    float sigma_inel_NN()                const { return m_sigma_inel_NN; }

    /// verify that the instance contains non-zero information
    bool  is_valid()                     const;

  // ---  mutators:
    /// set number of hard scatterings
    void   set_Ncoll_hard(const int &i)              { m_Ncoll_hard=i; }
    /// set number of projectile participants
    void   set_Npart_proj(const int &i)              { m_Npart_proj=i; }
    /// set number of target participants
    void   set_Npart_targ(const int &i)              { m_Npart_targ=i; }
    /// set number of NN (nucleon-nucleon) collisions
    void   set_Ncoll(const int &i)                   { m_Ncoll=i; }
    /// set number of spectator neutrons
    void   set_spectator_neutrons(const int &i)      { m_spectator_neutrons=i; }
    /// set number of spectator protons
    void   set_spectator_protons(const int &i)       { m_spectator_protons=i; }
    /// set number of N-Nwounded collisions
    void   set_N_Nwounded_collisions(const int &i)   { m_N_Nwounded_collisions=i; }
    /// set number of Nwounded-N collisons
    void   set_Nwounded_N_collisions(const int &i)   { m_Nwounded_N_collisions=i; }
    /// set number of Nwounded-Nwounded collisions
    void   set_Nwounded_Nwounded_collisions(const int &i) 
                                          { m_Nwounded_Nwounded_collisions=i; }
    /// set Impact Parameter in fm
    void   set_impact_parameter(const float &f)      { m_impact_parameter=f; }
    /// set azimuthal angle of event plane
    void   set_event_plane_angle(const float &f)     { m_event_plane_angle=f; }
    /// set eccentricity of participating nucleons in the transverse plane 
    void   set_eccentricity(const float &f)          { m_eccentricity=f;  }
    /// set nucleon-nucleon inelastic cross-section
    void   set_sigma_inel_NN(const float &f)         { m_sigma_inel_NN=f; }

private: // data members
    int   m_Ncoll_hard; 
    int   m_Npart_proj; 
    int   m_Npart_targ;
    int   m_Ncoll;
    int   m_spectator_neutrons;
    int   m_spectator_protons;
    int   m_N_Nwounded_collisions;
    int   m_Nwounded_N_collisions;
    int   m_Nwounded_Nwounded_collisions;
    float m_impact_parameter;
    float m_event_plane_angle;
    float m_eccentricity; 
    float m_sigma_inel_NN;

};

// Free Functions

/// Write the contents of HeavyIon to an output stream.
std::ostream & operator << (std::ostream &, HeavyIon const *);
/// Read the contents of HeavyIon from an input stream.
std::istream & operator >> (std::istream &, HeavyIon *);

// inline operators
  /// Required members are
  /// the number of hard scatterings,
  /// the number of projectile participants.
  /// the number of target participants.
  /// the number of nucleon-nucleon collisions,
  /// the number of spectator neutrons, and
  /// the number of spectator protons.
inline HeavyIon::HeavyIon( int nh, int np, int nt, int nc, int ns, int nsp,
                   int nnw, int nwn, int nwnw, 
		   float im, float pl, float ec, float s )
    : m_Ncoll_hard(nh), 
      m_Npart_proj(np),
      m_Npart_targ(nt),
      m_Ncoll(nc),
      m_spectator_neutrons(ns),
      m_spectator_protons(nsp),
      m_N_Nwounded_collisions(nnw),
      m_Nwounded_N_collisions(nwn),
      m_Nwounded_Nwounded_collisions(nwnw),
      m_impact_parameter(im),
      m_event_plane_angle(pl),
      m_eccentricity(ec),
      m_sigma_inel_NN(s)
   {}

inline HeavyIon::HeavyIon( HeavyIon const & orig )
    : m_Ncoll_hard(orig.m_Ncoll_hard), 
      m_Npart_proj(orig.m_Npart_proj),
      m_Npart_targ(orig.m_Npart_targ),
      m_Ncoll(orig.m_Ncoll),
      m_spectator_neutrons(orig.m_spectator_neutrons),
      m_spectator_protons(orig.m_spectator_protons),
      m_N_Nwounded_collisions(orig.m_N_Nwounded_collisions),
      m_Nwounded_N_collisions(orig.m_Nwounded_N_collisions),
      m_Nwounded_Nwounded_collisions(orig.m_Nwounded_Nwounded_collisions),
      m_impact_parameter(orig.m_impact_parameter),
      m_event_plane_angle(orig.m_event_plane_angle),
      m_eccentricity(orig.m_eccentricity),
      m_sigma_inel_NN(orig.m_sigma_inel_NN)
   {}

inline HeavyIon &  HeavyIon::operator = ( HeavyIon const & rhs ) 
{
  HeavyIon temp( rhs );
  swap( temp );
  return *this;
}

inline void HeavyIon::swap( HeavyIon & other ) 
{
  std::swap(m_Ncoll_hard, other.m_Ncoll_hard); 
  std::swap(m_Npart_proj, other.m_Npart_proj);
  std::swap(m_Npart_targ, other.m_Npart_targ);
  std::swap(m_Ncoll, other.m_Ncoll);
  std::swap(m_N_Nwounded_collisions, other.m_N_Nwounded_collisions);
  std::swap(m_Nwounded_N_collisions, other.m_Nwounded_N_collisions);
  std::swap(m_Nwounded_Nwounded_collisions, other.m_Nwounded_Nwounded_collisions);
  std::swap(m_spectator_neutrons, other.m_spectator_neutrons);
  std::swap(m_spectator_protons, other.m_spectator_protons);
  std::swap(m_impact_parameter, other.m_impact_parameter);
  std::swap(m_event_plane_angle, other.m_event_plane_angle);
  std::swap(m_eccentricity, other.m_eccentricity);
  std::swap(m_sigma_inel_NN, other.m_sigma_inel_NN);
}

inline bool    HeavyIon::operator==( const HeavyIon& a ) const
{
    /// equality requires that each member match
    return ( a.Ncoll_hard() == this->Ncoll_hard() 
             && a.Npart_proj() == this->Npart_proj() 
             && a.Npart_targ() == this->Npart_targ() 
	     && a.Ncoll() == this->Ncoll() 
             && a.N_Nwounded_collisions() == this->N_Nwounded_collisions() 
	     && a.Nwounded_N_collisions() == this->Nwounded_N_collisions() 
             && a.Nwounded_Nwounded_collisions() == this->Nwounded_Nwounded_collisions() 
	     && a.spectator_neutrons() == this->spectator_neutrons() 
             && a.spectator_protons() == this->spectator_protons() 
	     && a.impact_parameter() == this->impact_parameter() 
	     && a.event_plane_angle() == this->event_plane_angle()
	     && a.eccentricity() == this->eccentricity() 
	     && a.sigma_inel_NN() == this->sigma_inel_NN() );
}

inline bool    HeavyIon::operator!=( const HeavyIon& a ) const
{
    /// any nonmatching member generates inequality
    return !( a == *this );
}

inline bool  HeavyIon::is_valid() const
{
    if( m_Ncoll_hard != 0 ) return true;
    if( m_Npart_proj != 0 ) return true;
    if( m_Npart_targ != 0 ) return true;
    if( m_Ncoll != 0 ) return true;
    if( m_spectator_neutrons != 0 ) return true;
    if( m_spectator_protons != 0 ) return true;
    if( m_N_Nwounded_collisions != 0 ) return true;
    if( m_Nwounded_N_collisions != 0 ) return true;
    if( m_Nwounded_Nwounded_collisions != 0 ) return true;
    if( m_impact_parameter != 0 ) return true;
    if( m_event_plane_angle != 0 ) return true;
    if( m_eccentricity != 0 ) return true;
    if( m_sigma_inel_NN != 0 ) return true;
    return false;
}

} // HepMC

#endif  // HEPMC_HEAVY_ION_H
Commit	Line	Data
0ca57c2f	1	//--------------------------------------------------------------------------
	2	#ifndef HEPMC_HEAVY_ION_H
	3	#define HEPMC_HEAVY_ION_H
	4
	5	//////////////////////////////////////////////////////////////////////////
	6	// garren@fnal.gov, February 2006
	7	//
	8	// Additional information storage for Heavy Ion generators
	9	//////////////////////////////////////////////////////////////////////////
	10	//
	11	// int Ncoll_hard // Number of hard scatterings
	12	// int Npart_proj // Number of projectile participants
	13	// int Npart_targ // Number of target participants
	14	// int Ncoll // Number of NN (nucleon-nucleon) collisions
	15	// int N_Nwounded_collisions // Number of N-Nwounded collisions
	16	// int Nwounded_N_collisions // Number of Nwounded-N collisons
	17	// int Nwounded_Nwounded_collisions // Number of Nwounded-Nwounded collisions
	18	// int spectator_neutrons // Number of spectator neutrons
	19	// int spectator_protons // Number of spectator protons
	20	// float impact_parameter // Impact Parameter(fm) of collision
	21	// float event_plane_angle // Azimuthal angle of event plane
	22	// float eccentricity // eccentricity of participating nucleons
	23	// in the transverse plane
	24	// (as in phobos nucl-ex/0510031)
	25	// float sigma_inel_NN // nucleon-nucleon inelastic
	26	// (including diffractive) cross-section
	27	//
	28	//////////////////////////////////////////////////////////////////////////
	29	// Feb. 17, 2006: adjust names according to suggestions from Heavy Ion users
	30	// Feb. 7, 2006: first pass at making method names consistent with existing
	31	// HepMC code
	32	//////////////////////////////////////////////////////////////////////////
	33
	34	namespace HepMC {
	35
	36
	37	//! The HeavyIon class stores information about heavy ions
	38
	39	///
	40	/// \class HeavyIon
	41	/// HepMC::HeavyIon provides
	42	/// additional information storage for Heavy Ion generators in GenEvent.
	43	/// Creation and use of this information is optional.
	44	///
	45	class HeavyIon {
	46
	47	public:
	48	// --- birth/death:
	49	//
	50	/// default constructor
	51	HeavyIon()
	52	: m_Ncoll_hard(0),
	53	m_Npart_proj(0),
	54	m_Npart_targ(0),
	55	m_Ncoll(0),
	56	m_spectator_neutrons(0),
	57	m_spectator_protons(0),
	58	m_N_Nwounded_collisions(0),
	59	m_Nwounded_N_collisions(0),
	60	m_Nwounded_Nwounded_collisions(0),
	61	m_impact_parameter(0),
	62	m_event_plane_angle(0),
	63	m_eccentricity(0),
	64	m_sigma_inel_NN(0)
65	{}
66
67	/// The first 6 values must be provided.
68	HeavyIon( int nh, int np, int nt, int nc, int ns, int nsp,
69	int nnw=0, int nwn=0, int nwnw=0,
70	float im=0., float pl=0., float ec=0., float s=0. );
71
72	~HeavyIon() {}
73
74	// --- copying:
75	//
76	HeavyIon( HeavyIon const & orig ); //!< copy constructor
77	HeavyIon & operator = ( HeavyIon const & rhs ); //!< make a copy
78	void swap( HeavyIon & other ); //!< swap two HeavyIon objects
79
80	// --- equivalence:
81	//
82	bool operator==( const HeavyIon& ) const; //!< check for equality
83	bool operator!=( const HeavyIon& ) const; //!< check for inequality
84
85	// --- accessors:
86	/// Number of hard scatterings
87	int Ncoll_hard() const { return m_Ncoll_hard; }
88	/// Number of projectile participants
89	int Npart_proj() const { return m_Npart_proj; }
90	/// Number of target participants
91	int Npart_targ() const { return m_Npart_targ; }
92	/// Number of NN (nucleon-nucleon) collisions
93	int Ncoll() const { return m_Ncoll; }
94	/// Number of spectator neutrons
95	int spectator_neutrons() const { return m_spectator_neutrons; }
96	/// Number of spectator protons
97	int spectator_protons() const { return m_spectator_protons; }
98	/// Number of N-Nwounded collisions
99	int N_Nwounded_collisions() const { return m_N_Nwounded_collisions; }
100	/// Number of Nwounded-N collisons
101	int Nwounded_N_collisions() const { return m_Nwounded_N_collisions; }
102	/// Number of Nwounded-Nwounded collisions
103	int Nwounded_Nwounded_collisions() const { return m_Nwounded_Nwounded_collisions; }
104	/// Impact Parameter(in fm) of collision
105	float impact_parameter() const { return m_impact_parameter; }
106	/// Azimuthal angle of event plane
107	float event_plane_angle() const { return m_event_plane_angle; }
108	/// eccentricity of participating nucleons in the transverse plane
109	/// (as in phobos nucl-ex/0510031)
110	float eccentricity() const { return m_eccentricity; }
111	/// nucleon-nucleon inelastic (including diffractive) cross-section
112	float sigma_inel_NN() const { return m_sigma_inel_NN; }
113
114	/// verify that the instance contains non-zero information
115	bool is_valid() const;
116
117	// --- mutators:
118	/// set number of hard scatterings
119	void set_Ncoll_hard(const int &i) { m_Ncoll_hard=i; }
120	/// set number of projectile participants
121	void set_Npart_proj(const int &i) { m_Npart_proj=i; }
122	/// set number of target participants
123	void set_Npart_targ(const int &i) { m_Npart_targ=i; }
124	/// set number of NN (nucleon-nucleon) collisions
125	void set_Ncoll(const int &i) { m_Ncoll=i; }
126	/// set number of spectator neutrons
127	void set_spectator_neutrons(const int &i) { m_spectator_neutrons=i; }
128	/// set number of spectator protons
129	void set_spectator_protons(const int &i) { m_spectator_protons=i; }
130	/// set number of N-Nwounded collisions
131	void set_N_Nwounded_collisions(const int &i) { m_N_Nwounded_collisions=i; }
132	/// set number of Nwounded-N collisons
133	void set_Nwounded_N_collisions(const int &i) { m_Nwounded_N_collisions=i; }
134	/// set number of Nwounded-Nwounded collisions
135	void set_Nwounded_Nwounded_collisions(const int &i)
136	{ m_Nwounded_Nwounded_collisions=i; }
137	/// set Impact Parameter in fm
138	void set_impact_parameter(const float &f) { m_impact_parameter=f; }
139	/// set azimuthal angle of event plane
140	void set_event_plane_angle(const float &f) { m_event_plane_angle=f; }
141	/// set eccentricity of participating nucleons in the transverse plane
142	void set_eccentricity(const float &f) { m_eccentricity=f; }
143	/// set nucleon-nucleon inelastic cross-section
144	void set_sigma_inel_NN(const float &f) { m_sigma_inel_NN=f; }
145
146	private: // data members
147	int m_Ncoll_hard;
148	int m_Npart_proj;
149	int m_Npart_targ;
150	int m_Ncoll;
151	int m_spectator_neutrons;
152	int m_spectator_protons;
153	int m_N_Nwounded_collisions;
154	int m_Nwounded_N_collisions;
155	int m_Nwounded_Nwounded_collisions;
156	float m_impact_parameter;
157	float m_event_plane_angle;
158	float m_eccentricity;
159	float m_sigma_inel_NN;
160
161	};
162
163	// Free Functions
164
165	/// Write the contents of HeavyIon to an output stream.
166	std::ostream & operator << (std::ostream &, HeavyIon const *);
167	/// Read the contents of HeavyIon from an input stream.
168	std::istream & operator >> (std::istream &, HeavyIon *);
169
170	// inline operators
171	/// Required members are
172	/// the number of hard scatterings,
173	/// the number of projectile participants.
174	/// the number of target participants.
175	/// the number of nucleon-nucleon collisions,
176	/// the number of spectator neutrons, and
177	/// the number of spectator protons.
178	inline HeavyIon::HeavyIon( int nh, int np, int nt, int nc, int ns, int nsp,
179	int nnw, int nwn, int nwnw,
180	float im, float pl, float ec, float s )
181	: m_Ncoll_hard(nh),
182	m_Npart_proj(np),
183	m_Npart_targ(nt),
184	m_Ncoll(nc),
185	m_spectator_neutrons(ns),
186	m_spectator_protons(nsp),
187	m_N_Nwounded_collisions(nnw),
188	m_Nwounded_N_collisions(nwn),
189	m_Nwounded_Nwounded_collisions(nwnw),
190	m_impact_parameter(im),
191	m_event_plane_angle(pl),
192	m_eccentricity(ec),
193	m_sigma_inel_NN(s)
194	{}
195
196	inline HeavyIon::HeavyIon( HeavyIon const & orig )
197	: m_Ncoll_hard(orig.m_Ncoll_hard),
198	m_Npart_proj(orig.m_Npart_proj),
199	m_Npart_targ(orig.m_Npart_targ),
200	m_Ncoll(orig.m_Ncoll),
201	m_spectator_neutrons(orig.m_spectator_neutrons),
202	m_spectator_protons(orig.m_spectator_protons),
203	m_N_Nwounded_collisions(orig.m_N_Nwounded_collisions),
204	m_Nwounded_N_collisions(orig.m_Nwounded_N_collisions),
205	m_Nwounded_Nwounded_collisions(orig.m_Nwounded_Nwounded_collisions),
206	m_impact_parameter(orig.m_impact_parameter),
207	m_event_plane_angle(orig.m_event_plane_angle),
208	m_eccentricity(orig.m_eccentricity),
209	m_sigma_inel_NN(orig.m_sigma_inel_NN)
210	{}
211
212	inline HeavyIon & HeavyIon::operator = ( HeavyIon const & rhs )
213	{
214	HeavyIon temp( rhs );
215	swap( temp );
216	return *this;
217	}
218
219	inline void HeavyIon::swap( HeavyIon & other )
220	{
221	std::swap(m_Ncoll_hard, other.m_Ncoll_hard);
222	std::swap(m_Npart_proj, other.m_Npart_proj);
223	std::swap(m_Npart_targ, other.m_Npart_targ);
224	std::swap(m_Ncoll, other.m_Ncoll);
225	std::swap(m_N_Nwounded_collisions, other.m_N_Nwounded_collisions);
226	std::swap(m_Nwounded_N_collisions, other.m_Nwounded_N_collisions);
227	std::swap(m_Nwounded_Nwounded_collisions, other.m_Nwounded_Nwounded_collisions);
228	std::swap(m_spectator_neutrons, other.m_spectator_neutrons);
229	std::swap(m_spectator_protons, other.m_spectator_protons);
230	std::swap(m_impact_parameter, other.m_impact_parameter);
231	std::swap(m_event_plane_angle, other.m_event_plane_angle);
232	std::swap(m_eccentricity, other.m_eccentricity);
233	std::swap(m_sigma_inel_NN, other.m_sigma_inel_NN);
234	}
235
236	inline bool HeavyIon::operator==( const HeavyIon& a ) const
237	{
238	/// equality requires that each member match
239	return ( a.Ncoll_hard() == this->Ncoll_hard()
240	&& a.Npart_proj() == this->Npart_proj()
241	&& a.Npart_targ() == this->Npart_targ()
242	&& a.Ncoll() == this->Ncoll()
243	&& a.N_Nwounded_collisions() == this->N_Nwounded_collisions()
244	&& a.Nwounded_N_collisions() == this->Nwounded_N_collisions()
245	&& a.Nwounded_Nwounded_collisions() == this->Nwounded_Nwounded_collisions()
246	&& a.spectator_neutrons() == this->spectator_neutrons()
247	&& a.spectator_protons() == this->spectator_protons()
248	&& a.impact_parameter() == this->impact_parameter()
249	&& a.event_plane_angle() == this->event_plane_angle()
250	&& a.eccentricity() == this->eccentricity()
251	&& a.sigma_inel_NN() == this->sigma_inel_NN() );
252	}
253
254	inline bool HeavyIon::operator!=( const HeavyIon& a ) const
255	{
256	/// any nonmatching member generates inequality
257	return !( a == *this );
258	}
259
260	inline bool HeavyIon::is_valid() const
261	{
262	if( m_Ncoll_hard != 0 ) return true;
263	if( m_Npart_proj != 0 ) return true;
264	if( m_Npart_targ != 0 ) return true;
265	if( m_Ncoll != 0 ) return true;
266	if( m_spectator_neutrons != 0 ) return true;
267	if( m_spectator_protons != 0 ) return true;
268	if( m_N_Nwounded_collisions != 0 ) return true;
269	if( m_Nwounded_N_collisions != 0 ) return true;
270	if( m_Nwounded_Nwounded_collisions != 0 ) return true;
271	if( m_impact_parameter != 0 ) return true;
272	if( m_event_plane_angle != 0 ) return true;
273	if( m_eccentricity != 0 ) return true;
274	if( m_sigma_inel_NN != 0 ) return true;
275	return false;
276	}
277
278	} // HepMC
279
280	#endif // HEPMC_HEAVY_ION_H