D58.1759152743.diff
No OneTemporary
Actions

Size

1 MB

Referenced Files

None

Subscribers

None

D58.1759152743.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
	--- a/.gitlab-ci.yml
	+++ b/.gitlab-ci.yml
	@@ -77,6 +77,16 @@
	- cd test
	- python checkJsonFiles.py

	+check_member_varnames:
	+ extends:
	+ - .check_template
	+ script:
	+ - mkdir build && cd build
	+ - cmake -DEVTGEN_HEPMC3:BOOL=ON -DEVTGEN_PYTHIA:BOOL=ON -DEVTGEN_PHOTOS:BOOL=ON -DEVTGEN_TAUOLA:BOOL=ON -DEVTGEN_BUILD_TESTS:BOOL=OFF -DEVTGEN_BUILD_DOXYGEN:BOOL=ON $CI_PROJECT_DIR
	+ - cmake --build . --target doc
	+ - curl -o renameMemberVars.py "https://gitlab.cern.ch/evtgen/utilities/raw/master/RenameMemberVars/renameMemberVars.py?inline=false"
	+ - python renameMemberVars.py check $CI_PROJECT_DIR doxygen/html
	+
	build_clang_opt:
	variables:
	LCG_COMPILER: "clang$CLANG_VERSION-opt"
	diff --git a/EvtGen/EvtGen.hh b/EvtGen/EvtGen.hh
	--- a/EvtGen/EvtGen.hh
	+++ b/EvtGen/EvtGen.hh
	@@ -66,8 +66,8 @@
	const std::list<EvtDecayBase> extraModels = nullptr,
	int mixingType = 1, bool useXml = false );

	- EvtPDL _pdl;
	- int _mixingType;
	+ EvtPDL m_pdl;
	+ int m_mixingType;
	};

	#endif
	diff --git a/EvtGenBase/EvtAbsLineShape.hh b/EvtGenBase/EvtAbsLineShape.hh
	--- a/EvtGenBase/EvtAbsLineShape.hh
	+++ b/EvtGenBase/EvtAbsLineShape.hh
	@@ -35,34 +35,34 @@
	EvtAbsLineShape& operator=( const EvtAbsLineShape& x );
	EvtAbsLineShape( const EvtAbsLineShape& x );

	- double getMass() { return _mass; }
	- double getMassMin() { return _massMin; }
	- double getMassMax() { return _massMax; }
	- double getMaxRange() { return _maxRange; }
	- double getWidth() { return _width; }
	- EvtSpinType::spintype getSpinType() { return _spin; }
	+ double getMass() { return m_mass; }
	+ double getMassMin() { return m_massMin; }
	+ double getMassMax() { return m_massMax; }
	+ double getMaxRange() { return m_maxRange; }
	+ double getWidth() { return m_width; }
	+ EvtSpinType::spintype getSpinType() { return m_spin; }
	virtual double rollMass();
	virtual EvtAbsLineShape* clone();

	- void reSetMass( double mass ) { _mass = mass; }
	- void reSetWidth( double width ) { _width = width; }
	- void reSetMassMin( double mass ) { _massMin = mass; }
	- void reSetMassMax( double mass ) { _massMax = mass; }
	+ void reSetMass( double mass ) { m_mass = mass; }
	+ void reSetWidth( double width ) { m_width = width; }
	+ void reSetMassMin( double mass ) { m_massMin = mass; }
	+ void reSetMassMax( double mass ) { m_massMax = mass; }
	virtual void reSetBlatt( double /blatt/ ){};
	virtual void reSetBlattBirth( double /blatt/ ){};
	- void includeBirthFactor( bool yesno ) { _includeBirthFact = yesno; }
	- void includeDecayFactor( bool yesno ) { _includeDecayFact = yesno; }
	+ void includeBirthFactor( bool yesno ) { m_includeBirthFact = yesno; }
	+ void includeDecayFactor( bool yesno ) { m_includeDecayFact = yesno; }
	void setPWForDecay( int spin, EvtId d1, EvtId d2 )
	{
	- _userSetPW.push_back( spin );
	- _userSetPWD1.push_back( d1 );
	- _userSetPWD2.push_back( d2 );
	+ m_userSetPW.push_back( spin );
	+ m_userSetPWD1.push_back( d1 );
	+ m_userSetPWD2.push_back( d2 );
	}
	void setPWForBirthL( int spin, EvtId par, EvtId othD )
	{
	- _userSetBirthPW.push_back( spin );
	- _userSetBirthOthD.push_back( othD );
	- _userSetBirthPar.push_back( par );
	+ m_userSetBirthPW.push_back( spin );
	+ m_userSetBirthOthD.push_back( othD );
	+ m_userSetBirthPar.push_back( par );
	}

	virtual double getRandMass( EvtId* parId, int nDaug, EvtId* dauId,
	@@ -72,26 +72,26 @@
	double* massDau );

	protected:
	- bool _includeDecayFact;
	- bool _includeBirthFact;
	- double _mass;
	- double _massMin;
	- double _massMax;
	- double _width;
	- double _maxRange;
	+ bool m_includeDecayFact;
	+ bool m_includeBirthFact;
	+ double m_mass;
	+ double m_massMin;
	+ double m_massMax;
	+ double m_width;
	+ double m_maxRange;

	// allow for special cases where the default method of picking the
	//lowest allowed partial wave for a decay is not the right answer.
	// string is "<spin> <daughter1> <daughter2>"
	//new 9/12/2003 Lange
	- std::vector<EvtId> _userSetPWD1, _userSetPWD2;
	- std::vector<int> _userSetPW;
	+ std::vector<EvtId> m_userSetPWD1, m_userSetPWD2;
	+ std::vector<int> m_userSetPW;

	// also do it for birth factors
	- std::vector<EvtId> _userSetBirthPar, _userSetBirthOthD;
	- std::vector<int> _userSetBirthPW;
	+ std::vector<EvtId> m_userSetBirthPar, m_userSetBirthOthD;
	+ std::vector<int> m_userSetBirthPW;

	- EvtSpinType::spintype _spin;
	+ EvtSpinType::spintype m_spin;
	};

	#endif
	diff --git a/EvtGenBase/EvtAmp.hh b/EvtGenBase/EvtAmp.hh
	--- a/EvtGenBase/EvtAmp.hh
	+++ b/EvtGenBase/EvtAmp.hh
	@@ -85,25 +85,25 @@
	void setNState( int parent_states, int* daug_states );

	// the amplitudes
	- EvtComplex _amp[125];
	+ EvtComplex m_amp[125];

	// the number of daughters
	- int _ndaug;
	+ int m_ndaug;

	// the number of states of the parent
	- int _pstates;
	+ int m_pstates;

	// number of states of the daughter
	- int dstates[10];
	+ int m_dstates[10];

	// the nontrivial index of the daughter
	- int _dnontrivial[10];
	+ int m_dnontrivial[10];

	// number of nontrivial daugts+parent
	- int _nontrivial;
	+ int m_nontrivial;

	// compact nstates
	- int _nstate[5];
	+ int m_nstate[5];
	};

	#endif
	diff --git a/EvtGenBase/EvtAmpFactory.hh b/EvtGenBase/EvtAmpFactory.hh
	--- a/EvtGenBase/EvtAmpFactory.hh
	+++ b/EvtGenBase/EvtAmpFactory.hh
	@@ -44,13 +44,13 @@
	protected:
	EvtAmpFactory( EvtAmpFactory<T>&& ) = default;
	EvtAmpFactory( const EvtAmpFactory<T>& other ) :
	- _amp( other._amp ? other._amp->clone() : nullptr ),
	- _ampConj( other._ampConj ? other._ampConj->clone() : nullptr ),
	- _pc( other._pc ? other._pc->clone() : nullptr ),
	- _names( other._names ),
	- _dm( other._dm ),
	- _mixPhase( other._mixPhase ),
	- _verbose( other._verbose )
	+ m_amp( other.m_amp ? other.m_amp->clone() : nullptr ),
	+ m_ampConj( other.m_ampConj ? other.m_ampConj->clone() : nullptr ),
	+ m_pc( other.m_pc ? other.m_pc->clone() : nullptr ),
	+ m_names( other.m_names ),
	+ m_dm( other.m_dm ),
	+ m_mixPhase( other.m_mixPhase ),
	+ m_verbose( other.m_verbose )
	{
	}

	@@ -61,12 +61,12 @@

	virtual void build( const EvtMultiChannelParser& parser, int nItg )
	{
	- _amp = std::make_unique<EvtAmplitudeSum<T>>();
	- _ampConj = std::make_unique<EvtAmplitudeSum<T>>();
	- _pc = std::make_unique<EvtPdfSum<T>>();
	- _dm = parser.dm();
	- _mixAmpli = parser.mixAmpli();
	- _mixPhase = parser.mixPhase();
	+ m_amp = std::make_unique<EvtAmplitudeSum<T>>();
	+ m_ampConj = std::make_unique<EvtAmplitudeSum<T>>();
	+ m_pc = std::make_unique<EvtPdfSum<T>>();
	+ m_dm = parser.dm();
	+ m_mixAmpli = parser.mixAmpli();
	+ m_mixPhase = parser.mixPhase();

	printf( "Amplitude with %d terms\n", parser.getNAmp() );
	int i;
	@@ -85,7 +85,7 @@

	printf( "Calculating pole compensator integrals %d steps\n", nItg );
	if ( nItg > 0 )
	- _pc->getItg( nItg );
	+ m_pc->getItg( nItg );

	printf( "End build\n" );
	}
	@@ -95,50 +95,52 @@

	inline bool isCPModel() const
	{
	- return ( _ampConj->nTerms() > 0 ? true : false );
	+ return ( m_ampConj->nTerms() > 0 ? true : false );
	}
	- inline double dm() const { return _dm; }
	- inline double mixAmpli() const { return _mixAmpli; }
	- inline double mixPhase() const { return _mixPhase; }
	+ inline double dm() const { return m_dm; }
	+ inline double mixAmpli() const { return m_mixAmpli; }
	+ inline double mixPhase() const { return m_mixPhase; }

	- void setVerbose() { _verbose = true; }
	+ void setVerbose() { m_verbose = true; }

	- EvtAmplitudeSum<T>* getAmp() const { return _amp.get(); }
	- EvtAmplitudeSum<T>* getAmpConj() const { return _ampConj.get(); }
	- EvtPdfSum<T>* getPC() const { return _pc.get(); }
	- EvtAmplitude<T>* getAmp( int i ) const { return _amp->getTerm( i ); }
	- EvtPdf<T>* getPC( int i ) const { return _pc->getPdf( i ); }
	- const char* compName( int i ) const { return _names[i].c_str(); }
	+ EvtAmplitudeSum<T>* getAmp() const { return m_amp.get(); }
	+ EvtAmplitudeSum<T>* getAmpConj() const { return m_ampConj.get(); }
	+ EvtPdfSum<T>* getPC() const { return m_pc.get(); }
	+ EvtAmplitude<T>* getAmp( int i ) const { return m_amp->getTerm( i ); }
	+ EvtPdf<T>* getPC( int i ) const { return m_pc->getPdf( i ); }
	+ const char* compName( int i ) const { return m_names[i].c_str(); }

	- EvtComplex getCoeff( int i ) const { return _amp->c( i ); }
	+ EvtComplex getCoeff( int i ) const { return m_amp->c( i ); }

	- double getTermCoeff( int i ) const { return abs2( _amp->c( i ) ); }
	+ double getTermCoeff( int i ) const { return abs2( m_amp->c( i ) ); }
	double getTermCoeff( int type, int i, int j ) const
	{
	switch ( type ) {
	case 0:
	- return 2 * real( _amp->c( i ) * conj( _amp->c( j ) ) ); //posre
	+ return 2 * real( m_amp->c( i ) * conj( m_amp->c( j ) ) ); //posre
	case 1:
	- return -2 * real( _amp->c( i ) * conj( _amp->c( j ) ) ); //negre
	+ return -2 *
	+ real( m_amp->c( i ) * conj( m_amp->c( j ) ) ); //negre
	case 2:
	- return -2 * imag( _amp->c( i ) * conj( _amp->c( j ) ) ); //posim
	+ return -2 *
	+ imag( m_amp->c( i ) * conj( m_amp->c( j ) ) ); //posim
	case 3:
	- return 2 * imag( _amp->c( i ) * conj( _amp->c( j ) ) ); //negim
	+ return 2 * imag( m_amp->c( i ) * conj( m_amp->c( j ) ) ); //negim
	default:
	assert( 0 );
	}
	}

	protected:
	- std::unique_ptr<EvtAmplitudeSum<T>> _amp; // _owned_ amplitude
	- std::unique_ptr<EvtAmplitudeSum<T>> _ampConj; // _owned_ conjugate amplitude
	- std::unique_ptr<EvtPdfSum<T>> _pc; // _owned_ pole compensator
	- std::vector<std::string> _names; // names of partial amplitudes
	-
	- double _dm = 0; // Mass difference for conjugate amplitude
	- double _mixPhase; // mixing phase
	- double _mixAmpli; // cpv in mixing
	- bool _verbose = false;
	+ std::unique_ptr<EvtAmplitudeSum<T>> m_amp; // _owned_ amplitude
	+ std::unique_ptr<EvtAmplitudeSum<T>> m_ampConj; // _owned_ conjugate amplitude
	+ std::unique_ptr<EvtPdfSum<T>> m_pc; // _owned_ pole compensator
	+ std::vector<std::string> m_names; // names of partial amplitudes
	+
	+ double m_dm = 0; // Mass difference for conjugate amplitude
	+ double m_mixPhase; // mixing phase
	+ double m_mixAmpli; // cpv in mixing
	+ bool m_verbose = false;
	};

	#endif
	diff --git a/EvtGenBase/EvtAmpPdf.hh b/EvtGenBase/EvtAmpPdf.hh
	--- a/EvtGenBase/EvtAmpPdf.hh
	+++ b/EvtGenBase/EvtAmpPdf.hh
	@@ -30,25 +30,25 @@
	class EvtAmpPdf : public EvtPdf<T> {
	public:
	EvtAmpPdf() {}
	- EvtAmpPdf( const EvtAmplitude<T>& amp ) : EvtPdf<T>(), _amp( amp.clone() )
	+ EvtAmpPdf( const EvtAmplitude<T>& amp ) : EvtPdf<T>(), m_amp( amp.clone() )
	{
	}
	EvtAmpPdf( const EvtAmpPdf<T>& other ) :
	- EvtPdf<T>( other ), COPY_PTR( _amp )
	+ EvtPdf<T>( other ), COPY_PTR( m_amp )
	{
	}
	- virtual ~EvtAmpPdf() { delete _amp; }
	+ virtual ~EvtAmpPdf() { delete m_amp; }

	EvtAmpPdf<T>* clone() const override { return new EvtAmpPdf( *this ); }

	double pdf( const T& p ) const override
	{
	- EvtComplex amp = _amp->evaluate( p );
	+ EvtComplex amp = m_amp->evaluate( p );
	return real( amp ) * real( amp ) + imag( amp ) * imag( amp );
	}

	private:
	- EvtAmplitude<T>* _amp;
	+ EvtAmplitude<T>* m_amp;
	};

	#endif
	diff --git a/EvtGenBase/EvtAmplitudeSum.hh b/EvtGenBase/EvtAmplitudeSum.hh
	--- a/EvtGenBase/EvtAmplitudeSum.hh
	+++ b/EvtGenBase/EvtAmplitudeSum.hh
	@@ -37,19 +37,19 @@
	int i;
	for ( i = 0; i < other.nTerms(); i++ ) {
	EvtComplex c = other.c( i );
	- _c.push_back( c );
	+ m_c.push_back( c );
	EvtAmplitude<T>* amp = other.getTerm( i );
	assert( amp );
	EvtAmplitude<T>* amp1 = amp->clone();
	assert( amp1 );
	- _term.push_back( amp1 );
	+ m_term.push_back( amp1 );
	}
	}

	virtual ~EvtAmplitudeSum()
	{
	- for ( size_t i = 0; i < _term.size(); i++ ) {
	- delete _term[i];
	+ for ( size_t i = 0; i < m_term.size(); i++ ) {
	+ delete m_term[i];
	}
	}

	@@ -60,18 +60,18 @@

	void addTerm( EvtComplex c, const EvtAmplitude<T>& amp )
	{
	- _c.push_back( c );
	- _term.push_back( amp.clone() );
	+ m_c.push_back( c );
	+ m_term.push_back( amp.clone() );
	}

	void addOwnedTerm( EvtComplex c, std::unique_ptr<EvtAmplitude<T>> amp )
	{
	assert( amp );
	- _c.push_back( c );
	- _term.push_back( amp.release() );
	+ m_c.push_back( c );
	+ m_term.push_back( amp.release() );
	}

	- int nTerms() const { return _term.size(); } // number of terms
	+ int nTerms() const { return m_term.size(); } // number of terms

	void print() const
	{
	@@ -79,31 +79,31 @@
	printf( "Amplitude has %d terms\n", N );
	int i;
	for ( i = 0; i < N; i++ ) {
	- printf( "c%d = (%f,%f)\n", i, real( _c[i] ), imag( _c[i] ) );
	- assert( _term[i] );
	+ printf( "c%d = (%f,%f)\n", i, real( m_c[i] ), imag( m_c[i] ) );
	+ assert( m_term[i] );
	}
	}

	- inline EvtComplex c( int i ) const { return _c[i]; }
	- inline EvtAmplitude<T>* getTerm( int i ) const { return _term[i]; }
	+ inline EvtComplex c( int i ) const { return m_c[i]; }
	+ inline EvtAmplitude<T>* getTerm( int i ) const { return m_term[i]; }

	protected:
	EvtComplex amplitude( const T& p ) const override
	{
	- if ( _term.size() == 0 )
	+ if ( m_term.size() == 0 )
	printf( "Warning: amplitude sum has zero terms\n" );

	EvtComplex value = 0.;

	- for ( size_t i = 0; i < _term.size(); i++ ) {
	- value += _c[i] * _term[i]->evaluate( p );
	+ for ( size_t i = 0; i < m_term.size(); i++ ) {
	+ value += m_c[i] * m_term[i]->evaluate( p );
	}
	return value;
	}

	private:
	- std::vector<EvtComplex> _c; // coefficients
	- std::vector<EvtAmplitude<T>*> _term; // pointers to amplitudes
	+ std::vector<EvtComplex> m_c; // coefficients
	+ std::vector<EvtAmplitude<T>*> m_term; // pointers to amplitudes
	};

	#endif
	diff --git a/EvtGenBase/EvtBlattWeisskopf.hh b/EvtGenBase/EvtBlattWeisskopf.hh
	--- a/EvtGenBase/EvtBlattWeisskopf.hh
	+++ b/EvtGenBase/EvtBlattWeisskopf.hh
	@@ -32,11 +32,11 @@
	double operator()( double p ) const;

	private:
	- int _LL; // angular momentum of daughters
	- double _radial; // resonance radial parameter
	- double _p0;
	+ int m_LL; // angular momentum of daughters
	+ double m_radial; // resonance radial parameter
	+ double m_p0;

	- double _F0; // formula evaluated at _p0
	+ double m_F0; // formula evaluated at m_p0
	double compute( double p ) const;
	};

	diff --git a/EvtGenBase/EvtCGCoefSingle.hh b/EvtGenBase/EvtCGCoefSingle.hh
	--- a/EvtGenBase/EvtCGCoefSingle.hh
	+++ b/EvtGenBase/EvtCGCoefSingle.hh
	@@ -33,13 +33,13 @@
	void init( int j1, int j2 );
	double& cg( int J, int M, int m1, int m2 );

	- int _j1;
	- int _j2;
	+ int m_j1;
	+ int m_j2;

	- int _Jmax;
	- int _Jmin;
	+ int m_Jmax;
	+ int m_Jmin;

	- std::vector<std::vector<std::vector<double>>> _table;
	+ std::vector<std::vector<std::vector<double>>> m_table;
	};

	#endif
	diff --git a/EvtGenBase/EvtCPUtil.hh b/EvtGenBase/EvtCPUtil.hh
	--- a/EvtGenBase/EvtCPUtil.hh
	+++ b/EvtGenBase/EvtCPUtil.hh
	@@ -39,8 +39,8 @@

	static EvtCPUtil* getInstance();

	- void setMixingType( int mixingType ) { _mixingType = mixingType; }
	- int getMixingType() { return _mixingType; }
	+ void setMixingType( int mixingType ) { m_mixingType = mixingType; }
	+ int getMixingType() { return m_mixingType; }

	void fractB0CP( EvtComplex Af, EvtComplex Abarf, double deltam, double beta,
	double& fract );
	@@ -77,8 +77,8 @@
	double getDeltaM( const EvtId id );

	private:
	- bool _enableFlip;
	- int _mixingType;
	+ bool m_enableFlip;
	+ int m_mixingType;
	};

	#endif
	diff --git a/EvtGenBase/EvtComplex.hh b/EvtGenBase/EvtComplex.hh
	--- a/EvtGenBase/EvtComplex.hh
	+++ b/EvtGenBase/EvtComplex.hh
	@@ -50,12 +50,13 @@
	friend std::ostream& operator<<( std::ostream& s, const EvtComplex& c );

	public:
	- EvtComplex() : _rpart( 0.0 ), _ipart( 0.0 ) {}
	+ EvtComplex() : m_rpart( 0.0 ), m_ipart( 0.0 ) {}
	EvtComplex( double rpart, double ipart = 0.0 ) :
	- _rpart( rpart ), _ipart( ipart )
	+ m_rpart( rpart ), m_ipart( ipart )
	{
	}
	- EvtComplex( const EvtComplex& c ) : _rpart( c._rpart ), _ipart( c._ipart )
	+ EvtComplex( const EvtComplex& c ) :
	+ m_rpart( c.m_rpart ), m_ipart( c.m_ipart )
	{
	}
	inline EvtComplex& operator*=( double d );
	@@ -71,7 +72,7 @@
	inline int operator!=( const EvtComplex c );

	private:
	- double _rpart, _ipart;
	+ double m_rpart, m_ipart;
	};

	typedef EvtComplex* EvtComplexPtr;
	@@ -80,127 +81,128 @@

	EvtComplex& EvtComplex::operator=( const EvtComplex& c )
	{
	- _rpart = c._rpart;
	- _ipart = c._ipart;
	+ m_rpart = c.m_rpart;
	+ m_ipart = c.m_ipart;

	return *this;
	}

	EvtComplex& EvtComplex::operator+=( const EvtComplex& c )
	{
	- _rpart += c._rpart;
	- _ipart += c._ipart;
	+ m_rpart += c.m_rpart;
	+ m_ipart += c.m_ipart;

	return *this;
	}

	EvtComplex& EvtComplex::operator-=( const EvtComplex& c )
	{
	- _rpart -= c._rpart;
	- _ipart -= c._ipart;
	+ m_rpart -= c.m_rpart;
	+ m_ipart -= c.m_ipart;

	return *this;
	}

	EvtComplex& EvtComplex::operator+=( double d )
	{
	- _rpart += d;
	+ m_rpart += d;

	return *this;
	}

	EvtComplex& EvtComplex::operator-=( double d )
	{
	- _rpart -= d;
	+ m_rpart -= d;

	return *this;
	}

	EvtComplex operator*( double d, const EvtComplex& c )
	{
	- return EvtComplex( c._rpart * d, c._ipart * d );
	+ return EvtComplex( c.m_rpart * d, c.m_ipart * d );
	}

	EvtComplex operator*( const EvtComplex& c, double d )
	{
	- return EvtComplex( c._rpart * d, c._ipart * d );
	+ return EvtComplex( c.m_rpart * d, c.m_ipart * d );
	}

	EvtComplex operator/( const EvtComplex& c, double d )
	{
	- return EvtComplex( c._rpart / d, c._ipart / d );
	+ return EvtComplex( c.m_rpart / d, c.m_ipart / d );
	}

	EvtComplex& EvtComplex::operator*=( double d )
	{
	- _rpart *= d;
	- _ipart *= d;
	+ m_rpart *= d;
	+ m_ipart *= d;

	return *this;
	}

	EvtComplex& EvtComplex::operator/=( double d )
	{
	- _rpart /= d;
	- _ipart /= d;
	+ m_rpart /= d;
	+ m_ipart /= d;

	return *this;
	}

	EvtComplex operator/( double d, const EvtComplex& c )
	{
	- double Num = d / ( c._rpart * c._rpart + c._ipart * c._ipart );
	+ double Num = d / ( c.m_rpart * c.m_rpart + c.m_ipart * c.m_ipart );

	- return EvtComplex( Num * c._rpart, -Num * c._ipart );
	+ return EvtComplex( Num * c.m_rpart, -Num * c.m_ipart );
	}

	EvtComplex operator/( const EvtComplex& c1, const EvtComplex& c2 )
	{
	- double inv = 1.0 / ( c2._rpart * c2._rpart + c2._ipart * c2._ipart );
	+ double inv = 1.0 / ( c2.m_rpart * c2.m_rpart + c2.m_ipart * c2.m_ipart );

	- return EvtComplex( inv * ( c1._rpart * c2._rpart + c1._ipart * c2._ipart ),
	- inv * ( c1._ipart * c2._rpart - c1._rpart * c2._ipart ) );
	+ return EvtComplex(
	+ inv * ( c1.m_rpart * c2.m_rpart + c1.m_ipart * c2.m_ipart ),
	+ inv * ( c1.m_ipart * c2.m_rpart - c1.m_rpart * c2.m_ipart ) );
	}

	EvtComplex operator*( const EvtComplex& c1, const EvtComplex& c2 )
	{
	- return EvtComplex( c1._rpart * c2._rpart - c1._ipart * c2._ipart,
	- c1._rpart * c2._ipart + c1._ipart * c2._rpart );
	+ return EvtComplex( c1.m_rpart * c2.m_rpart - c1.m_ipart * c2.m_ipart,
	+ c1.m_rpart * c2.m_ipart + c1.m_ipart * c2.m_rpart );
	}

	EvtComplex operator-( const EvtComplex& c1, const EvtComplex& c2 )
	{
	- return EvtComplex( c1._rpart - c2._rpart, c1._ipart - c2._ipart );
	+ return EvtComplex( c1.m_rpart - c2.m_rpart, c1.m_ipart - c2.m_ipart );
	}

	EvtComplex operator+( const EvtComplex& c1, const EvtComplex& c2 )
	{
	- return EvtComplex( c1._rpart + c2._rpart, c1._ipart + c2._ipart );
	+ return EvtComplex( c1.m_rpart + c2.m_rpart, c1.m_ipart + c2.m_ipart );
	}

	int EvtComplex::operator==( const EvtComplex c )
	{
	- return _rpart == c._rpart && _ipart == c._ipart;
	+ return m_rpart == c.m_rpart && m_ipart == c.m_ipart;
	}

	int EvtComplex::operator!=( const EvtComplex c )
	{
	- return _rpart != c._rpart \|\| _ipart != c._ipart;
	+ return m_rpart != c.m_rpart \|\| m_ipart != c.m_ipart;
	}

	EvtComplex operator-( const EvtComplex& c )
	{
	- return EvtComplex( -c._rpart, -c._ipart );
	+ return EvtComplex( -c.m_rpart, -c.m_ipart );
	}

	EvtComplex conj( const EvtComplex& c )
	{
	- return EvtComplex( c._rpart, -c._ipart );
	+ return EvtComplex( c.m_rpart, -c.m_ipart );
	}

	double abs( const EvtComplex& c )
	{
	- double c2 = c._rpart * c._rpart + c._ipart * c._ipart;
	+ double c2 = c.m_rpart * c.m_rpart + c.m_ipart * c.m_ipart;
	if ( c2 <= 0.0 )
	return 0.0;
	return sqrt( c2 );
	@@ -208,38 +210,38 @@

	double abs2( const EvtComplex& c )
	{
	- return c._rpart * c._rpart + c._ipart * c._ipart;
	+ return c.m_rpart * c.m_rpart + c.m_ipart * c.m_ipart;
	}

	double arg( const EvtComplex& c )
	{
	- if ( ( c._rpart == 0 ) && ( c._ipart == 0 ) ) {
	+ if ( ( c.m_rpart == 0 ) && ( c.m_ipart == 0 ) ) {
	return 0.0;
	}
	- if ( c._rpart == 0 ) {
	- if ( c._ipart > 0 ) {
	+ if ( c.m_rpart == 0 ) {
	+ if ( c.m_ipart > 0 ) {
	return EvtConst::pi / 2;
	} else {
	return -EvtConst::pi / 2;
	}
	} else {
	- return atan2( c._ipart, c._rpart );
	+ return atan2( c.m_ipart, c.m_rpart );
	}
	}

	double real( const EvtComplex& c )
	{
	- return c._rpart;
	+ return c.m_rpart;
	}

	double imag( const EvtComplex& c )
	{
	- return c._ipart;
	+ return c.m_ipart;
	}

	EvtComplex exp( const EvtComplex& c )
	{
	- return exp( c._rpart ) * EvtComplex( cos( c._ipart ), sin( c._ipart ) );
	+ return exp( c.m_rpart ) * EvtComplex( cos( c.m_ipart ), sin( c.m_ipart ) );
	}

	#endif
	diff --git a/EvtGenBase/EvtDalitzCoord.hh b/EvtGenBase/EvtDalitzCoord.hh
	--- a/EvtGenBase/EvtDalitzCoord.hh
	+++ b/EvtGenBase/EvtDalitzCoord.hh
	@@ -36,10 +36,10 @@
	double q2 );
	EvtDalitzCoord( const EvtDalitzCoord& other );

	- inline EvtCyclic3::Pair pair1() const { return _i1; }
	- inline EvtCyclic3::Pair pair2() const { return _i2; }
	- inline double q1() const { return _q1; }
	- inline double q2() const { return _q2; }
	+ inline EvtCyclic3::Pair pair1() const { return m_i1; }
	+ inline EvtCyclic3::Pair pair2() const { return m_i2; }
	+ inline double q1() const { return m_q1; }
	+ inline double q2() const { return m_q2; }

	// It's nice to have an equality operator for
	// a coordinate. However, beware effects of numerical precision
	@@ -51,11 +51,11 @@
	private:
	// Two coordinates define the point

	- EvtCyclic3::Pair _i1;
	- EvtCyclic3::Pair _i2;
	+ EvtCyclic3::Pair m_i1;
	+ EvtCyclic3::Pair m_i2;

	- double _q1;
	- double _q2;
	+ double m_q1;
	+ double m_q2;
	};

	std::ostream& operator<<( std::ostream&, const EvtDalitzCoord& );
	diff --git a/EvtGenBase/EvtDalitzFlatPdf.hh b/EvtGenBase/EvtDalitzFlatPdf.hh
	--- a/EvtGenBase/EvtDalitzFlatPdf.hh
	+++ b/EvtGenBase/EvtDalitzFlatPdf.hh
	@@ -44,7 +44,7 @@
	protected:
	double pdf( const EvtDalitzPoint& ) const override;

	- EvtDalitzPlot _dp;
	+ EvtDalitzPlot m_dp;
	};

	#endif
	diff --git a/EvtGenBase/EvtDalitzPlot.hh b/EvtGenBase/EvtDalitzPlot.hh
	--- a/EvtGenBase/EvtDalitzPlot.hh
	+++ b/EvtGenBase/EvtDalitzPlot.hh
	@@ -52,9 +52,9 @@
	double qResAbsMax( EvtCyclic3::Pair i ) const;
	double qHelAbsMin( EvtCyclic3::Pair i ) const;
	double qHelAbsMax( EvtCyclic3::Pair i ) const;
	- inline double qSumMin() const { return sum() + _ldel; }
	- inline double qSumMax() const { return sum() + _rdel; }
	- inline bool fuzzy() const { return ( _rdel - _ldel != 0. ); }
	+ inline double qSumMin() const { return sum() + m_ldel; }
	+ inline double qSumMax() const { return sum() + m_rdel; }
	+ inline bool fuzzy() const { return ( m_rdel - m_ldel != 0. ); }

	// Find the area of the Dalitz plot by numeric integration. (N bins for variable q(i) are used).
	// Very large numbers of N can result in a very long calculation. It should not
	@@ -92,10 +92,10 @@
	// Accessors

	double sum() const;
	- inline double bigM() const { return _bigM; }
	- inline double mA() const { return _mA; }
	- inline double mB() const { return _mB; }
	- inline double mC() const { return _mC; }
	+ inline double bigM() const { return m_bigM; }
	+ inline double mA() const { return m_mA; }
	+ inline double mB() const { return m_mB; }
	+ inline double mC() const { return m_mC; }
	double m( EvtCyclic3::Index i ) const;

	void print() const;
	@@ -105,15 +105,15 @@
	protected:
	// Defines two dimensional dalitz plot

	- double _mA;
	- double _mB;
	- double _mC;
	- double _bigM;
	+ double m_mA;
	+ double m_mB;
	+ double m_mC;
	+ double m_bigM;

	// Defines third dimension, or fuzziness. M^2 + ldel < M^2 < M^2 + rdel

	- double _ldel;
	- double _rdel;
	+ double m_ldel;
	+ double m_rdel;
	};

	#endif
	diff --git a/EvtGenBase/EvtDalitzPoint.hh b/EvtGenBase/EvtDalitzPoint.hh
	--- a/EvtGenBase/EvtDalitzPoint.hh
	+++ b/EvtGenBase/EvtDalitzPoint.hh
	@@ -74,8 +74,8 @@
	void print() const;

	private:
	- double _mA, _mB, _mC; // masses
	- double _qAB, _qBC, _qCA; // masses squared
	+ double m_mA, m_mB, m_mC; // masses
	+ double m_qAB, m_qBC, m_qCA; // masses squared
	};

	#endif
	diff --git a/EvtGenBase/EvtDalitzResPdf.hh b/EvtGenBase/EvtDalitzResPdf.hh
	--- a/EvtGenBase/EvtDalitzResPdf.hh
	+++ b/EvtGenBase/EvtDalitzResPdf.hh
	@@ -58,10 +58,10 @@
	double pdf( const EvtDalitzPoint& ) const override;

	private:
	- EvtDalitzPlot _dp;
	- double _m0; // mass
	- double _g0; // width
	- EvtCyclic3::Pair _pair; // resonant pair
	+ EvtDalitzPlot m_dp;
	+ double m_m0; // mass
	+ double m_g0; // width
	+ EvtCyclic3::Pair m_pair; // resonant pair
	};

	#endif
	diff --git a/EvtGenBase/EvtDalitzReso.hh b/EvtGenBase/EvtDalitzReso.hh
	--- a/EvtGenBase/EvtDalitzReso.hh
	+++ b/EvtGenBase/EvtDalitzReso.hh
	@@ -87,11 +87,11 @@
	WA76
	};

	- EvtDalitzReso() : _typeN( NON_RES ){};
	+ EvtDalitzReso() : m_typeN( NON_RES ){};

	EvtDalitzReso( const EvtDalitzPlot& dp, EvtCyclic3::Pair pairRes,
	NumType typeN, double alpha = 0.0 ) :
	- _dp( dp ), _pairRes( pairRes ), _typeN( typeN ), _alpha( alpha ){};
	+ m_dp( dp ), m_pairRes( pairRes ), m_typeN( typeN ), m_alpha( alpha ){};

	EvtDalitzReso( const EvtDalitzPlot& dp, EvtCyclic3::Pair pairAng,
	EvtCyclic3::Pair pairRes, EvtSpinType::spintype spin,
	@@ -126,12 +126,12 @@

	EvtComplex evaluate( const EvtDalitzPoint& p );

	- void set_fd( double R ) { _vd.set_f( R ); }
	- void set_fb( double R ) { _vb.set_f( R ); }
	+ void set_fd( double R ) { m_vd.set_f( R ); }
	+ void set_fb( double R ) { m_vb.set_f( R ); }

	void addFlatteParam( const EvtFlatteParam& param )
	{
	- _flatteParams.push_back( param );
	+ m_flatteParams.push_back( param );
	}

	private:
	@@ -171,59 +171,59 @@
	}

	// Dalitz plot
	- EvtDalitzPlot _dp;
	+ EvtDalitzPlot m_dp;

	// Pairing indices:
	- EvtCyclic3::Pair _pairAng; // angular
	- EvtCyclic3::Pair _pairRes; // resonance
	+ EvtCyclic3::Pair m_pairAng; // angular
	+ EvtCyclic3::Pair m_pairRes; // resonance

	// Spin
	- EvtSpinType::spintype _spin;
	+ EvtSpinType::spintype m_spin;

	// Numerator type
	- NumType _typeN;
	+ NumType m_typeN;

	// Nominal mass and width
	- double _m0, _g0;
	+ double m_m0, m_g0;

	// Vertices
	- EvtTwoBodyVertex _vb;
	- EvtTwoBodyVertex _vd;
	+ EvtTwoBodyVertex m_vb;
	+ EvtTwoBodyVertex m_vd;

	// Daughter masses
	- double _massFirst, _massSecond;
	+ double m_massFirst, m_massSecond;

	// variables for electromagnetic mass mixing
	- double _m0_mix, _g0_mix, _delta_mix;
	- EvtComplex _amp_mix;
	+ double m_m0_mix, m_g0_mix, m_delta_mix;
	+ EvtComplex m_amp_mix;

	// variables for coupled Breit-Wigner
	- double _g1, _g2;
	- CouplingType _coupling2;
	+ double m_g1, m_g2;
	+ CouplingType m_coupling2;

	// variables for Blatt-Weisskopf form factors
	- double _f_b, _f_d;
	+ double m_f_b, m_f_d;

	// K-matrix
	- int _kmatrix_index;
	- EvtComplex _fr12prod, _fr13prod, _fr14prod, _fr15prod;
	- double _s0prod;
	+ int m_kmatrix_index;
	+ EvtComplex m_fr12prod, m_fr13prod, m_fr14prod, m_fr15prod;
	+ double m_s0prod;

	// LASS
	- double _a;
	- double _r;
	- double _Blass;
	- double _phiB;
	- double _R;
	- double _phiR;
	- double _cutoff;
	- bool _scaleByMOverQ;
	+ double m_a;
	+ double m_r;
	+ double m_Blass;
	+ double m_phiB;
	+ double m_R;
	+ double m_phiR;
	+ double m_cutoff;
	+ bool m_scaleByMOverQ;

	//Nonresonant
	- double _alpha;
	+ double m_alpha;

	// Flatte
	- std::vector<EvtFlatteParam> _flatteParams;
	+ std::vector<EvtFlatteParam> m_flatteParams;
	};

	#endif
	diff --git a/EvtGenBase/EvtDecayAmp.hh b/EvtGenBase/EvtDecayAmp.hh
	--- a/EvtGenBase/EvtDecayAmp.hh
	+++ b/EvtGenBase/EvtDecayAmp.hh
	@@ -29,24 +29,24 @@
	class EvtDecayAmp : public EvtDecayBase {
	public:
	void makeDecay( EvtParticle* p, bool recursive = true ) override;
	- inline void setWeight( double weight ) { _weight = weight; }
	+ inline void setWeight( double weight ) { m_weight = weight; }

	/**
	* sets the amplitudes calculated in the decay objects
	*/
	- void vertex( const EvtComplex& amp ) { _amp2.vertex( amp ); }
	+ void vertex( const EvtComplex& amp ) { m_amp2.vertex( amp ); }

	/**
	* sets the amplitudes calculated in the decay objects
	*/
	- void vertex( int i1, const EvtComplex& amp ) { _amp2.vertex( i1, amp ); }
	+ void vertex( int i1, const EvtComplex& amp ) { m_amp2.vertex( i1, amp ); }

	/**
	* sets the amplitudes calculated in the decay objects
	*/
	void vertex( int i1, int i2, const EvtComplex& amp )
	{
	- _amp2.vertex( i1, i2, amp );
	+ m_amp2.vertex( i1, i2, amp );
	}

	/**
	@@ -54,26 +54,26 @@
	*/
	void vertex( int i1, int i2, int i3, const EvtComplex& amp )
	{
	- _amp2.vertex( i1, i2, i3, amp );
	+ m_amp2.vertex( i1, i2, i3, amp );
	}

	/**
	* sets the amplitudes calculated in the decay objects
	*/
	- void vertex( int* i1, const EvtComplex& amp ) { _amp2.vertex( i1, amp ); }
	+ void vertex( int* i1, const EvtComplex& amp ) { m_amp2.vertex( i1, amp ); }

	/**
	* Provide access to the amplitude
	*/
	- const EvtAmp& amplitude() const { return _amp2; }
	+ const EvtAmp& amplitude() const { return m_amp2; }

	virtual ~EvtDecayAmp() {}

	protected:
	- EvtAmp _amp2;
	+ EvtAmp m_amp2;

	private:
	- double _weight;
	+ double m_weight;
	};

	#endif
	diff --git a/EvtGenBase/EvtDecayBase.hh b/EvtGenBase/EvtDecayBase.hh
	--- a/EvtGenBase/EvtDecayBase.hh
	+++ b/EvtGenBase/EvtDecayBase.hh
	@@ -58,28 +58,28 @@

	virtual bool matchingDecay( const EvtDecayBase& other ) const;

	- EvtId getParentId() const { return _parent; }
	- double getBranchingFraction() const { return _brfr; }
	- void disableCheckQ() { _chkCharge = false; };
	+ EvtId getParentId() const { return m_parent; }
	+ double getBranchingFraction() const { return m_brfr; }
	+ void disableCheckQ() { m_chkCharge = false; };
	void checkQ();
	- int getNDaug() const { return _ndaug; }
	- EvtId* getDaugs() { return _daug.data(); }
	- EvtId getDaug( int i ) const { return _daug[i]; }
	- int getNArg() const { return _narg; }
	- bool getFSR() const { return _fsr; }
	- void setFSR() { _fsr = true; }
	- void setVerbose() { _verbose = true; }
	- void setSummary() { _summary = true; }
	+ int getNDaug() const { return m_ndaug; }
	+ EvtId* getDaugs() { return m_daug.data(); }
	+ EvtId getDaug( int i ) const { return m_daug[i]; }
	+ int getNArg() const { return m_narg; }
	+ bool getFSR() const { return m_fsr; }
	+ void setFSR() { m_fsr = true; }
	+ void setVerbose() { m_verbose = true; }
	+ void setSummary() { m_summary = true; }
	double* getArgs();
	- std::string* getArgsStr() { return _args.data(); }
	+ std::string* getArgsStr() { return m_args.data(); }
	double getArg( unsigned int j );
	- double getStoredArg( int j ) const { return _storedArgs.at( j ); }
	- double getNStoredArg() const { return _storedArgs.size(); }
	- std::string getArgStr( int j ) const { return _args[j]; }
	- std::string getModelName() const { return _modelname; }
	- int getDSum() const { return _dsum; }
	- bool summary() const { return _summary; }
	- bool verbose() const { return _verbose; }
	+ double getStoredArg( int j ) const { return m_storedArgs.at( j ); }
	+ double getNStoredArg() const { return m_storedArgs.size(); }
	+ std::string getArgStr( int j ) const { return m_args[j]; }
	+ std::string getModelName() const { return m_modelname; }
	+ int getDSum() const { return m_dsum; }
	+ bool summary() const { return m_summary; }
	+ bool verbose() const { return m_verbose; }

	void saveDecayInfo( EvtId ipar, int ndaug, EvtId* daug, int narg,
	std::vector<std::string>& args, std::string name,
	@@ -105,41 +105,42 @@

	// lange - some models can take more daughters
	// than they really have to fool aliases (VSSBMIX for example)
	- virtual int nRealDaughters() { return _ndaug; }
	+ virtual int nRealDaughters() { return m_ndaug; }

	protected:
	- bool _daugsDecayedByParentModel;
	- bool daugsDecayedByParentModel() { return _daugsDecayedByParentModel; }
	+ bool m_daugsDecayedByParentModel;
	+ bool daugsDecayedByParentModel() { return m_daugsDecayedByParentModel; }

	private:
	- std::vector<double> _storedArgs;
	- std::vector<EvtId> _daug;
	- std::vector<double> _argsD;
	- std::vector<std::string> _args;
	+ std::vector<double> m_storedArgs;
	+ std::vector<EvtId> m_daug;
	+ std::vector<double> m_argsD;
	+ std::vector<std::string> m_args;

	- std::string _modelname = "**********";
	+ std::string m_modelname = "**********";

	- EvtId _parent = EvtId( -1, -1 );
	- int _ndaug = 0;
	- int _narg = 0;
	- double _brfr = 0;
	- int _dsum = 0;
	+ EvtId m_parent = EvtId( -1, -1 );
	+ int m_ndaug = 0;
	+ int m_narg = 0;
	+ double m_brfr = 0;
	+ int m_dsum = 0;

	- bool _fsr = false;
	- bool _summary = false;
	- bool _verbose = false;
	+ bool m_fsr = false;
	+ bool m_summary = false;
	+ bool m_verbose = false;

	// The default is that the user module does _not_ set any probmax.
	- bool defaultprobmax = true;
	- int ntimes_prob = 0;
	- double probmax = 0.0;
	+ bool m_defaultprobmax = true;
	+ int m_ntimes_prob = 0;
	+ double m_probmax = 0.0;

	+ //Should charge conservation be checked when model is created?
	//Default is to check that charge is conserved
	- bool _chkCharge = true;
	+ bool m_chkCharge = true;

	//These are used for gathering statistics.
	- double sum_prob = 0.0;
	- double max_prob = 0.0;
	+ double m_sum_prob = 0.0;
	+ double m_max_prob = 0.0;
	};

	#endif
	diff --git a/EvtGenBase/EvtDecayIncoherent.hh b/EvtGenBase/EvtDecayIncoherent.hh
	--- a/EvtGenBase/EvtDecayIncoherent.hh
	+++ b/EvtGenBase/EvtDecayIncoherent.hh
	@@ -36,17 +36,17 @@

	void setDaughterSpinDensity( int daughter )
	{
	- spinDensitySet[daughter] = 1;
	+ m_spinDensitySet[daughter] = 1;
	return;
	}

	int isDaughterSpinDensitySet( int daughter )
	{
	- return spinDensitySet[daughter];
	+ return m_spinDensitySet[daughter];
	}

	private:
	- int spinDensitySet[MAX_DAUG];
	+ int m_spinDensitySet[MAX_DAUG];
	};

	#endif
	diff --git a/EvtGenBase/EvtDecayMode.hh b/EvtGenBase/EvtDecayMode.hh
	--- a/EvtGenBase/EvtDecayMode.hh
	+++ b/EvtGenBase/EvtDecayMode.hh
	@@ -47,8 +47,8 @@
	std::string mode() const;

	private:
	- std::string _mother;
	- std::vector<std::string> _dau;
	+ std::string m_mother;
	+ std::vector<std::string> m_dau;
	};

	std::ostream& operator<<( std::ostream&, const EvtDecayMode& );
	diff --git a/EvtGenBase/EvtDecayProb.hh b/EvtGenBase/EvtDecayProb.hh
	--- a/EvtGenBase/EvtDecayProb.hh
	+++ b/EvtGenBase/EvtDecayProb.hh
	@@ -29,13 +29,13 @@
	public:
	void makeDecay( EvtParticle* p, bool recursive = true ) override;

	- void setProb( double prob ) { _prob = prob; }
	- double getProb() { return _prob; }
	- inline void setWeight( double weight ) { _weight = weight; }
	+ void setProb( double prob ) { m_prob = prob; }
	+ double getProb() { return m_prob; }
	+ inline void setWeight( double weight ) { m_weight = weight; }

	private:
	- double _prob{ 1.0 };
	- double _weight{ 1.0 };
	+ double m_prob{ 1.0 };
	+ double m_weight{ 1.0 };
	};

	#endif
	diff --git a/EvtGenBase/EvtDecayTable.hh b/EvtGenBase/EvtDecayTable.hh
	--- a/EvtGenBase/EvtDecayTable.hh
	+++ b/EvtGenBase/EvtDecayTable.hh
	@@ -57,7 +57,7 @@

	void checkConj();

	- std::vector<EvtParticleDecayList> getDecayTable() { return _decaytable; };
	+ std::vector<EvtParticleDecayList> getDecayTable() { return m_decaytable; };

	EvtDecayBase* findDecayModel( int aliasInt, int modeInt );
	EvtDecayBase* findDecayModel( EvtId id, int modeInt );
	@@ -76,7 +76,7 @@
	~EvtDecayTable();

	private:
	- std::vector<EvtParticleDecayList> _decaytable;
	+ std::vector<EvtParticleDecayList> m_decaytable;

	EvtDecayTable( const EvtDecayTable& ){};
	//EvtDecayTable& operator=(const EvtDecayTable&) {};
	diff --git a/EvtGenBase/EvtDiracParticle.hh b/EvtGenBase/EvtDiracParticle.hh
	--- a/EvtGenBase/EvtDiracParticle.hh
	+++ b/EvtGenBase/EvtDiracParticle.hh
	@@ -34,15 +34,18 @@
	void init( EvtId part_n, const EvtVector4R& p4, const EvtDiracSpinor&,
	const EvtDiracSpinor&, const EvtDiracSpinor&,
	const EvtDiracSpinor& );
	- EvtDiracSpinor spParent( int i ) const override { return _spinorParent[i]; }
	- EvtDiracSpinor sp( int i ) const override { return _spinorRest[i]; }
	+ EvtDiracSpinor spParent( int i ) const override
	+ {
	+ return m_spinorParent[i];
	+ }
	+ EvtDiracSpinor sp( int i ) const override { return m_spinorRest[i]; }
	EvtSpinDensity rotateToHelicityBasis() const override;
	EvtSpinDensity rotateToHelicityBasis( double alpha, double beta,
	double gamma ) const override;

	private:
	- EvtDiracSpinor _spinorRest[2];
	- EvtDiracSpinor _spinorParent[2];
	+ EvtDiracSpinor m_spinorRest[2];
	+ EvtDiracSpinor m_spinorParent[2];
	EvtDiracParticle( const EvtDiracParticle& d );
	EvtDiracParticle& operator=( const EvtDiracParticle& d );
	};
	diff --git a/EvtGenBase/EvtDiracSpinor.hh b/EvtGenBase/EvtDiracSpinor.hh
	--- a/EvtGenBase/EvtDiracSpinor.hh
	+++ b/EvtGenBase/EvtDiracSpinor.hh
	@@ -81,41 +81,41 @@
	EvtDiracSpinor adjoint() const;

	private:
	- EvtComplex spinor[4];
	+ EvtComplex m_spinor[4];
	};

	EvtDiracSpinor::EvtDiracSpinor()
	{
	- spinor[0] = EvtComplex();
	- spinor[1] = EvtComplex();
	- spinor[2] = EvtComplex();
	- spinor[3] = EvtComplex();
	+ m_spinor[0] = EvtComplex();
	+ m_spinor[1] = EvtComplex();
	+ m_spinor[2] = EvtComplex();
	+ m_spinor[3] = EvtComplex();
	}

	EvtDiracSpinor::EvtDiracSpinor( const EvtDiracSpinor& dspinor )
	{
	- spinor[0] = dspinor.spinor[0];
	- spinor[1] = dspinor.spinor[1];
	- spinor[2] = dspinor.spinor[2];
	- spinor[3] = dspinor.spinor[3];
	+ m_spinor[0] = dspinor.m_spinor[0];
	+ m_spinor[1] = dspinor.m_spinor[1];
	+ m_spinor[2] = dspinor.m_spinor[2];
	+ m_spinor[3] = dspinor.m_spinor[3];
	}

	EvtDiracSpinor& EvtDiracSpinor::operator=( const EvtDiracSpinor& dspinor )
	{
	- spinor[0] = dspinor.spinor[0];
	- spinor[1] = dspinor.spinor[1];
	- spinor[2] = dspinor.spinor[2];
	- spinor[3] = dspinor.spinor[3];
	+ m_spinor[0] = dspinor.m_spinor[0];
	+ m_spinor[1] = dspinor.m_spinor[1];
	+ m_spinor[2] = dspinor.m_spinor[2];
	+ m_spinor[3] = dspinor.m_spinor[3];

	return *this;
	}

	inline EvtDiracSpinor& EvtDiracSpinor::operator+=( const EvtDiracSpinor& u2 )
	{
	- spinor[0] += u2.spinor[0];
	- spinor[1] += u2.spinor[1];
	- spinor[2] += u2.spinor[2];
	- spinor[3] += u2.spinor[3];
	+ m_spinor[0] += u2.m_spinor[0];
	+ m_spinor[1] += u2.m_spinor[1];
	+ m_spinor[2] += u2.m_spinor[2];
	+ m_spinor[3] += u2.m_spinor[3];

	return *this;
	}
	@@ -128,10 +128,10 @@

	inline EvtDiracSpinor& EvtDiracSpinor::operator-=( const EvtDiracSpinor& u2 )
	{
	- spinor[0] -= u2.spinor[0];
	- spinor[1] -= u2.spinor[1];
	- spinor[2] -= u2.spinor[2];
	- spinor[3] -= u2.spinor[3];
	+ m_spinor[0] -= u2.m_spinor[0];
	+ m_spinor[1] -= u2.m_spinor[1];
	+ m_spinor[2] -= u2.m_spinor[2];
	+ m_spinor[3] -= u2.m_spinor[3];

	return *this;
	}
	diff --git a/EvtGenBase/EvtEvalHelAmp.hh b/EvtGenBase/EvtEvalHelAmp.hh
	--- a/EvtGenBase/EvtEvalHelAmp.hh
	+++ b/EvtGenBase/EvtEvalHelAmp.hh
	@@ -44,22 +44,22 @@
	void applyRotationMatrices();

	//spins states available for particle A, B, and C.
	- int _nA, _nB, _nC;
	+ int m_nA, m_nB, m_nC;

	//helicity amplitudes
	- EvtComplexPtrPtr _HBC;
	+ EvtComplexPtrPtr m_HBC;

	//2 times spin for each of the particles
	- int _JA2, _JB2, _JC2;
	+ int m_JA2, m_JB2, m_JC2;

	//2 times the helicity for the states
	- int _lambdaA2, _lambdaB2, *_lambdaC2;
	+ int m_lambdaA2, m_lambdaB2, *m_lambdaC2;

	//Rotation matrices
	- EvtComplexPtrPtr _RA, _RB, _RC;
	+ EvtComplexPtrPtr m_RA, m_RB, m_RC;

	//temporary array for amplitudes
	- EvtComplexPtrPtrPtr _amp, _amp1, _amp3;
	+ EvtComplexPtrPtrPtr m_amp, m_amp1, m_amp3;
	};

	#endif
	diff --git a/EvtGenBase/EvtExtGeneratorCommandsTable.hh b/EvtGenBase/EvtExtGeneratorCommandsTable.hh
	--- a/EvtGenBase/EvtExtGeneratorCommandsTable.hh
	+++ b/EvtGenBase/EvtExtGeneratorCommandsTable.hh
	@@ -35,11 +35,11 @@

	void addCommand( std::string extGenerator, Command command )
	{
	- _commandMap[extGenerator].push_back( command );
	+ m_commandMap[extGenerator].push_back( command );
	}
	const GeneratorCommands& getCommands( std::string extGenerator )
	{
	- return _commandMap[extGenerator];
	+ return m_commandMap[extGenerator];
	}

	protected:
	@@ -47,7 +47,7 @@
	~EvtExtGeneratorCommandsTable();

	private:
	- GlobalCommandMap _commandMap;
	+ GlobalCommandMap m_commandMap;

	EvtExtGeneratorCommandsTable( const EvtExtGeneratorCommandsTable& ){};
	};
	diff --git a/EvtGenBase/EvtFlatte.hh b/EvtGenBase/EvtFlatte.hh
	--- a/EvtGenBase/EvtFlatte.hh
	+++ b/EvtGenBase/EvtFlatte.hh
	@@ -33,16 +33,16 @@
	class EvtFlatteParam {
	public:
	EvtFlatteParam( double m1, double m2, double g ) :
	- _m1( m1 ), _m2( m2 ), _g( g )
	+ m_m1( m1 ), m_m2( m2 ), m_g( g )
	{
	}

	- inline double m1() const { return _m1; }
	- inline double m2() const { return _m2; }
	- inline double g() const { return _g; }
	+ inline double m1() const { return m_m1; }
	+ inline double m2() const { return m_m2; }
	+ inline double g() const { return m_g; }

	private:
	- double _m1, _m2, _g;
	+ double m_m1, m_m2, m_g;
	};

	//class declaration
	@@ -55,25 +55,22 @@
	//constructor with all information about the resonance
	EvtFlatte( const EvtVector4R& p4_p, const EvtVector4R& p4_d1,
	const EvtVector4R& p4_d2, double ampl, double theta, double mass,
	- vector<EvtFlatteParam>& params
	- // double m1a = 0.0, double m1b = 0.0, double g1 = 0.0,
	- // double m2a = 0.0, double m2b = 0.0, double g2 = 0.0
	- );
	+ vector<EvtFlatteParam>& params );

	//accessors
	//return 4-momenta of the particles involved
	- inline const EvtVector4R& p4_p() { return _p4_p; }
	- inline const EvtVector4R& p4_d1() { return _p4_d1; }
	- inline const EvtVector4R& p4_d2() { return _p4_d2; }
	+ inline const EvtVector4R& p4_p() { return m_p4_p; }
	+ inline const EvtVector4R& p4_d1() { return m_p4_d1; }
	+ inline const EvtVector4R& p4_d2() { return m_p4_d2; }

	//return amplitude
	- inline double amplitude() { return _ampl; }
	+ inline double amplitude() { return m_ampl; }

	//return theta
	- inline double theta() { return _theta; }
	+ inline double theta() { return m_theta; }

	//return bwm
	- inline double mass() { return _mass; }
	+ inline double mass() { return m_mass; }

	//functions

	@@ -87,11 +84,9 @@
	: EvtComplex( 0, sqrt( -in ) );
	}

	- EvtVector4R _p4_p, _p4_d1, _p4_d2;
	- double _ampl, _theta, _mass;
	- vector<EvtFlatteParam> _params;
	- // double _m1a, _m1b, _g1;
	- // double _m2a, _m2b, _g2;
	+ EvtVector4R m_p4_p, m_p4_d1, m_p4_d2;
	+ double m_ampl, m_theta, m_mass;
	+ vector<EvtFlatteParam> m_params;
	};

	#endif
	diff --git a/EvtGenBase/EvtGammaMatrix.hh b/EvtGenBase/EvtGammaMatrix.hh
	--- a/EvtGenBase/EvtGammaMatrix.hh
	+++ b/EvtGenBase/EvtGammaMatrix.hh
	@@ -84,7 +84,7 @@
	EvtGammaMatrix& operator*=( const EvtGammaMatrix& g );

	private:
	- EvtComplex _gamma[4][4];
	+ EvtComplex m_gamma[4][4];
	};

	inline EvtGammaMatrix operator+( const EvtGammaMatrix& g1,
	diff --git a/EvtGenBase/EvtHepMCEvent.hh b/EvtGenBase/EvtHepMCEvent.hh
	--- a/EvtGenBase/EvtHepMCEvent.hh
	+++ b/EvtGenBase/EvtHepMCEvent.hh
	@@ -95,7 +95,7 @@
	void constructEvent( EvtParticle* baseParticle );
	void constructEvent( EvtParticle* baseParticle, EvtVector4R& translation );

	- GenEvent* getEvent() { return _theEvent; }
	+ GenEvent* getEvent() { return m_theEvent; }

	// Methods used to create GenParticles and FourVectors of vertices.
	// Make these public so that other classes may call them if they use EvtHepMCEvent.
	@@ -117,8 +117,8 @@
	// their descendents.
	void addVertex( EvtParticle* inEvtParticle, GenParticlePtr inGenParticle );

	- GenEvent* _theEvent;
	- EvtVector4R _translation;
	+ GenEvent* m_theEvent;
	+ EvtVector4R m_translation;
	};

	#endif
	diff --git a/EvtGenBase/EvtId.hh b/EvtGenBase/EvtId.hh
	--- a/EvtGenBase/EvtId.hh
	+++ b/EvtGenBase/EvtId.hh
	@@ -27,34 +27,34 @@
	class EvtId {
	public:
	//need a default constructor
	- EvtId() : _id( -1 ), _alias( -1 ) {}
	+ EvtId() : m_id( -1 ), m_alias( -1 ) {}

	- EvtId( int id, int alias ) : _id( id ), _alias( alias ) {}
	+ EvtId( int id, int alias ) : m_id( id ), m_alias( alias ) {}

	friend std::ostream& operator<<( std::ostream& s, const EvtId& v );

	- int operator==( const EvtId& id ) const { return _id == id._id; }
	- int operator!=( const EvtId& id ) const { return _id != id._id; }
	- int operator<( const EvtId& id ) const { return _id < id._id; }
	+ int operator==( const EvtId& id ) const { return m_id == id.m_id; }
	+ int operator!=( const EvtId& id ) const { return m_id != id.m_id; }
	+ int operator<( const EvtId& id ) const { return m_id < id.m_id; }

	int isConjugate( const EvtId& id ) const;

	- int getId() const { return _id; }
	+ int getId() const { return m_id; }

	- int getAlias() const { return _alias; }
	+ int getAlias() const { return m_alias; }

	- int isAlias() const { return _id != _alias; }
	+ int isAlias() const { return m_id != m_alias; }

	std::string getName() const;

	private:
	//particle number 0..n. The order of particles are determined
	//by the order in pdt.table
	- int _id;
	+ int m_id;
	//if the particle is an alias to another particle alias!=id
	//The only place where the alias should be used is for looking
	//up decays in the decay table.
	- int _alias;
	+ int m_alias;
	};

	#endif
	diff --git a/EvtGenBase/EvtIncoherentMixing.hh b/EvtGenBase/EvtIncoherentMixing.hh
	--- a/EvtGenBase/EvtIncoherentMixing.hh
	+++ b/EvtGenBase/EvtIncoherentMixing.hh
	@@ -83,12 +83,12 @@

	protected:
	private:
	- static bool _doB0Mixing;
	- static bool _doBsMixing;
	- static double _dGammad;
	- static double _deltamd;
	- static double _dGammas;
	- static double _deltams;
	- static bool _enableFlip;
	+ static bool m_doB0Mixing;
	+ static bool m_doBsMixing;
	+ static double m_dGammad;
	+ static double m_deltamd;
	+ static double m_dGammas;
	+ static double m_deltams;
	+ static bool m_enableFlip;
	};
	#endif // EVTGENBASE_EVTINCOHERENTMIXING_HH
	diff --git a/EvtGenBase/EvtIntervalFlatPdf.hh b/EvtGenBase/EvtIntervalFlatPdf.hh
	--- a/EvtGenBase/EvtIntervalFlatPdf.hh
	+++ b/EvtGenBase/EvtIntervalFlatPdf.hh
	@@ -43,8 +43,8 @@
	protected:
	double pdf( const EvtPoint1D& ) const override;

	- double _min;
	- double _max;
	+ double m_min;
	+ double m_max;
	};

	#endif
	diff --git a/EvtGenBase/EvtLASSAmp.hh b/EvtGenBase/EvtLASSAmp.hh
	--- a/EvtGenBase/EvtLASSAmp.hh
	+++ b/EvtGenBase/EvtLASSAmp.hh
	@@ -43,17 +43,17 @@
	}

	private:
	- EvtDalitzPlot* _dalitzSpace;
	+ EvtDalitzPlot* m_dalitzSpace;

	- EvtCyclic3::Pair _pair;
	+ EvtCyclic3::Pair m_pair;

	- double _m0;
	- double _g0;
	- double _q0;
	- double _r;
	- double _a;
	- double _cutoff;
	- std::string _subtype;
	+ double m_m0;
	+ double m_g0;
	+ double m_q0;
	+ double m_r;
	+ double m_a;
	+ double m_cutoff;
	+ std::string m_subtype;
	};

	#endif
	diff --git a/EvtGenBase/EvtMTRandomEngine.hh b/EvtGenBase/EvtMTRandomEngine.hh
	--- a/EvtGenBase/EvtMTRandomEngine.hh
	+++ b/EvtGenBase/EvtMTRandomEngine.hh
	@@ -32,10 +32,10 @@
	virtual double random();

	private:
	- std::mt19937 engine_;
	+ std::mt19937 m_engine;

	typedef std::uniform_real_distribution<double> URDist;
	- URDist distribution_;
	+ URDist m_distribution;
	};

	#endif
	diff --git a/EvtGenBase/EvtMassAmp.hh b/EvtGenBase/EvtMassAmp.hh
	--- a/EvtGenBase/EvtMassAmp.hh
	+++ b/EvtGenBase/EvtMassAmp.hh
	@@ -26,6 +26,7 @@
	#include "EvtGenBase/EvtPropBreitWignerRel.hh"
	#include "EvtGenBase/EvtTwoBodyVertex.hh"

	+#include <memory>
	// Relativistic lineshape for a two-body decay of a resonance to two
	// pseudoscalars. The mass dependence of the width and the vertex factors
	// are included in the calculation.
	@@ -45,23 +46,23 @@

	void setBirthVtx( const EvtTwoBodyVertex& vb )
	{
	- _vb = std::make_unique<EvtTwoBodyVertex>( vb );
	+ m_vb = std::make_unique<EvtTwoBodyVertex>( vb );
	}

	- void addBirthFact() { _useBirthFact = true; }
	- void addDeathFact() { _useDeathFact = true; }
	- void addBirthFactFF() { _useBirthFactFF = true; }
	- void addDeathFactFF() { _useDeathFactFF = true; }
	+ void addBirthFact() { m_useBirthFact = true; }
	+ void addDeathFact() { m_useDeathFact = true; }
	+ void addBirthFactFF() { m_useBirthFactFF = true; }
	+ void addDeathFactFF() { m_useDeathFactFF = true; }

	private:
	- EvtPropBreitWignerRel _prop;
	- EvtTwoBodyVertex _vd;
	- std::unique_ptr<EvtTwoBodyVertex> _vb;
	+ EvtPropBreitWignerRel m_prop;
	+ EvtTwoBodyVertex m_vd;
	+ std::unique_ptr<EvtTwoBodyVertex> m_vb;

	- bool _useBirthFact;
	- bool _useDeathFact;
	- bool _useBirthFactFF;
	- bool _useDeathFactFF;
	+ bool m_useBirthFact;
	+ bool m_useDeathFact;
	+ bool m_useBirthFactFF;
	+ bool m_useDeathFactFF;
	};

	#endif
	diff --git a/EvtGenBase/EvtMatrix.hh b/EvtGenBase/EvtMatrix.hh
	--- a/EvtGenBase/EvtMatrix.hh
	+++ b/EvtGenBase/EvtMatrix.hh
	@@ -28,16 +28,16 @@
	template <class T>
	class EvtMatrix {
	private:
	- T** _mat;
	- int _range;
	+ T** m_mat;
	+ int m_range;

	public:
	- EvtMatrix() : _range( 0 ){};
	+ EvtMatrix() : m_range( 0 ){};
	~EvtMatrix();
	inline void setRange( int range );

	- T& operator()( int row, int col ) { return _mat[row][col]; }
	- T* operator[]( int row ) { return _mat[row]; }
	+ T& operator()( int row, int col ) { return m_mat[row][col]; }
	+ T* operator[]( int row ) { return m_mat[row]; }
	T det();
	EvtMatrix* min( int row, int col );
	EvtMatrix* inverse();
	@@ -53,33 +53,33 @@
	{
	// If the range is changed, delete any previous matrix stored
	// and allocate elements with the newly specified range.
	- if ( _range != range ) {
	- if ( _range ) {
	- for ( int row = 0; row < _range; row++ )
	- delete[] _mat[row];
	- delete[] _mat;
	+ if ( m_range != range ) {
	+ if ( m_range ) {
	+ for ( int row = 0; row < m_range; row++ )
	+ delete[] m_mat[row];
	+ delete[] m_mat;
	}

	- _mat = new T*[range];
	+ m_mat = new T*[range];
	for ( int row = 0; row < range; row++ )
	- _mat[row] = new T[range];
	+ m_mat[row] = new T[range];

	// Set the new range.
	- _range = range;
	+ m_range = range;
	}

	// Since user is willing to change the range, reset the matrix elements.
	- for ( int row = 0; row < _range; row++ )
	- for ( int col = 0; col < _range; col++ )
	- _mat[row][col] = 0.;
	+ for ( int row = 0; row < m_range; row++ )
	+ for ( int col = 0; col < m_range; col++ )
	+ m_mat[row][col] = 0.;
	}

	template <class T>
	EvtMatrix<T>::~EvtMatrix()
	{
	- for ( int row = 0; row < _range; row++ )
	- delete[] _mat[row];
	- delete[] _mat;
	+ for ( int row = 0; row < m_range; row++ )
	+ delete[] m_mat[row];
	+ delete[] m_mat;
	}

	template <class T>
	@@ -87,10 +87,10 @@
	{
	std::ostringstream str;

	- for ( int row = 0; row < _range; row++ ) {
	+ for ( int row = 0; row < m_range; row++ ) {
	str << "\|";
	- for ( int col = 0; col < _range; col++ )
	- str << "\t" << _mat[row][col];
	+ for ( int col = 0; col < m_range; col++ )
	+ str << "\t" << m_mat[row][col];
	str << "\t\|" << std::endl;
	}

	@@ -100,19 +100,19 @@
	template <class T>
	T EvtMatrix<T>::det()
	{
	- if ( _range == 1 )
	- return _mat[0][0];
	+ if ( m_range == 1 )
	+ return m_mat[0][0];

	// There's no need to define the range 2 determinant manually, but it may
	// speed up the calculation.
	- if ( _range == 2 )
	- return _mat[0][0] * _mat[1][1] - _mat[0][1] * _mat[1][0];
	+ if ( m_range == 2 )
	+ return m_mat[0][0] * m_mat[1][1] - m_mat[0][1] * m_mat[1][0];

	T sum = 0.;

	- for ( int col = 0; col < _range; col++ ) {
	+ for ( int col = 0; col < m_range; col++ ) {
	EvtMatrix<T>* minor = min( 0, col );
	- sum += std::pow( -1., col ) * _mat[0][col] * minor->det();
	+ sum += std::pow( -1., col ) * m_mat[0][col] * minor->det();
	delete minor;
	}

	@@ -124,15 +124,15 @@
	EvtMatrix<T>* EvtMatrix<T>::min( int row, int col )
	{
	EvtMatrix<T>* minor = new EvtMatrix<T>();
	- minor->setRange( _range - 1 );
	+ minor->setRange( m_range - 1 );

	int minIndex = 0;

	- for ( int r = 0; r < _range; r++ )
	- for ( int c = 0; c < _range; c++ )
	+ for ( int r = 0; r < m_range; r++ )
	+ for ( int c = 0; c < m_range; c++ )
	if ( ( r != row ) && ( c != col ) ) {
	- ( *minor )( minIndex / ( _range - 1 ),
	- minIndex % ( _range - 1 ) ) = _mat[r][c];
	+ ( *minor )( minIndex / ( m_range - 1 ),
	+ minIndex % ( m_range - 1 ) ) = m_mat[r][c];
	minIndex++;
	}

	@@ -143,24 +143,24 @@
	EvtMatrix<T>* EvtMatrix<T>::inverse()
	{
	EvtMatrix<T>* inv = new EvtMatrix<T>();
	- inv->setRange( _range );
	+ inv->setRange( m_range );

	if ( det() == 0 ) {
	std::cerr << "This matrix has a null determinant and cannot be inverted. Returning zero matrix."
	<< std::endl;
	- for ( int row = 0; row < _range; row++ )
	- for ( int col = 0; col < _range; col++ )
	+ for ( int row = 0; row < m_range; row++ )
	+ for ( int col = 0; col < m_range; col++ )
	( *inv )( row, col ) = 0.;
	return inv;
	}

	T determinant = det();

	- for ( int row = 0; row < _range; row++ )
	- for ( int col = 0; col < _range; col++ ) {
	+ for ( int row = 0; row < m_range; row++ )
	+ for ( int col = 0; col < m_range; col++ ) {
	EvtMatrix<T>* minor = min( row, col );
	- inv->_mat[col][row] = std::pow( -1., row + col ) * minor->det() /
	- determinant;
	+ inv->m_mat[col][row] = std::pow( -1., row + col ) * minor->det() /
	+ determinant;
	delete minor;
	}

	@@ -171,24 +171,24 @@
	EvtMatrix<T>* operator*( const EvtMatrix<T>& left, const EvtMatrix<T>& right )
	{
	// Chech that the matrices have the correct range.
	- if ( left._range != right._range ) {
	+ if ( left.m_range != right.m_range ) {
	std::cerr << "These matrices cannot be multiplied." << std::endl;
	return new EvtMatrix<T>();
	}

	EvtMatrix<T>* mat = new EvtMatrix<T>();
	- mat->setRange( left._range );
	+ mat->setRange( left.m_range );

	// Initialize the elements of the matrix.
	- for ( int row = 0; row < left._range; row++ )
	- for ( int col = 0; col < right._range; col++ )
	+ for ( int row = 0; row < left.m_range; row++ )
	+ for ( int col = 0; col < right.m_range; col++ )
	( *mat )[row][col] = 0;

	- for ( int row = 0; row < left._range; row++ )
	- for ( int col = 0; col < right._range; col++ )
	- for ( int line = 0; line < right._range; line++ )
	- ( mat )[row][col] += left._mat[row][line]
	- right._mat[line][col];
	+ for ( int row = 0; row < left.m_range; row++ )
	+ for ( int col = 0; col < right.m_range; col++ )
	+ for ( int line = 0; line < right.m_range; line++ )
	+ ( mat )[row][col] += left.m_mat[row][line]
	+ right.m_mat[line][col];

	return mat;
	}
	diff --git a/EvtGenBase/EvtModel.hh b/EvtGenBase/EvtModel.hh
	--- a/EvtGenBase/EvtModel.hh
	+++ b/EvtGenBase/EvtModel.hh
	@@ -47,17 +47,17 @@
	private:
	EvtModel();

	- static EvtModel* _instance;
	+ static EvtModel* m_instance;

	- std::map<std::string, EvtDecayBase*> _modelNameHash;
	- std::map<std::string, EvtDecayBase*> _commandNameHash;
	+ std::map<std::string, EvtDecayBase*> m_modelNameHash;
	+ std::map<std::string, EvtDecayBase*> m_commandNameHash;
	};

	inline EvtModel& EvtModel::instance()
	{
	- if ( _instance == nullptr )
	- _instance = new EvtModel;
	- return *_instance;
	+ if ( m_instance == nullptr )
	+ m_instance = new EvtModel;
	+ return *m_instance;
	}

	#endif
	diff --git a/EvtGenBase/EvtModelAlias.hh b/EvtGenBase/EvtModelAlias.hh
	--- a/EvtGenBase/EvtModelAlias.hh
	+++ b/EvtGenBase/EvtModelAlias.hh
	@@ -34,16 +34,16 @@
	EvtModelAlias operator=( const EvtModelAlias& copyMe );
	bool matchAlias( const std::string& cand )
	{
	- if ( cand == _aliasName )
	+ if ( cand == m_aliasName )
	return true;
	return false;
	}
	- std::string getName() { return _model; }
	+ std::string getName() { return m_model; }
	std::vector<std::string> getArgList();

	private:
	- std::string _aliasName;
	- std::string _model;
	- std::vector<std::string> _modelArgs;
	+ std::string m_aliasName;
	+ std::string m_model;
	+ std::vector<std::string> m_modelArgs;
	};
	#endif
	diff --git a/EvtGenBase/EvtMultiChannelParser.hh b/EvtGenBase/EvtMultiChannelParser.hh
	--- a/EvtGenBase/EvtMultiChannelParser.hh
	+++ b/EvtGenBase/EvtMultiChannelParser.hh
	@@ -39,7 +39,7 @@

	class EvtMultiChannelParser {
	public:
	- EvtMultiChannelParser() : _pdfMax( -1. ), _nScan( 0 ), _dm( 0. ) {}
	+ EvtMultiChannelParser() : m_pdfMax( -1. ), m_nScan( 0 ), m_dm( 0. ) {}
	~EvtMultiChannelParser() {}

	static EvtDecayMode getDecayMode( const char* file );
	@@ -52,39 +52,39 @@
	static double parseRealCoef( int& i, const std::vector<std::string>& v );
	static bool isKeyword( const std::string& s );

	- inline double pdfMax() const { return _pdfMax; }
	- inline int nScan() const { return _nScan; }
	- inline double dm() const { return _dm; }
	- inline double mixPhase() const { return _mixPhase; }
	- inline double mixAmpli() const { return _mixAmpli; }
	+ inline double pdfMax() const { return m_pdfMax; }
	+ inline int nScan() const { return m_nScan; }
	+ inline double dm() const { return m_dm; }
	+ inline double mixPhase() const { return m_mixPhase; }
	+ inline double mixAmpli() const { return m_mixAmpli; }

	- inline std::vector<std::string> amp( int i ) const { return _amp[i]; }
	+ inline std::vector<std::string> amp( int i ) const { return m_amp[i]; }
	inline std::vector<std::string> ampConj( int i ) const
	{
	- return _ampConj[i];
	+ return m_ampConj[i];
	}
	- inline EvtComplex ampCoef( int i ) const { return _ampCoef[i]; }
	- inline EvtComplex ampConjCoef( int i ) const { return _ampConjCoef[i]; }
	+ inline EvtComplex ampCoef( int i ) const { return m_ampCoef[i]; }
	+ inline EvtComplex ampConjCoef( int i ) const { return m_ampConjCoef[i]; }

	- inline int coefFormat( int i ) const { return _coefFormat[i]; }
	- inline int coefConjFormat( int i ) const { return _coefConjFormat[i]; }
	+ inline int coefFormat( int i ) const { return m_coefFormat[i]; }
	+ inline int coefConjFormat( int i ) const { return m_coefConjFormat[i]; }

	- inline int getNAmp() const { return _amp.size(); }
	- inline int getNAmpConj() const { return _ampConj.size(); }
	+ inline int getNAmp() const { return m_amp.size(); }
	+ inline int getNAmpConj() const { return m_ampConj.size(); }

	private:
	- double _pdfMax;
	- int _nScan;
	- double _dm;
	- double _mixPhase;
	- double _mixAmpli;
	-
	- std::vector<std::vector<std::string>> _amp;
	- std::vector<std::vector<std::string>> _ampConj;
	- std::vector<EvtComplex> _ampCoef;
	- std::vector<int> _coefFormat;
	- std::vector<EvtComplex> _ampConjCoef;
	- std::vector<int> _coefConjFormat;
	+ double m_pdfMax;
	+ int m_nScan;
	+ double m_dm;
	+ double m_mixPhase;
	+ double m_mixAmpli;
	+
	+ std::vector<std::vector<std::string>> m_amp;
	+ std::vector<std::vector<std::string>> m_ampConj;
	+ std::vector<EvtComplex> m_ampCoef;
	+ std::vector<int> m_coefFormat;
	+ std::vector<EvtComplex> m_ampConjCoef;
	+ std::vector<int> m_coefConjFormat;
	};

	#endif
	diff --git a/EvtGenBase/EvtNeutrinoParticle.hh b/EvtGenBase/EvtNeutrinoParticle.hh
	--- a/EvtGenBase/EvtNeutrinoParticle.hh
	+++ b/EvtGenBase/EvtNeutrinoParticle.hh
	@@ -37,8 +37,8 @@
	double gamma ) const override;

	private:
	- EvtDiracSpinor spinor_rest;
	- EvtDiracSpinor spinor_parent;
	+ EvtDiracSpinor m_spinor_rest;
	+ EvtDiracSpinor m_spinor_parent;

	EvtNeutrinoParticle( const EvtNeutrinoParticle& n );
	EvtNeutrinoParticle& operator=( const EvtNeutrinoParticle& n );
	diff --git a/EvtGenBase/EvtNonresonantAmp.hh b/EvtGenBase/EvtNonresonantAmp.hh
	--- a/EvtGenBase/EvtNonresonantAmp.hh
	+++ b/EvtGenBase/EvtNonresonantAmp.hh
	@@ -45,15 +45,15 @@
	}

	private:
	- EvtDalitzPlot* _dalitzSpace;
	+ EvtDalitzPlot* m_dalitzSpace;

	- EvtPto3PAmp::NumType _type;
	+ EvtPto3PAmp::NumType m_type;

	- EvtCyclic3::Pair _pair1, _pair2;
	+ EvtCyclic3::Pair m_pair1, m_pair2;

	- double _par1, _par2;
	+ double m_par1, m_par2;

	- EvtSpinType::spintype _spin;
	+ EvtSpinType::spintype m_spin;
	};

	#endif
	diff --git a/EvtGenBase/EvtOrthogVector.hh b/EvtGenBase/EvtOrthogVector.hh
	--- a/EvtGenBase/EvtOrthogVector.hh
	+++ b/EvtGenBase/EvtOrthogVector.hh
	@@ -27,15 +27,15 @@
	public:
	EvtOrthogVector( int n, std::vector<double>* vectors );

	- std::vector<double> getOrthogVector() { return _orthogVector; }
	+ std::vector<double> getOrthogVector() { return m_orthogVector; }

	private:
	- int _dimen;
	- std::vector<int> _holder;
	+ int m_dimen;
	+ std::vector<int> m_holder;
	void findOrthog( int dim, std::vector<int> invect,
	std::vector<double>* vectors );

	- std::vector<double> _orthogVector;
	+ std::vector<double> m_orthogVector;

	int findEvenOddSwaps();
	};
	diff --git a/EvtGenBase/EvtPDL.hh b/EvtGenBase/EvtPDL.hh
	--- a/EvtGenBase/EvtPDL.hh
	+++ b/EvtGenBase/EvtPDL.hh
	@@ -26,7 +26,7 @@
	#include "EvtGenBase/EvtSpinType.hh"
	#include "EvtGenBase/EvtStringHash.hh"

	-#include <iostream>
	+#include <iosfwd>
	#include <map>
	#include <string>
	#include <vector>
	@@ -84,8 +84,8 @@
	private:
	void setUpConstsPdt();

	- static unsigned int _firstAlias;
	- static int _nentries;
	+ static unsigned int m_firstAlias;
	+ static int m_nentries;

	static std::vector<EvtPartProp>& partlist()
	{
	@@ -93,7 +93,7 @@
	return s_partlist;
	}

	- static std::map<std::string, int> _particleNameLookup;
	+ static std::map<std::string, int> m_particleNameLookup;

	}; // EvtPDL.h

	diff --git a/EvtGenBase/EvtParser.hh b/EvtGenBase/EvtParser.hh
	--- a/EvtGenBase/EvtParser.hh
	+++ b/EvtGenBase/EvtParser.hh
	@@ -34,10 +34,10 @@
	int getLineofToken( int i );

	private:
	- int _ntoken;
	- std::string* _tokenlist;
	- int* _linelist;
	- int _lengthoftokenlist;
	+ int m_ntoken;
	+ std::string* m_tokenlist;
	+ int* m_linelist;
	+ int m_lengthoftokenlist;

	void addToken( int line, const std::string& string );
	};
	diff --git a/EvtGenBase/EvtParserXml.hh b/EvtGenBase/EvtParserXml.hh
	--- a/EvtGenBase/EvtParserXml.hh
	+++ b/EvtGenBase/EvtParserXml.hh
	@@ -32,10 +32,10 @@

	bool readNextTag();

	- std::string getTagTitle() { return _tagTitle; }
	+ std::string getTagTitle() { return m_tagTitle; }
	std::string getParentTagTitle();
	- int getLineNumber() { return _lineNo; }
	- bool isTagInline() { return _inLineTag; }
	+ int getLineNumber() { return m_lineNo; }
	+ bool isTagInline() { return m_inLineTag; }

	std::string readAttribute( std::string attribute,
	std::string defaultValue = "" );
	@@ -44,14 +44,14 @@
	double readAttributeDouble( std::string attribute, double defaultValue = -1. );

	private:
	- std::ifstream _fin;
	- std::string _line;
	- int _lineNo = 0;
	-
	- std::string _tag;
	- std::string _tagTitle;
	- bool _inLineTag;
	- std::vector<std::string> _tagTree;
	+ std::ifstream m_fin;
	+ std::string m_line;
	+ int m_lineNo = 0;
	+
	+ std::string m_tag;
	+ std::string m_tagTitle;
	+ bool m_inLineTag;
	+ std::vector<std::string> m_tagTree;

	bool processTagTree();

	diff --git a/EvtGenBase/EvtPartProp.hh b/EvtGenBase/EvtPartProp.hh
	--- a/EvtGenBase/EvtPartProp.hh
	+++ b/EvtGenBase/EvtPartProp.hh
	@@ -33,54 +33,54 @@
	EvtPartProp();
	EvtPartProp( const EvtPartProp& x );

	- double getMass() { return _lineShape->getMass(); }
	- double getMassMin() { return _lineShape->getMassMin(); }
	- double getMassMax() { return _lineShape->getMassMax(); }
	- double getMaxRange() { return _lineShape->getMaxRange(); }
	- double getWidth() { return _lineShape->getWidth(); }
	+ double getMass() { return m_lineShape->getMass(); }
	+ double getMassMin() { return m_lineShape->getMassMin(); }
	+ double getMassMax() { return m_lineShape->getMassMax(); }
	+ double getMaxRange() { return m_lineShape->getMaxRange(); }
	+ double getWidth() { return m_lineShape->getWidth(); }

	double getRandMass( EvtId* parId, int nDaug, EvtId* dauId, EvtId* othDauId,
	double maxMass, double* dauMasses )
	{
	- return _lineShape->getRandMass( parId, nDaug, dauId, othDauId, maxMass,
	- dauMasses );
	+ return m_lineShape->getRandMass( parId, nDaug, dauId, othDauId, maxMass,
	+ dauMasses );
	}
	double getMassProb( double mass, double massPar, int nDaug, double* massDau )
	{
	- return _lineShape->getMassProb( mass, massPar, nDaug, massDau );
	+ return m_lineShape->getMassProb( mass, massPar, nDaug, massDau );
	}

	- double getctau() { return _ctau; }
	- void setctau( double tau ) { _ctau = tau; }
	+ double getctau() { return m_ctau; }
	+ void setctau( double tau ) { m_ctau = tau; }

	- int getChg3() { return _chg3; }
	- void setChg3( int c3 ) { _chg3 = c3; }
	+ int getChg3() { return m_chg3; }
	+ void setChg3( int c3 ) { m_chg3 = c3; }

	- EvtSpinType::spintype getSpinType() { return _spintype; }
	- void setSpinType( EvtSpinType::spintype stype ) { _spintype = stype; }
	+ EvtSpinType::spintype getSpinType() { return m_spintype; }
	+ void setSpinType( EvtSpinType::spintype stype ) { m_spintype = stype; }

	- const std::string& getName() { return _name; }
	+ const std::string& getName() { return m_name; }
	void setName( std::string pname );

	- EvtId getId() { return _id; }
	- void setId( EvtId id ) { _id = id; }
	+ EvtId getId() { return m_id; }
	+ void setId( EvtId id ) { m_id = id; }

	- EvtId getIdChgConj() { return _idchgconj; }
	- void setIdChgConj( EvtId idchgconj ) { _idchgconj = idchgconj; }
	+ EvtId getIdChgConj() { return m_idchgconj; }
	+ void setIdChgConj( EvtId idchgconj ) { m_idchgconj = idchgconj; }

	- int getStdHep() { return _stdhep; }
	- void setStdHep( int stdhep ) { _stdhep = stdhep; }
	+ int getStdHep() { return m_stdhep; }
	+ void setStdHep( int stdhep ) { m_stdhep = stdhep; }

	- int getLundKC() { return _lundkc; }
	- void setLundKC( int lundkc ) { _lundkc = lundkc; }
	+ int getLundKC() { return m_lundkc; }
	+ void setLundKC( int lundkc ) { m_lundkc = lundkc; }

	- EvtAbsLineShape* getLineShape() { return _lineShape.get(); }
	+ EvtAbsLineShape* getLineShape() { return m_lineShape.get(); }
	void initLineShape( double mass, double width, double maxRange );
	// void initLineShape(double mass, double width, double maxRange, double mDaug1, double mDaug2, int l);

	// setLineShape takes ownership of l
	- void setLineShape( EvtAbsLineShape* l ) { _lineShape.reset( l ); }
	- double rollMass() { return _lineShape->rollMass(); }
	+ void setLineShape( EvtAbsLineShape* l ) { m_lineShape.reset( l ); }
	+ double rollMass() { return m_lineShape->rollMass(); }

	EvtPartProp& operator=( const EvtPartProp& x );

	@@ -98,16 +98,16 @@
	void setPWForBirthL( int spin, EvtId par, EvtId othD );

	private:
	- std::unique_ptr<EvtAbsLineShape> _lineShape;
	-
	- double _ctau;
	- EvtId _id;
	- EvtId _idchgconj;
	- EvtSpinType::spintype _spintype;
	- int _chg3;
	- int _stdhep;
	- int _lundkc;
	- std::string _name;
	+ std::unique_ptr<EvtAbsLineShape> m_lineShape;
	+
	+ double m_ctau;
	+ EvtId m_id;
	+ EvtId m_idchgconj;
	+ EvtSpinType::spintype m_spintype;
	+ int m_chg3;
	+ int m_stdhep;
	+ int m_lundkc;
	+ std::string m_name;
	};

	#endif
	diff --git a/EvtGenBase/EvtParticle.hh b/EvtGenBase/EvtParticle.hh
	--- a/EvtGenBase/EvtParticle.hh
	+++ b/EvtGenBase/EvtParticle.hh
	@@ -148,21 +148,21 @@
	* adds them to the parent. Note that momentum
	* is left uninitialized, this is _only_ creation.
	*/
	- void makeDaughters( unsigned int ndaug, EvtId* id );
	+ void makeDaughters( size_t ndaug, EvtId* id );

	/**
	* Creates the daughters in the list of ids and
	* adds them to the parent. Note that momentum
	* is left uninitialized, this is _only_ creation.
	*/
	- void makeDaughters( unsigned int ndaug, std::vector<EvtId> idVector );
	+ void makeDaughters( size_t ndaug, std::vector<EvtId> idVector );

	/**
	* Similar to the routine above except that here
	* momentum is generated according to phase space
	* daughters are filled with this momentum.
	*/
	- double initializePhaseSpace( unsigned int numdaughter, EvtId* daughters,
	+ double initializePhaseSpace( size_t numdaughter, EvtId* daughters,
	bool forceResetMasses = false,
	double poleSize = -1., int whichTwo1 = 0,
	int whichTwo2 = 1 );
	@@ -170,12 +170,12 @@
	/**
	* Get pointer the the i:th daugther.
	*/
	- EvtParticle* getDaug( const int i ) { return _daug[i]; }
	+ EvtParticle* getDaug( const int i ) { return m_daug[i]; }

	/**
	* Get const pointer the the i:th daugther.
	*/
	- const EvtParticle* getDaug( const int i ) const { return _daug[i]; }
	+ const EvtParticle* getDaug( const int i ) const { return m_daug[i]; }

	/**
	* Iterates over the particles in a decay chain.
	@@ -223,8 +223,8 @@
	*/
	void insertDaugPtr( int idaug, EvtParticle* partptr )
	{
	- _daug[idaug] = partptr;
	- partptr->_parent = this;
	+ m_daug[idaug] = partptr;
	+ partptr->m_parent = this;
	}
	/**
	* Returns mass of particle.
	@@ -270,13 +270,13 @@
	*/
	void setP4( const EvtVector4R& p4 )
	{
	- _p = p4;
	- _pBeforeFSR = p4;
	+ m_p = p4;
	+ m_pBeforeFSR = p4;
	}

	- void setP4WithFSR( const EvtVector4R& p4 ) { _p = p4; }
	+ void setP4WithFSR( const EvtVector4R& p4 ) { m_p = p4; }

	- void setFSRP4toZero() { _pBeforeFSR.set( 0.0, 0.0, 0.0, 0.0 ); }
	+ void setFSRP4toZero() { m_pBeforeFSR.set( 0.0, 0.0, 0.0, 0.0 ); }

	/**
	* Retunrs the decay channel.
	@@ -289,7 +289,7 @@
	size_t getNDaug() const;
	void resetNDaug()
	{
	- _ndaug = 0;
	+ m_ndaug = 0;
	return;
	}

	@@ -340,7 +340,7 @@
	*/
	void setSpinDensityForward( const EvtSpinDensity& rho )
	{
	- _rhoForward = rho;
	+ m_rhoForward = rho;
	}

	/**
	@@ -365,53 +365,53 @@
	/**
	* Get forward spin density matrix.
	*/
	- EvtSpinDensity getSpinDensityForward() { return _rhoForward; }
	+ EvtSpinDensity getSpinDensityForward() { return m_rhoForward; }

	/**
	* Set backward spin density matrix.
	*/
	void setSpinDensityBackward( const EvtSpinDensity& rho )
	{
	- _rhoBackward = rho;
	+ m_rhoBackward = rho;
	}

	/**
	* Get backward spin density matrix.
	*/
	- EvtSpinDensity getSpinDensityBackward() { return _rhoBackward; }
	+ EvtSpinDensity getSpinDensityBackward() { return m_rhoBackward; }

	//Hacks will be removed when better solutions are thought of!
	//This is used to suppress use of random numbers when doing initialization
	//of some models.
	- void noLifeTime() { _genlifetime = 0; }
	+ void noLifeTime() { m_genlifetime = 0; }

	//lange - April 29, 2002
	- void setId( EvtId id ) { _id = id; }
	+ void setId( EvtId id ) { m_id = id; }
	void initDecay( bool useMinMass = false );
	bool generateMassTree();

	double compMassProb();

	//setMass will blow away any existing 4vector
	- void setMass( double m ) { _p = EvtVector4R( m, 0.0, 0.0, 0.0 ); }
	+ void setMass( double m ) { m_p = EvtVector4R( m, 0.0, 0.0, 0.0 ); }

	- //void setMixed() {_mix=true;}
	- //void setUnMixed() {_mix=false;}
	- //bool getMixed() {return _mix;}
	+ //void setMixed() {m_mix=true;}
	+ //void setUnMixed() {m_mix=false;}
	+ //bool getMixed() {return m_mix;}

	//void takeCConj() {EvtGenReport(EVTGEN_INFO,"EvtGen") << "should take conj\n";}

	//this means that the particle has gone through initDecay
	// and thus has a mass
	- bool isInitialized() { return _isInit; }
	- bool hasValidP4() { return _validP4; }
	- bool isDecayed() { return _isDecayed; }
	+ bool isInitialized() { return m_isInit; }
	+ bool hasValidP4() { return m_validP4; }
	+ bool isDecayed() { return m_isDecayed; }

	// decay prob - only relevent if already decayed
	// and is a scalar particle
	// returned is a double* that should be prob/probMax
	// FIXME - this should probably be changed to std::optional
	- const double* decayProb() const { return _decayProb; }
	+ const double* decayProb() const { return m_decayProb; }
	void setDecayProb( double p );

	// Return the name of the particle (from the EvtId number)
	@@ -422,7 +422,7 @@
	// can set this to mean something specific, e.g. if a photon is FSR
	void setAttribute( std::string attName, int attValue )
	{
	- _intAttributes[attName] = attValue;
	+ m_intAttributes[attName] = attValue;
	}

	// Retrieve the integer value for the given attribute name
	@@ -432,7 +432,7 @@
	// By default, nothing is set, but derived classes can set this to mean something specific
	void setAttributeDouble( std::string attName, double attValue )
	{
	- _dblAttributes[attName] = attValue;
	+ m_dblAttributes[attName] = attValue;
	}

	// Retrieve the double value for the given attribute name
	@@ -441,63 +441,63 @@
	protected:
	void setp( double e, double px, double py, double pz )
	{
	- _p.set( e, px, py, pz );
	- _pBeforeFSR = _p;
	+ m_p.set( e, px, py, pz );
	+ m_pBeforeFSR = m_p;
	}

	void setp( const EvtVector4R& p4 )
	{
	- _p = p4;
	- _pBeforeFSR = _p;
	+ m_p = p4;
	+ m_pBeforeFSR = m_p;
	}

	void setpart_num( EvtId particle_number )
	{
	- assert( _channel == -10 \|\| _id.getId() == particle_number.getId() \|\|
	- _id.getId() == -1 );
	- _id = particle_number;
	+ assert( m_channel == -10 \|\| m_id.getId() == particle_number.getId() \|\|
	+ m_id.getId() == -1 );
	+ m_id = particle_number;
	}
	- bool _validP4;
	+ bool m_validP4;

	// A typedef to define the attribute (name, integer) map
	typedef std::map<std::string, int> EvtAttIntMap;
	- EvtAttIntMap _intAttributes;
	+ EvtAttIntMap m_intAttributes;

	// A typedef to define the attribute (name, double) map
	typedef std::map<std::string, double> EvtAttDblMap;
	- EvtAttDblMap _dblAttributes;
	+ EvtAttDblMap m_dblAttributes;

	private:
	- EvtParticle* _daug[MAX_DAUG];
	- size_t _ndaug;
	- EvtParticle* _parent;
	- int _channel;
	- int _first;
	- EvtId _id;
	- EvtVector4R _p;
	- EvtVector4R _pBeforeFSR;
	- double _t;
	- bool _isInit;
	- bool _isDecayed;
	-
	- //bool _mix;
	-
	- EvtSpinDensity _rhoForward;
	- EvtSpinDensity _rhoBackward;
	+ EvtParticle* m_daug[MAX_DAUG];
	+ size_t m_ndaug;
	+ EvtParticle* m_parent;
	+ int m_channel;
	+ int m_first;
	+ EvtId m_id;
	+ EvtVector4R m_p;
	+ EvtVector4R m_pBeforeFSR;
	+ double m_t;
	+ bool m_isInit;
	+ bool m_isDecayed;
	+
	+ //bool m_mix;
	+
	+ EvtSpinDensity m_rhoForward;
	+ EvtSpinDensity m_rhoBackward;

	void makeStdHepRec( int firstparent, int lastparent, EvtStdHep& stdhep,
	EvtSecondary& secondary, EvtId* stable_parent_ihep );
	void makeStdHepRec( int firstparent, int lastparent, EvtStdHep& stdhep );

	//This is a hack until things gets straightened out. (Ryd)
	- int _genlifetime;
	+ int m_genlifetime;

	//should never be used, therefor is private.
	//these does _not_ have an implementation
	EvtParticle& operator=( const EvtParticle& p );
	EvtParticle( const EvtParticle& p );

	- double* _decayProb;
	+ double* m_decayProb;
	};

	#endif
	diff --git a/EvtGenBase/EvtParticleDecay.hh b/EvtGenBase/EvtParticleDecay.hh
	--- a/EvtGenBase/EvtParticleDecay.hh
	+++ b/EvtGenBase/EvtParticleDecay.hh
	@@ -27,33 +27,33 @@
	public:
	EvtParticleDecay()
	{
	- _decay = nullptr;
	- _brfrsum = 0.0;
	- _massmin = 0.0;
	+ m_decay = nullptr;
	+ m_brfrsum = 0.0;
	+ m_massmin = 0.0;
	}

	~EvtParticleDecay()
	{
	- if ( _decay != nullptr )
	- delete _decay;
	+ if ( m_decay != nullptr )
	+ delete m_decay;
	}

	void chargeConj( EvtParticleDecay* decay );

	- void setDecayModel( EvtDecayBase* decay ) { _decay = decay; }
	- EvtDecayBase* getDecayModel() { return _decay; }
	- double getBrfrSum() { return _brfrsum; }
	- void setBrfrSum( double brfrsum ) { _brfrsum = brfrsum; }
	- double getMassMin() { return _massmin; }
	- void setMassMin( double massmin ) { _massmin = massmin; }
	+ void setDecayModel( EvtDecayBase* decay ) { m_decay = decay; }
	+ EvtDecayBase* getDecayModel() { return m_decay; }
	+ double getBrfrSum() { return m_brfrsum; }
	+ void setBrfrSum( double brfrsum ) { m_brfrsum = brfrsum; }
	+ double getMassMin() { return m_massmin; }
	+ void setMassMin( double massmin ) { m_massmin = massmin; }

	void printSummary();

	private:
	- EvtDecayBase* _decay;
	+ EvtDecayBase* m_decay;

	- double _brfrsum;
	- double _massmin;
	+ double m_brfrsum;
	+ double m_massmin;
	};

	#endif
	diff --git a/EvtGenBase/EvtParticleDecayList.hh b/EvtGenBase/EvtParticleDecayList.hh
	--- a/EvtGenBase/EvtParticleDecayList.hh
	+++ b/EvtGenBase/EvtParticleDecayList.hh
	@@ -29,9 +29,9 @@
	public:
	EvtParticleDecayList()
	{
	- _decaylist = nullptr;
	- _nmode = 0;
	- _rawbrfrsum = 0;
	+ m_decaylist = nullptr;
	+ m_nmode = 0;
	+ m_rawbrfrsum = 0;
	}

	EvtParticleDecayList( const EvtParticleDecayList& o );
	@@ -40,7 +40,7 @@

	EvtParticleDecayList& operator=( const EvtParticleDecayList& o );

	- int getNMode() const { return _nmode; }
	+ int getNMode() const { return m_nmode; }

	void setNMode( int nmode );

	@@ -49,8 +49,8 @@

	EvtParticleDecay& getDecay( int nchannel ) const;

	- double getRawBrfrSum() { return _rawbrfrsum; }
	- void setRawBrfrSum( double rawbrfrsum ) { _rawbrfrsum = rawbrfrsum; }
	+ double getRawBrfrSum() { return m_rawbrfrsum; }
	+ void setRawBrfrSum( double rawbrfrsum ) { m_rawbrfrsum = rawbrfrsum; }

	void makeChargeConj( EvtParticleDecayList* conjDecayList );

	@@ -58,7 +58,7 @@

	void alocateDecay( int nmode )
	{
	- _decaylist = new EvtParticleDecayPtr[nmode];
	+ m_decaylist = new EvtParticleDecayPtr[nmode];
	}

	void removeMode( EvtDecayBase* decay );
	@@ -71,10 +71,10 @@
	bool isJetSet() const;

	private:
	- EvtParticleDecayPtr* _decaylist;
	+ EvtParticleDecayPtr* m_decaylist;

	- double _rawbrfrsum;
	- int _nmode;
	+ double m_rawbrfrsum;
	+ int m_nmode;
	};

	#endif
	diff --git a/EvtGenBase/EvtPatches.hh b/EvtGenBase/EvtPatches.hh
	--- a/EvtGenBase/EvtPatches.hh
	+++ b/EvtGenBase/EvtPatches.hh
	@@ -25,4 +25,4 @@
	#endif /* ifndef _CLOCK_T */
	#endif

	-#define _unused( x ) ( (void)x )
	+#define UNUSED( x ) ( (void)x )
	diff --git a/EvtGenBase/EvtPdf.hh b/EvtGenBase/EvtPdf.hh
	--- a/EvtGenBase/EvtPdf.hh
	+++ b/EvtGenBase/EvtPdf.hh
	@@ -72,7 +72,7 @@
	class EvtPdf {
	public:
	EvtPdf() {}
	- EvtPdf( const EvtPdf& other ) : _itg( other._itg ) {}
	+ EvtPdf( const EvtPdf& other ) : m_itg( other.m_itg ) {}
	virtual ~EvtPdf() {}
	virtual EvtPdf<T>* clone() const = 0;

	@@ -95,19 +95,19 @@
	// Analytic integration. Calls cascade down until an overridden
	// method is called.

	- void setItg( EvtValError itg ) { _itg = itg; }
	+ void setItg( EvtValError itg ) { m_itg = itg; }

	EvtValError getItg() const
	{
	- if ( !_itg.valueKnown() )
	- _itg = compute_integral();
	- return _itg;
	+ if ( !m_itg.valueKnown() )
	+ m_itg = compute_integral();
	+ return m_itg;
	}
	EvtValError getItg( int N ) const
	{
	- if ( !_itg.valueKnown() )
	- _itg = compute_integral( N );
	- return _itg;
	+ if ( !m_itg.valueKnown() )
	+ m_itg = compute_integral( N );
	+ return m_itg;
	}

	virtual EvtValError compute_integral() const
	@@ -136,7 +136,7 @@

	protected:
	virtual double pdf( const T& ) const = 0;
	- mutable EvtValError _itg;
	+ mutable EvtValError m_itg;
	};

	template <class T>
	@@ -144,18 +144,18 @@
	public:
	typedef T result_type;

	- EvtPdfGen() : _pdf( 0 ) {}
	+ EvtPdfGen() : m_pdf( 0 ) {}
	EvtPdfGen( const EvtPdfGen<T>& other ) :
	- _pdf( other._pdf ? other._pdf->clone() : nullptr )
	+ m_pdf( other.m_pdf ? other.m_pdf->clone() : nullptr )
	{
	}
	- EvtPdfGen( const EvtPdf<T>& pdf ) : _pdf( pdf.clone() ) {}
	- ~EvtPdfGen() { delete _pdf; }
	+ EvtPdfGen( const EvtPdf<T>& pdf ) : m_pdf( pdf.clone() ) {}
	+ ~EvtPdfGen() { delete m_pdf; }

	- result_type operator()() { return _pdf->randomPoint(); }
	+ result_type operator()() { return m_pdf->randomPoint(); }

	private:
	- EvtPdf<T>* _pdf;
	+ EvtPdf<T>* m_pdf;
	};

	template <class T>
	@@ -165,41 +165,41 @@
	typedef bool result_type;

	EvtPdfPred() {}
	- EvtPdfPred( const EvtPdf<T>& thePdf ) : itsPdf( thePdf.clone() ) {}
	+ EvtPdfPred( const EvtPdf<T>& thePdf ) : m_pdf( thePdf.clone() ) {}
	EvtPdfPred( const EvtPdfPred& other ) :
	- COPY_PTR( itsPdf ), COPY_MEM( itsPdfMax )
	+ COPY_PTR( m_pdf ), COPY_MEM( m_pdfMax )
	{
	}
	- ~EvtPdfPred() { delete itsPdf; }
	+ ~EvtPdfPred() { delete m_pdf; }

	result_type operator()( argument_type p )
	{
	- assert( itsPdf );
	- assert( itsPdfMax.valueKnown() );
	+ assert( m_pdf );
	+ assert( m_pdfMax.valueKnown() );

	- double random = EvtRandom::Flat( 0., itsPdfMax.value() );
	- return ( random <= itsPdf->evaluate( p ) );
	+ double random = EvtRandom::Flat( 0., m_pdfMax.value() );
	+ return ( random <= m_pdf->evaluate( p ) );
	}

	- EvtPdfMax<T> getMax() const { return itsPdfMax; }
	- void setMax( const EvtPdfMax<T>& max ) { itsPdfMax = max; }
	+ EvtPdfMax<T> getMax() const { return m_pdfMax; }
	+ void setMax( const EvtPdfMax<T>& max ) { m_pdfMax = max; }
	template <class InputIterator>
	void compute_max( InputIterator it, InputIterator end, double factor = 1. )
	{
	T p = *it++;
	- itsPdfMax = EvtPdfMax<T>( p, itsPdf->evaluate( p ) * factor );
	+ m_pdfMax = EvtPdfMax<T>( p, m_pdf->evaluate( p ) * factor );

	while ( !( it == end ) ) {
	- T p = *it++;
	- double val = itsPdf->evaluate( p ) * factor;
	- if ( val > itsPdfMax.value() )
	- itsPdfMax = EvtPdfMax<T>( p, val );
	+ T pp = *it++;
	+ double val = m_pdf->evaluate( pp ) * factor;
	+ if ( val > m_pdfMax.value() )
	+ m_pdfMax = EvtPdfMax<T>( pp, val );
	}
	}

	private:
	- EvtPdf<T>* itsPdf;
	- EvtPdfMax<T> itsPdfMax;
	+ EvtPdf<T>* m_pdf;
	+ EvtPdfMax<T> m_pdfMax;
	};

	template <class T>
	@@ -209,51 +209,51 @@
	typedef T argument_type;

	EvtPdfUnary() {}
	- EvtPdfUnary( const EvtPdf<T>& thePdf ) : itsPdf( thePdf.clone() ) {}
	- EvtPdfUnary( const EvtPdfUnary& other ) : COPY_PTR( itsPdf ) {}
	- ~EvtPdfUnary() { delete itsPdf; }
	+ EvtPdfUnary( const EvtPdf<T>& thePdf ) : m_pdf( thePdf.clone() ) {}
	+ EvtPdfUnary( const EvtPdfUnary& other ) : COPY_PTR( m_pdf ) {}
	+ ~EvtPdfUnary() { delete m_pdf; }

	result_type operator()( argument_type p )
	{
	- assert( itsPdf );
	- double ret = itsPdf->evaluate( p );
	+ assert( m_pdf );
	+ double ret = m_pdf->evaluate( p );
	return ret;
	}

	private:
	- EvtPdf<T>* itsPdf;
	+ EvtPdf<T>* m_pdf;
	};

	template <class T>
	class EvtPdfDiv : public EvtPdf<T> {
	public:
	- EvtPdfDiv() : itsNum( 0 ), itsDen( 0 ) {}
	+ EvtPdfDiv() : m_num( 0 ), m_den( 0 ) {}
	EvtPdfDiv( const EvtPdf<T>& theNum, const EvtPdf<T>& theDen ) :
	- EvtPdf<T>(), itsNum( theNum.clone() ), itsDen( theDen.clone() )
	+ EvtPdf<T>(), m_num( theNum.clone() ), m_den( theDen.clone() )
	{
	}
	EvtPdfDiv( const EvtPdfDiv<T>& other ) :
	- EvtPdf<T>( other ), COPY_PTR( itsNum ), COPY_PTR( itsDen )
	+ EvtPdf<T>( other ), COPY_PTR( m_num ), COPY_PTR( m_den )
	{
	}
	virtual ~EvtPdfDiv()
	{
	- delete itsNum;
	- delete itsDen;
	+ delete m_num;
	+ delete m_den;
	}
	EvtPdf<T>* clone() const override { return new EvtPdfDiv( *this ); }

	double pdf( const T& p ) const override
	{
	- double num = itsNum->evaluate( p );
	- double den = itsDen->evaluate( p );
	+ double num = m_num->evaluate( p );
	+ double den = m_den->evaluate( p );
	assert( den != 0 );
	return num / den;
	}

	private:
	- EvtPdf<T>* itsNum; // numerator
	- EvtPdf<T>* itsDen; // denominator
	+ EvtPdf<T>* m_num; // numerator
	+ EvtPdf<T>* m_den; // denominator
	};

	template <class T>
	@@ -312,8 +312,8 @@
	} else
	x = EvtValError( av );
	}
	- _itg = x * pc.getItg();
	- return _itg;
	+ m_itg = x * pc.getItg();
	+ return m_itg;
	}

	template <class T>
	diff --git a/EvtGenBase/EvtPdfMax.hh b/EvtGenBase/EvtPdfMax.hh
	--- a/EvtGenBase/EvtPdfMax.hh
	+++ b/EvtGenBase/EvtPdfMax.hh
	@@ -30,34 +30,34 @@
	template <class Point>
	class EvtPdfMax {
	public:
	- EvtPdfMax() : _value( -1 ), _valueKnown( false ), _locKnown( false ) {}
	+ EvtPdfMax() : m_value( -1 ), m_valueKnown( false ), m_locKnown( false ) {}
	EvtPdfMax( double value ) :
	- _value( value ), _valueKnown( true ), _locKnown( false )
	+ m_value( value ), m_valueKnown( true ), m_locKnown( false )
	{
	}
	EvtPdfMax( Point p, double value ) :
	- _value( value ), _valueKnown( true ), _locKnown( true ), _loc( p )
	+ m_value( value ), m_valueKnown( true ), m_locKnown( true ), m_loc( p )
	{
	}

	- bool valueKnown() const { return _valueKnown; }
	+ bool valueKnown() const { return m_valueKnown; }
	double value() const
	{
	- assert( _valueKnown );
	- return _value;
	+ assert( m_valueKnown );
	+ return m_value;
	}
	- bool locKnown() const { return _locKnown; }
	+ bool locKnown() const { return m_locKnown; }
	Point loc() const
	{
	- assert( _locKnown );
	- return _loc;
	+ assert( m_locKnown );
	+ return m_loc;
	}

	private:
	- double _value;
	- bool _valueKnown;
	- bool _locKnown;
	- Point _loc;
	+ double m_value;
	+ bool m_valueKnown;
	+ bool m_locKnown;
	+ Point m_loc;
	};

	#endif
	diff --git a/EvtGenBase/EvtPdfSum.hh b/EvtGenBase/EvtPdfSum.hh
	--- a/EvtGenBase/EvtPdfSum.hh
	+++ b/EvtGenBase/EvtPdfSum.hh
	@@ -41,20 +41,20 @@
	void addTerm( double c, const EvtPdf<T>& pdf )
	{
	assert( c >= 0. );
	- _c.push_back( c );
	- _term.push_back( pdf.clone() );
	+ m_c.push_back( c );
	+ m_term.push_back( pdf.clone() );
	}

	void addOwnedTerm( double c, std::unique_ptr<EvtPdf<T>> pdf )
	{
	- _c.push_back( c );
	- _term.push_back( pdf.release() );
	+ m_c.push_back( c );
	+ m_term.push_back( pdf.release() );
	}

	- size_t nTerms() const { return _term.size(); } // number of terms
	+ size_t nTerms() const { return m_term.size(); } // number of terms

	- inline double c( int i ) const { return _c[i]; }
	- inline EvtPdf<T>* getPdf( int i ) const { return _term[i]; }
	+ inline double c( int i ) const { return m_c[i]; }
	+ inline EvtPdf<T>* getPdf( int i ) const { return m_term[i]; }

	// Integrals

	@@ -65,24 +65,24 @@
	protected:
	double pdf( const T& p ) const override;

	- vector<double> _c; // coefficients
	- vector<EvtPdf<T>*> _term; // pointers to pdfs
	+ vector<double> m_c; // coefficients
	+ vector<EvtPdf<T>*> m_term; // pointers to pdfs
	};

	template <class T>
	EvtPdfSum<T>::EvtPdfSum( const EvtPdfSum<T>& other ) : EvtPdf<T>( other )
	{
	for ( size_t i = 0; i < other.nTerms(); i++ ) {
	- _c.push_back( other._c[i] );
	- _term.push_back( other._term[i]->clone() );
	+ m_c.push_back( other.m_c[i] );
	+ m_term.push_back( other.m_term[i]->clone() );
	}
	}

	template <class T>
	EvtPdfSum<T>::~EvtPdfSum()
	{
	- for ( size_t i = 0; i < _c.size(); i++ ) {
	- delete _term[i];
	+ for ( size_t i = 0; i < m_c.size(); i++ ) {
	+ delete m_term[i];
	}
	}

	@@ -90,8 +90,8 @@
	double EvtPdfSum<T>::pdf( const T& p ) const
	{
	double ret = 0.;
	- for ( size_t i = 0; i < _c.size(); i++ ) {
	- ret += _c[i] * _term[i]->evaluate( p );
	+ for ( size_t i = 0; i < m_c.size(); i++ ) {
	+ ret += m_c[i] * m_term[i]->evaluate( p );
	}
	return ret;
	}
	@@ -105,7 +105,7 @@
	{
	EvtValError itg( 0.0, 0.0 );
	for ( size_t i = 0; i < nTerms(); i++ ) {
	- itg += _c[i] * _term[i]->getItg();
	+ itg += m_c[i] * m_term[i]->getItg();
	}
	return itg;
	}
	@@ -115,7 +115,7 @@
	{
	EvtValError itg( 0.0, 0.0 );
	for ( size_t i = 0; i < nTerms(); i++ )
	- itg += _c[i] * _term[i]->getItg( N );
	+ itg += m_c[i] * m_term[i]->getItg( N );
	return itg;
	}

	@@ -128,22 +128,22 @@
	template <class T>
	T EvtPdfSum<T>::randomPoint()
	{
	- if ( !this->_itg.valueKnown() )
	- this->_itg = compute_integral();
	+ if ( !this->m_itg.valueKnown() )
	+ this->m_itg = compute_integral();

	- double max = this->_itg.value();
	+ double max = this->m_itg.value();
	double rnd = EvtRandom::Flat( 0, max );

	double sum = 0.;
	size_t i;
	for ( i = 0; i < nTerms(); i++ ) {
	- double itg = _term[i]->getItg().value();
	- sum += _c[i] * itg;
	+ double itg = m_term[i]->getItg().value();
	+ sum += m_c[i] * itg;
	if ( sum > rnd )
	break;
	}

	- return _term[i]->randomPoint();
	+ return m_term[i]->randomPoint();
	}

	#endif
	diff --git a/EvtGenBase/EvtPoint1D.hh b/EvtGenBase/EvtPoint1D.hh
	--- a/EvtGenBase/EvtPoint1D.hh
	+++ b/EvtGenBase/EvtPoint1D.hh
	@@ -22,7 +22,7 @@
	#define EVT_POINT_1D_HH

	// Point on a finite 1-D interval. isValid shows whether for a given specification,
	-// the coordinate _value is inside the interval defined by _min, _max.
	+// the coordinate m_value is inside the interval defined by m_min, m_max.

	class EvtPoint1D final {
	public:
	@@ -30,17 +30,17 @@
	EvtPoint1D( double value );
	EvtPoint1D( double min, double max, double value );

	- bool isValid() const { return _valid; }
	+ bool isValid() const { return m_valid; }

	- double value() const { return _value; }
	+ double value() const { return m_value; }

	void print() const;

	private:
	- double _min; // interval minimum
	- double _max; // interval maximum
	- double _value;
	- bool _valid; // valid point inside the interval?
	+ double m_min; // interval minimum
	+ double m_max; // interval maximum
	+ double m_value;
	+ bool m_valid; // valid point inside the interval?
	};

	#endif
	diff --git a/EvtGenBase/EvtPredGen.hh b/EvtGenBase/EvtPredGen.hh
	--- a/EvtGenBase/EvtPredGen.hh
	+++ b/EvtGenBase/EvtPredGen.hh
	@@ -34,18 +34,18 @@
	public:
	typedef typename Generator::result_type result_type;

	- EvtPredGen() : itsTried( 0 ), itsPassed( 0 ) {}
	+ EvtPredGen() : m_tried( 0 ), m_passed( 0 ) {}

	EvtPredGen( Generator gen, Predicate pred ) :
	- itsGen( gen ), itsPred( pred ), itsTried( 0 ), itsPassed( 0 )
	+ m_gen( gen ), m_pred( pred ), m_tried( 0 ), m_passed( 0 )
	{
	}

	EvtPredGen( const EvtPredGen& other ) :
	- itsGen( other.itsGen ),
	- itsPred( other.itsPred ),
	- itsTried( other.itsTried ),
	- itsPassed( other.itsPassed )
	+ m_gen( other.m_gen ),
	+ m_pred( other.m_pred ),
	+ m_tried( other.m_tried ),
	+ m_passed( other.m_passed )
	{
	}

	@@ -56,10 +56,10 @@
	int i = 0;
	int MAX = 10000;
	while ( i++ < MAX ) {
	- itsTried++;
	- result_type point = itsGen();
	- if ( itsPred( point ) ) {
	- itsPassed++;
	+ m_tried++;
	+ result_type point = m_gen();
	+ if ( m_pred( point ) ) {
	+ m_passed++;
	return point;
	}
	}
	@@ -67,17 +67,17 @@
	printf( "No random point generated after %d attempts\n", MAX );
	printf( "Sharp peak? Consider using pole compensation.\n" );
	printf( "I will now pick a point at random to return.\n" );
	- return itsGen();
	+ return m_gen();
	}

	- inline int getTried() const { return itsTried; }
	- inline int getPassed() const { return itsPassed; }
	+ inline int getTried() const { return m_tried; }
	+ inline int getPassed() const { return m_passed; }

	protected:
	- Generator itsGen;
	- Predicate itsPred;
	- int itsTried;
	- int itsPassed;
	+ Generator m_gen;
	+ Predicate m_pred;
	+ int m_tried;
	+ int m_passed;
	};

	#endif
	diff --git a/EvtGenBase/EvtPropFlatte.hh b/EvtGenBase/EvtPropFlatte.hh
	--- a/EvtGenBase/EvtPropFlatte.hh
	+++ b/EvtGenBase/EvtPropFlatte.hh
	@@ -36,12 +36,12 @@
	protected:
	EvtComplex amplitude( const EvtPoint1D& x ) const override;

	- double _m0a;
	- double _m0b;
	+ double m_m0a;
	+ double m_m0b;

	- double _g1;
	- double _m1a;
	- double _m1b;
	+ double m_g1;
	+ double m_m1a;
	+ double m_m1b;
	};

	#endif
	diff --git a/EvtGenBase/EvtPropGounarisSakurai.hh b/EvtGenBase/EvtPropGounarisSakurai.hh
	--- a/EvtGenBase/EvtPropGounarisSakurai.hh
	+++ b/EvtGenBase/EvtPropGounarisSakurai.hh
	@@ -38,13 +38,13 @@
	EvtComplex amplitude( const EvtPoint1D& x ) const override;

	private:
	- EvtDalitzPlot* _dalitzSpace;
	+ EvtDalitzPlot* m_dalitzSpace;

	- EvtCyclic3::Pair _pair;
	- double _gbase;
	- double _m1;
	- double _m2;
	- double _dfun;
	+ EvtCyclic3::Pair m_pair;
	+ double m_gbase;
	+ double m_m1;
	+ double m_m2;
	+ double m_dfun;
	double dFun( double s ) const;
	double dh_dsFun( double s ) const;
	double hFun( double s ) const;
	diff --git a/EvtGenBase/EvtPropagator.hh b/EvtGenBase/EvtPropagator.hh
	--- a/EvtGenBase/EvtPropagator.hh
	+++ b/EvtGenBase/EvtPropagator.hh
	@@ -31,7 +31,7 @@

	class EvtPropagator : public EvtAmplitude<EvtPoint1D> {
	public:
	- EvtPropagator( double m0, double g0 ) : _m0( m0 ), _g0( g0 )
	+ EvtPropagator( double m0, double g0 ) : m_m0( m0 ), m_g0( g0 )
	{
	assert( m0 > 0 );
	assert( g0 >= 0 );
	@@ -39,25 +39,25 @@

	// Accessors

	- inline double m0() const { return _m0; }
	- inline double g0() const { return _g0; }
	+ inline double m0() const { return m_m0; }
	+ inline double g0() const { return m_g0; }

	// Modifiers (can be useful e.g. for fitting!)

	inline void set_m0( double m0 )
	{
	assert( m0 > 0 );
	- _m0 = m0;
	+ m_m0 = m0;
	}
	inline void set_g0( double g0 )
	{
	assert( g0 >= 0 );
	- _g0 = g0;
	+ m_g0 = g0;
	}

	protected:
	- double _m0;
	- double _g0;
	+ double m_m0;
	+ double m_g0;
	};

	#endif
	diff --git a/EvtGenBase/EvtPto3PAmp.hh b/EvtGenBase/EvtPto3PAmp.hh
	--- a/EvtGenBase/EvtPto3PAmp.hh
	+++ b/EvtGenBase/EvtPto3PAmp.hh
	@@ -78,39 +78,39 @@
	void set_fd( double R );
	void set_fb( double R );

	- void setmin( double min ) { _min = min; }
	- void setmax( double max ) { _max = max; }
	+ void setmin( double min ) { m_min = min; }
	+ void setmax( double max ) { m_max = max; }

	virtual EvtComplex evalPropagator( double m ) const
	{
	- return _prop->evaluate( m );
	+ return m_prop->evaluate( m );
	}

	private:
	// Pairing indices:

	- EvtCyclic3::Pair _pairAng; // angular
	- EvtCyclic3::Pair _pairRes; // resonance
	+ EvtCyclic3::Pair m_pairAng; // angular
	+ EvtCyclic3::Pair m_pairRes; // resonance

	// Spin

	- EvtSpinType::spintype _spin;
	+ EvtSpinType::spintype m_spin;

	// Numerator type

	- NumType _typeN;
	+ NumType m_typeN;

	// _Owned_ pointer to propagator factor

	- EvtPropagator* _prop;
	- double _g0; // nominal width
	- double _min; //min and max values on which
	- double _max; //the resonance is defined
	+ EvtPropagator* m_prop;
	+ double m_g0; // nominal width
	+ double m_min; //min and max values on which
	+ double m_max; //the resonance is defined

	// Vertices

	- EvtTwoBodyVertex _vb;
	- EvtTwoBodyVertex _vd;
	+ EvtTwoBodyVertex m_vb;
	+ EvtTwoBodyVertex m_vd;
	};

	#endif
	diff --git a/EvtGenBase/EvtPto3PAmpFactory.hh b/EvtGenBase/EvtPto3PAmpFactory.hh
	--- a/EvtGenBase/EvtPto3PAmpFactory.hh
	+++ b/EvtGenBase/EvtPto3PAmpFactory.hh
	@@ -33,7 +33,7 @@
	class EvtPto3PAmpFactory final : public EvtAmpFactory<EvtDalitzPoint> {
	public:
	EvtPto3PAmpFactory( const EvtDalitzPlot& dp ) :
	- EvtAmpFactory<EvtDalitzPoint>(), _dp( dp )
	+ EvtAmpFactory<EvtDalitzPoint>(), m_dp( dp )
	{
	}
	EvtPto3PAmpFactory( EvtPto3PAmpFactory&& ) = default;
	@@ -51,7 +51,7 @@
	double matchIsobarCoef( EvtAmplitude<EvtDalitzPoint>& amp,
	EvtPdf<EvtDalitzPoint>& pdf, EvtCyclic3::Pair i );

	- EvtDalitzPlot _dp;
	+ EvtDalitzPlot m_dp;
	};

	#endif
	diff --git a/EvtGenBase/EvtRadCorr.hh b/EvtGenBase/EvtRadCorr.hh
	--- a/EvtGenBase/EvtRadCorr.hh
	+++ b/EvtGenBase/EvtRadCorr.hh
	@@ -42,9 +42,9 @@
	static void setNormalRadCorr();

	private:
	- static EvtAbsRadCorr* _fsrEngine;
	- static bool _alwaysRadCorr;
	- static bool _neverRadCorr;
	+ static EvtAbsRadCorr* m_fsrEngine;
	+ static bool m_alwaysRadCorr;
	+ static bool m_neverRadCorr;
	};

	#endif
	diff --git a/EvtGenBase/EvtRandom.hh b/EvtGenBase/EvtRandom.hh
	--- a/EvtGenBase/EvtRandom.hh
	+++ b/EvtGenBase/EvtRandom.hh
	@@ -40,7 +40,7 @@
	static void setRandomEngine( EvtRandomEngine* randomEngine );

	private:
	- static EvtRandomEngine* _randomEngine;
	+ static EvtRandomEngine* m_randomEngine;
	};

	#endif
	diff --git a/EvtGenBase/EvtRaritaSchwinger.hh b/EvtGenBase/EvtRaritaSchwinger.hh
	--- a/EvtGenBase/EvtRaritaSchwinger.hh
	+++ b/EvtGenBase/EvtRaritaSchwinger.hh
	@@ -86,7 +86,7 @@

	private:
	//First index in spinor index, second is Lorentz index.
	- EvtComplex _rs[4][4];
	+ EvtComplex m_rs[4][4];
	};

	EvtRaritaSchwinger::EvtRaritaSchwinger()
	@@ -94,7 +94,7 @@
	int i, j;
	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _rs[i][j] = 0.0;
	+ m_rs[i][j] = 0.0;
	}
	}
	}
	@@ -104,7 +104,7 @@
	int i, j;
	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _rs[i][j] = rs._rs[i][j];
	+ m_rs[i][j] = rs.m_rs[i][j];
	}
	}
	}
	@@ -114,7 +114,7 @@
	int i, j;
	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _rs[i][j] = rs._rs[i][j];
	+ m_rs[i][j] = rs.m_rs[i][j];
	}
	}

	diff --git a/EvtGenBase/EvtRaritaSchwingerParticle.hh b/EvtGenBase/EvtRaritaSchwingerParticle.hh
	--- a/EvtGenBase/EvtRaritaSchwingerParticle.hh
	+++ b/EvtGenBase/EvtRaritaSchwingerParticle.hh
	@@ -43,8 +43,8 @@
	double gamma ) const override;

	private:
	- EvtRaritaSchwinger _spinorRest[4];
	- EvtRaritaSchwinger _spinor[4];
	+ EvtRaritaSchwinger m_spinorRest[4];
	+ EvtRaritaSchwinger m_spinor[4];
	EvtRaritaSchwingerParticle( const EvtRaritaSchwingerParticle& d );
	EvtRaritaSchwingerParticle& operator=( const EvtRaritaSchwingerParticle& d );
	};
	diff --git a/EvtGenBase/EvtRelBreitWignerBarrierFact.hh b/EvtGenBase/EvtRelBreitWignerBarrierFact.hh
	--- a/EvtGenBase/EvtRelBreitWignerBarrierFact.hh
	+++ b/EvtGenBase/EvtRelBreitWignerBarrierFact.hh
	@@ -42,13 +42,13 @@
	double getRandMass( EvtId* parId, int nDaug, EvtId* dauId, EvtId* othDaugId,
	double maxMass, double* dauMasses ) override;

	- void reSetBlatt( double blatt ) override { _blattDecay = blatt; }
	- void reSetBlattBirth( double blatt ) override { _blattBirth = blatt; }
	+ void reSetBlatt( double blatt ) override { m_blattDecay = blatt; }
	+ void reSetBlattBirth( double blatt ) override { m_blattBirth = blatt; }

	protected:
	- double _blattDecay;
	- double _blattBirth;
	- bool _errorCond;
	+ double m_blattDecay;
	+ double m_blattBirth;
	+ bool m_errorCond;
	};

	#endif
	diff --git a/EvtGenBase/EvtResonance.hh b/EvtGenBase/EvtResonance.hh
	--- a/EvtGenBase/EvtResonance.hh
	+++ b/EvtGenBase/EvtResonance.hh
	@@ -36,24 +36,24 @@

	//accessors
	//return 4-momenta of the particles involved
	- inline const EvtVector4R& p4_p() { return _p4_p; }
	- inline const EvtVector4R& p4_d1() { return _p4_d1; }
	- inline const EvtVector4R& p4_d2() { return _p4_d2; }
	+ inline const EvtVector4R& p4_p() { return m_p4_p; }
	+ inline const EvtVector4R& p4_d1() { return m_p4_d1; }
	+ inline const EvtVector4R& p4_d2() { return m_p4_d2; }

	//return amplitude
	- inline double amplitude() { return _ampl; }
	+ inline double amplitude() { return m_ampl; }

	//return theta
	- inline double theta() { return _theta; }
	+ inline double theta() { return m_theta; }

	//return gamma
	- inline double gamma() { return _gamma; }
	+ inline double gamma() { return m_gamma; }

	//return bwm
	- inline double bwm() { return _bwm; }
	+ inline double bwm() { return m_bwm; }

	//return spin
	- inline int spin() { return _spin; }
	+ inline int spin() { return m_spin; }

	//calculate amplitude for this resonance
	EvtComplex resAmpl();
	@@ -62,9 +62,9 @@
	EvtComplex relBrWig( int i );

	private:
	- EvtVector4R _p4_p, _p4_d1, _p4_d2;
	- double _ampl, _theta, _gamma, _bwm;
	- int _spin;
	+ EvtVector4R m_p4_p, m_p4_d1, m_p4_d2;
	+ double m_ampl, m_theta, m_gamma, m_bwm;
	+ int m_spin;
	};

	#endif
	diff --git a/EvtGenBase/EvtResonance2.hh b/EvtGenBase/EvtResonance2.hh
	--- a/EvtGenBase/EvtResonance2.hh
	+++ b/EvtGenBase/EvtResonance2.hh
	@@ -39,33 +39,33 @@

	//accessors
	//return 4-momenta of the particles involved
	- inline const EvtVector4R& p4_p() const { return _p4_p; }
	- inline const EvtVector4R& p4_d1() const { return _p4_d1; }
	- inline const EvtVector4R& p4_d2() const { return _p4_d2; }
	+ inline const EvtVector4R& p4_p() const { return m_p4_p; }
	+ inline const EvtVector4R& p4_d1() const { return m_p4_d1; }
	+ inline const EvtVector4R& p4_d2() const { return m_p4_d2; }

	//return amplitude
	- inline double amplitude() const { return _ampl; }
	+ inline double amplitude() const { return m_ampl; }

	//return theta
	- inline double theta() const { return _theta; }
	+ inline double theta() const { return m_theta; }

	//return gamma
	- inline double gamma() const { return _gamma; }
	+ inline double gamma() const { return m_gamma; }

	//return bwm
	- inline double bwm() const { return _bwm; }
	+ inline double bwm() const { return m_bwm; }

	//return spin
	- inline int spin() const { return _spin; }
	+ inline int spin() const { return m_spin; }

	//calculate amplitude for this resonance
	EvtComplex resAmpl() const;

	private:
	- EvtVector4R _p4_p, _p4_d1, _p4_d2;
	- double _ampl, _theta, _gamma, _bwm, _barrier1, _barrier2;
	- int _spin;
	- bool _invmass_angdenom;
	+ EvtVector4R m_p4_p, m_p4_d1, m_p4_d2;
	+ double m_ampl, m_theta, m_gamma, m_bwm, m_barrier1, m_barrier2;
	+ int m_spin;
	+ bool m_invmass_angdenom;
	};

	#endif
	diff --git a/EvtGenBase/EvtSecondary.hh b/EvtGenBase/EvtSecondary.hh
	--- a/EvtGenBase/EvtSecondary.hh
	+++ b/EvtGenBase/EvtSecondary.hh
	@@ -33,10 +33,10 @@

	void init();

	- int getStdHepIndex( int i ) { return _stdhepindex[i]; }
	- int getD1( int i ) { return _id1[i]; }
	- int getD2( int i ) { return _id2[i]; }
	- int getD3( int i ) { return _id3[i]; }
	+ int getStdHepIndex( int i ) { return m_stdhepindex[i]; }
	+ int getD1( int i ) { return m_id1[i]; }
	+ int getD2( int i ) { return m_id2[i]; }
	+ int getD3( int i ) { return m_id3[i]; }

	int getNPart();
	void createSecondary( int stdhepindex, EvtParticle* prnt );
	@@ -45,11 +45,11 @@
	const EvtSecondary& secondary );

	private:
	- int _npart;
	- int _stdhepindex[EVTSECONDARYLENGTH];
	- int _id1[EVTSECONDARYLENGTH];
	- int _id2[EVTSECONDARYLENGTH];
	- int _id3[EVTSECONDARYLENGTH];
	+ int m_npart;
	+ int m_stdhepindex[EVTSECONDARYLENGTH];
	+ int m_id1[EVTSECONDARYLENGTH];
	+ int m_id2[EVTSECONDARYLENGTH];
	+ int m_id3[EVTSECONDARYLENGTH];
	};

	#endif
	diff --git a/EvtGenBase/EvtSimpleRandomEngine.hh b/EvtGenBase/EvtSimpleRandomEngine.hh
	--- a/EvtGenBase/EvtSimpleRandomEngine.hh
	+++ b/EvtGenBase/EvtSimpleRandomEngine.hh
	@@ -25,14 +25,14 @@

	class EvtSimpleRandomEngine : public EvtRandomEngine {
	public:
	- EvtSimpleRandomEngine() { _next = 1; }
	+ EvtSimpleRandomEngine() { m_next = 1; }

	- void reset() { _next = 1; }
	+ void reset() { m_next = 1; }

	double random() override;

	private:
	- unsigned long int _next;
	+ unsigned long int m_next;
	};

	#endif
	diff --git a/EvtGenBase/EvtSpinDensity.hh b/EvtGenBase/EvtSpinDensity.hh
	--- a/EvtGenBase/EvtSpinDensity.hh
	+++ b/EvtGenBase/EvtSpinDensity.hh
	@@ -43,8 +43,8 @@
	int check();

	private:
	- EvtComplexPtrPtr rho;
	- int dim;
	+ EvtComplexPtrPtr m_rho;
	+ int m_dim;
	};

	#endif
	diff --git a/EvtGenBase/EvtStdHep.hh b/EvtGenBase/EvtStdHep.hh
	--- a/EvtGenBase/EvtStdHep.hh
	+++ b/EvtGenBase/EvtStdHep.hh
	@@ -34,16 +34,16 @@

	void init();

	- int getFirstMother( int i ) { return _prntfirst[i]; }
	- int getLastMother( int i ) { return _prntlast[i]; }
	- int getFirstDaughter( int i ) { return _daugfirst[i]; }
	- int getLastDaughter( int i ) { return _dauglast[i]; }
	+ int getFirstMother( int i ) { return m_prntfirst[i]; }
	+ int getLastMother( int i ) { return m_prntlast[i]; }
	+ int getFirstDaughter( int i ) { return m_daugfirst[i]; }
	+ int getLastDaughter( int i ) { return m_dauglast[i]; }

	- int getStdHepID( int i ) { return _id[i]; }
	- int getIStat( int i ) { return _istat[i]; }
	+ int getStdHepID( int i ) { return m_id[i]; }
	+ int getIStat( int i ) { return m_istat[i]; }

	- EvtVector4R getP4( int i ) { return _p4[i]; }
	- EvtVector4R getX4( int i ) { return _x[i]; }
	+ EvtVector4R getP4( int i ) { return m_p4[i]; }
	+ EvtVector4R getX4( int i ) { return m_x[i]; }

	void translate( EvtVector4R d );

	@@ -54,15 +54,15 @@
	friend std::ostream& operator<<( std::ostream& s, const EvtStdHep& stdhep );

	private:
	- int _npart;
	- EvtVector4R _p4[EVTSTDHEPLENGTH];
	- EvtVector4R _x[EVTSTDHEPLENGTH];
	- int _prntfirst[EVTSTDHEPLENGTH];
	- int _prntlast[EVTSTDHEPLENGTH];
	- int _daugfirst[EVTSTDHEPLENGTH];
	- int _dauglast[EVTSTDHEPLENGTH];
	- int _id[EVTSTDHEPLENGTH];
	- int _istat[EVTSTDHEPLENGTH];
	+ int m_npart;
	+ EvtVector4R m_p4[EVTSTDHEPLENGTH];
	+ EvtVector4R m_x[EVTSTDHEPLENGTH];
	+ int m_prntfirst[EVTSTDHEPLENGTH];
	+ int m_prntlast[EVTSTDHEPLENGTH];
	+ int m_daugfirst[EVTSTDHEPLENGTH];
	+ int m_dauglast[EVTSTDHEPLENGTH];
	+ int m_id[EVTSTDHEPLENGTH];
	+ int m_istat[EVTSTDHEPLENGTH];
	};

	#endif
	diff --git a/EvtGenBase/EvtStreamAdapter.hh b/EvtGenBase/EvtStreamAdapter.hh
	--- a/EvtGenBase/EvtStreamAdapter.hh
	+++ b/EvtGenBase/EvtStreamAdapter.hh
	@@ -43,7 +43,7 @@
	class EvtGenStreamAdapter : public EvtStreamAdapter<Point> {
	public:
	EvtGenStreamAdapter( Generator gen, int count ) :
	- _gen( gen ), _count( count )
	+ m_gen( gen ), m_count( count )
	{
	}

	@@ -53,13 +53,13 @@
	{
	return new EvtGenStreamAdapter( *this );
	}
	- Point currentValue() override { return _gen(); }
	- bool pastEnd() override { return ( _count <= 0 ); }
	- void advance() override { _count--; }
	+ Point currentValue() override { return m_gen(); }
	+ bool pastEnd() override { return ( m_count <= 0 ); }
	+ void advance() override { m_count--; }

	private:
	- Generator _gen;
	- int _count; // also serves as past the end indicator
	+ Generator m_gen;
	+ int m_count; // also serves as past the end indicator
	};

	// Only points satisfying a predicate are read from the stream.
	@@ -68,7 +68,7 @@
	class EvtPredStreamAdapter : public EvtStreamAdapter<Point> {
	public:
	EvtPredStreamAdapter( Predicate pred, Iterator it, Iterator end ) :
	- _pred( pred ), _it( it ), _end( end )
	+ m_pred( pred ), m_it( it ), m_end( end )
	{
	}
	virtual ~EvtPredStreamAdapter() {}
	@@ -81,21 +81,21 @@
	{
	Point value;
	while ( !pastEnd() ) {
	- value = *_it;
	- if ( _pred( value ) )
	+ value = *m_it;
	+ if ( m_pred( value ) )
	break;
	- _it++;
	+ m_it++;
	}
	return value;
	}

	- virtual bool pastEnd() { return _it == _end; }
	- virtual void advance() { _it++; }
	+ virtual bool pastEnd() { return m_it == m_end; }
	+ virtual void advance() { m_it++; }

	private:
	- Predicate _pred;
	- Iterator _it;
	- Iterator _end;
	+ Predicate m_pred;
	+ Iterator m_it;
	+ Iterator m_end;
	};

	#endif
	diff --git a/EvtGenBase/EvtStreamInputIterator.hh b/EvtGenBase/EvtStreamInputIterator.hh
	--- a/EvtGenBase/EvtStreamInputIterator.hh
	+++ b/EvtGenBase/EvtStreamInputIterator.hh
	@@ -40,38 +40,38 @@
	typedef const Point* pointer;
	typedef const Point& reference;

	- EvtStreamInputIterator() : _counter( 0 ) {}
	+ EvtStreamInputIterator() : m_counter( 0 ) {}

	EvtStreamInputIterator( const EvtStreamInputIterator& other ) :
	- _counter( other._counter ? other._counter->clone() : nullptr ),
	- _currentValue( other._currentValue )
	+ m_counter( other.m_counter ? other.m_counter->clone() : nullptr ),
	+ m_currentValue( other.m_currentValue )
	{
	}

	EvtStreamInputIterator( EvtStreamAdapter<Point>& counter ) :
	- _counter( counter.clone() )
	+ m_counter( counter.clone() )
	{
	- _currentValue = _counter->currentValue();
	+ m_currentValue = m_counter->currentValue();
	}

	~EvtStreamInputIterator()
	{
	- if ( _counter )
	- delete _counter;
	+ if ( m_counter )
	+ delete m_counter;
	}

	- reference operator*() const { return _currentValue; }
	+ reference operator*() const { return m_currentValue; }

	EvtStreamInputIterator& operator++()
	{
	- _read();
	+ m_read();
	return *this;
	}

	EvtStreamInputIterator operator++( int )
	{
	EvtStreamInputIterator tmp = *this;
	- _read();
	+ m_read();
	return tmp;
	}

	@@ -82,23 +82,23 @@
	}

	protected:
	- EvtStreamAdapter<Point>* _counter;
	- value_type _currentValue;
	+ EvtStreamAdapter<Point>* m_counter;
	+ value_type m_currentValue;

	bool pastEnd() const
	{
	bool ret = true;
	- if ( _counter )
	- ret = _counter->pastEnd();
	+ if ( m_counter )
	+ ret = m_counter->pastEnd();
	return ret;
	}

	// Advances the iterator

	- void _read()
	+ void m_read()
	{
	- _counter->advance();
	- _currentValue = _counter->currentValue();
	+ m_counter->advance();
	+ m_currentValue = m_counter->currentValue();
	}
	};

	diff --git a/EvtGenBase/EvtStringHash.hh b/EvtGenBase/EvtStringHash.hh
	--- a/EvtGenBase/EvtStringHash.hh
	+++ b/EvtGenBase/EvtStringHash.hh
	@@ -33,29 +33,29 @@

	private:
	EvtStringHash();
	- int _size;
	+ int m_size;
	inline int hash( const std::string& str );
	- std::string*** _strings;
	- T*** _data;
	- int* _entries;
	+ std::string*** m_strings;
	+ T*** m_data;
	+ int* m_entries;
	};

	template <class T>
	EvtStringHash<T>::EvtStringHash( int size )
	{
	- _size = size;
	+ m_size = size;

	typedef std::string** EvtStringPtrPtr;
	typedef T** TPtrPtr;

	- _strings = new EvtStringPtrPtr[_size];
	- _data = new TPtrPtr[_size];
	- _entries = new int[_size];
	+ m_strings = new EvtStringPtrPtr[m_size];
	+ m_data = new TPtrPtr[m_size];
	+ m_entries = new int[m_size];

	int i;

	- for ( i = 0; i < _size; i++ ) {
	- _entries[i] = 0;
	+ for ( i = 0; i < m_size; i++ ) {
	+ m_entries[i] = 0;
	}
	}

	@@ -63,20 +63,20 @@
	EvtStringHash<T>::~EvtStringHash()
	{
	int i;
	- for ( i = 0; i < _size; i++ ) {
	+ for ( i = 0; i < m_size; i++ ) {
	int j;
	- for ( j = 0; j < _entries[i]; j++ ) {
	- delete _strings[i][j];
	+ for ( j = 0; j < m_entries[i]; j++ ) {
	+ delete m_strings[i][j];
	}
	- if ( _entries[i] > 0 ) {
	- delete[] _strings[i];
	- delete[] _data[i];
	+ if ( m_entries[i] > 0 ) {
	+ delete[] m_strings[i];
	+ delete[] m_data[i];
	}
	}

	- delete[] _strings;
	- delete[] _data;
	- delete[] _entries;
	+ delete[] m_strings;
	+ delete[] m_data;
	+ delete[] m_entries;
	}

	template <class T>
	@@ -87,29 +87,29 @@
	typedef std::string* EvtStringPtr;
	typedef T* TPtr;

	- std::string** newstrings = new EvtStringPtr[_entries[ihash] + 1];
	- T** newdata = new TPtr[_entries[ihash] + 1];
	+ std::string** newstrings = new EvtStringPtr[m_entries[ihash] + 1];
	+ T** newdata = new TPtr[m_entries[ihash] + 1];

	int i;

	- for ( i = 0; i < _entries[ihash]; i++ ) {
	- newstrings[i] = _strings[ihash][i];
	- newdata[i] = _data[ihash][i];
	+ for ( i = 0; i < m_entries[ihash]; i++ ) {
	+ newstrings[i] = m_strings[ihash][i];
	+ newdata[i] = m_data[ihash][i];
	}

	- newstrings[_entries[ihash]] = new std::string;
	- *( newstrings[_entries[ihash]] ) = str;
	- newdata[_entries[ihash]] = data;
	+ newstrings[m_entries[ihash]] = new std::string;
	+ *( newstrings[m_entries[ihash]] ) = str;
	+ newdata[m_entries[ihash]] = data;

	- if ( _entries[ihash] != 0 ) {
	- delete[] _strings[ihash];
	- delete[] _data[ihash];
	+ if ( m_entries[ihash] != 0 ) {
	+ delete[] m_strings[ihash];
	+ delete[] m_data[ihash];
	}

	- _entries[ihash]++;
	+ m_entries[ihash]++;

	- _strings[ihash] = newstrings;
	- _data[ihash] = newdata;
	+ m_strings[ihash] = newstrings;
	+ m_data[ihash] = newdata;
	}

	template <class T>
	@@ -119,9 +119,9 @@

	int i;

	- for ( i = 0; i < _entries[ihash]; i++ ) {
	- if ( *( _strings[ihash][i] ) == str )
	- return _data[ihash][i];
	+ for ( i = 0; i < m_entries[ihash]; i++ ) {
	+ if ( *( m_strings[ihash][i] ) == str )
	+ return m_data[ihash][i];
	}

	return 0;
	@@ -141,7 +141,7 @@
	i++;
	}

	- return value % _size;
	+ return value % m_size;
	}

	#endif
	diff --git a/EvtGenBase/EvtStringParticle.hh b/EvtGenBase/EvtStringParticle.hh
	--- a/EvtGenBase/EvtStringParticle.hh
	+++ b/EvtGenBase/EvtStringParticle.hh
	@@ -40,8 +40,8 @@
	double gamma ) const override;

	private:
	- std::vector<EvtVector4R> _p4partons;
	- std::vector<EvtId> _idpartons;
	+ std::vector<EvtVector4R> m_p4partons;
	+ std::vector<EvtId> m_idpartons;

	EvtStringParticle& operator=( const EvtStringParticle& d );
	};
	diff --git a/EvtGenBase/EvtSymTable.hh b/EvtGenBase/EvtSymTable.hh
	--- a/EvtGenBase/EvtSymTable.hh
	+++ b/EvtGenBase/EvtSymTable.hh
	@@ -37,7 +37,7 @@
	static std::string get( const std::string& name, int& ierr );

	private:
	- static std::map<std::string, std::string> _symMap;
	+ static std::map<std::string, std::string> m_symMap;
	};

	#endif
	diff --git a/EvtGenBase/EvtTensor3C.hh b/EvtGenBase/EvtTensor3C.hh
	--- a/EvtGenBase/EvtTensor3C.hh
	+++ b/EvtGenBase/EvtTensor3C.hh
	@@ -84,7 +84,7 @@
	EvtVector3C cont2( const EvtVector3R& v ) const;

	private:
	- EvtComplex t[3][3];
	+ EvtComplex m_t[3][3];
	};

	inline EvtTensor3C operator*( const EvtComplex& c, const EvtTensor3C& t2 )
	@@ -119,17 +119,17 @@

	inline void EvtTensor3C::set( int i, int j, const EvtComplex& c )
	{
	- t[i][j] = c;
	+ m_t[i][j] = c;
	}

	inline const EvtComplex& EvtTensor3C::get( int i, int j ) const
	{
	- return t[i][j];
	+ return m_t[i][j];
	}

	inline EvtComplex EvtTensor3C::trace() const
	{
	- return t[0][0] + t[1][1] + t[2][2];
	+ return m_t[0][0] + m_t[1][1] + m_t[2][2];
	}

	#endif
	diff --git a/EvtGenBase/EvtTensor4C.hh b/EvtGenBase/EvtTensor4C.hh
	--- a/EvtGenBase/EvtTensor4C.hh
	+++ b/EvtGenBase/EvtTensor4C.hh
	@@ -91,7 +91,7 @@
	EvtVector4C cont2( const EvtVector4R& v4 ) const;

	private:
	- EvtComplex t[4][4];
	+ EvtComplex m_t[4][4];
	};

	inline EvtTensor4C operator+( const EvtTensor4C& t1, const EvtTensor4C& t2 )
	@@ -106,17 +106,17 @@

	inline void EvtTensor4C::set( int i, int j, const EvtComplex& c )
	{
	- t[i][j] = c;
	+ m_t[i][j] = c;
	}

	inline const EvtComplex& EvtTensor4C::get( int i, int j ) const
	{
	- return t[i][j];
	+ return m_t[i][j];
	}

	inline EvtComplex EvtTensor4C::trace() const
	{
	- return t[0][0] - t[1][1] - t[2][2] - t[3][3];
	+ return m_t[0][0] - m_t[1][1] - m_t[2][2] - m_t[3][3];
	}

	#endif
	diff --git a/EvtGenBase/EvtTensorParticle.hh b/EvtGenBase/EvtTensorParticle.hh
	--- a/EvtGenBase/EvtTensorParticle.hh
	+++ b/EvtGenBase/EvtTensorParticle.hh
	@@ -44,7 +44,7 @@
	double gamma ) const override;

	private:
	- std::array<EvtTensor4C, 5> eps; //eps1,eps2,eps3,eps4,eps5;
	+ std::array<EvtTensor4C, 5> m_eps; //eps1,eps2,eps3,eps4,eps5;

	EvtTensorParticle( const EvtTensorParticle& tensor );
	EvtTensorParticle& operator=( const EvtTensorParticle& tensor );
	diff --git a/EvtGenBase/EvtTwoBodyKine.hh b/EvtGenBase/EvtTwoBodyKine.hh
	--- a/EvtGenBase/EvtTwoBodyKine.hh
	+++ b/EvtGenBase/EvtTwoBodyKine.hh
	@@ -39,9 +39,9 @@

	// Accessors

	- inline double mA() const { return _mA; }
	- inline double mB() const { return _mB; }
	- inline double mAB() const { return _mAB; }
	+ inline double mA() const { return m_mA; }
	+ inline double mB() const { return m_mB; }
	+ inline double mAB() const { return m_mAB; }
	double m( Index i ) const;

	// Momentum of the other two particles in the
	@@ -56,9 +56,9 @@
	void print( std::ostream& os ) const;

	private:
	- double _mA;
	- double _mB;
	- double _mAB;
	+ double m_mA;
	+ double m_mB;
	+ double m_mAB;
	};

	std::ostream& operator<<( std::ostream& os, const EvtTwoBodyKine& p );
	diff --git a/EvtGenBase/EvtTwoBodyVertex.hh b/EvtGenBase/EvtTwoBodyVertex.hh
	--- a/EvtGenBase/EvtTwoBodyVertex.hh
	+++ b/EvtGenBase/EvtTwoBodyVertex.hh
	@@ -40,20 +40,20 @@
	double formFactor( EvtTwoBodyKine x ) const;
	double phaseSpaceFactor( EvtTwoBodyKine x, EvtTwoBodyKine::Index ) const;

	- inline int L() const { return _LL; }
	- inline double mA() const { return _kine.mA(); }
	- inline double mB() const { return _kine.mB(); }
	- inline double mAB() const { return _kine.mAB(); }
	- inline double pD() const { return _p0; }
	+ inline int L() const { return m_LL; }
	+ inline double mA() const { return m_kine.mA(); }
	+ inline double mB() const { return m_kine.mB(); }
	+ inline double mAB() const { return m_kine.mAB(); }
	+ inline double pD() const { return m_p0; }
	void print( std::ostream& os ) const;

	void set_f( double R );

	private:
	- EvtTwoBodyKine _kine;
	- int _LL;
	- double _p0;
	- std::unique_ptr<EvtBlattWeisskopf> _f; // optional Blatt-Weisskopf form factor
	+ EvtTwoBodyKine m_kine;
	+ int m_LL;
	+ double m_p0;
	+ std::unique_ptr<EvtBlattWeisskopf> m_f; // optional Blatt-Weisskopf form factor
	};

	std::ostream& operator<<( std::ostream& os, const EvtTwoBodyVertex& v );
	diff --git a/EvtGenBase/EvtValError.hh b/EvtGenBase/EvtValError.hh
	--- a/EvtGenBase/EvtValError.hh
	+++ b/EvtGenBase/EvtValError.hh
	@@ -35,17 +35,17 @@
	EvtValError( double val, double err );
	EvtValError( const EvtValError& other );

	- inline int valueKnown() const { return _valKnown; }
	+ inline int valueKnown() const { return m_valKnown; }
	inline double value() const
	{
	- assert( _valKnown );
	- return _val;
	+ assert( m_valKnown );
	+ return m_val;
	}
	- inline int errorKnown() const { return _errKnown; }
	+ inline int errorKnown() const { return m_errKnown; }
	inline double error() const
	{
	- assert( _errKnown );
	- return _err;
	+ assert( m_errKnown );
	+ return m_err;
	}

	double prec() const;
	@@ -58,10 +58,10 @@
	void print( std::ostream& ) const;

	private:
	- int _valKnown;
	- double _val;
	- int _errKnown;
	- double _err;
	+ int m_valKnown;
	+ double m_val;
	+ int m_errKnown;
	+ double m_err;
	};

	EvtValError operator*( const EvtValError& x1, const EvtValError& x2 );
	diff --git a/EvtGenBase/EvtVector3C.hh b/EvtGenBase/EvtVector3C.hh
	--- a/EvtGenBase/EvtVector3C.hh
	+++ b/EvtGenBase/EvtVector3C.hh
	@@ -66,70 +66,70 @@
	double dot( const EvtVector3C& p2 );

	private:
	- EvtComplex v[3];
	+ EvtComplex m_v[3];
	};

	inline EvtVector3C::EvtVector3C( const EvtVector3R& v1 )
	{
	- v[0] = EvtComplex( v1.get( 0 ), 0.0 );
	- v[1] = EvtComplex( v1.get( 1 ), 0.0 );
	- v[2] = EvtComplex( v1.get( 2 ), 0.0 );
	+ m_v[0] = EvtComplex( v1.get( 0 ), 0.0 );
	+ m_v[1] = EvtComplex( v1.get( 1 ), 0.0 );
	+ m_v[2] = EvtComplex( v1.get( 2 ), 0.0 );
	}

	inline void EvtVector3C::set( const int i, const EvtComplex& c )
	{
	- v[i] = c;
	+ m_v[i] = c;
	}

	inline void EvtVector3C::set( const EvtComplex& x, const EvtComplex& y,
	const EvtComplex& z )
	{
	- v[0] = x;
	- v[1] = y;
	- v[2] = z;
	+ m_v[0] = x;
	+ m_v[1] = y;
	+ m_v[2] = z;
	}

	inline void EvtVector3C::set( double x, double y, double z )
	{
	- v[0] = EvtComplex( x );
	- v[1] = EvtComplex( y );
	- v[2] = EvtComplex( z );
	+ m_v[0] = EvtComplex( x );
	+ m_v[1] = EvtComplex( y );
	+ m_v[2] = EvtComplex( z );
	}

	inline const EvtComplex& EvtVector3C::get( int i ) const
	{
	- return v[i];
	+ return m_v[i];
	}

	inline EvtVector3C& EvtVector3C::operator*=( const EvtComplex& c )
	{
	- v[0] *= c;
	- v[1] *= c;
	- v[2] *= c;
	+ m_v[0] *= c;
	+ m_v[1] *= c;
	+ m_v[2] *= c;
	return *this;
	}

	inline EvtVector3C& EvtVector3C::operator/=( const EvtComplex& c )
	{
	- v[0] /= c;
	- v[1] /= c;
	- v[2] /= c;
	+ m_v[0] /= c;
	+ m_v[1] /= c;
	+ m_v[2] /= c;
	return *this;
	}

	inline EvtVector3C& EvtVector3C::operator+=( const EvtVector3C& v2 )
	{
	- v[0] += v2.v[0];
	- v[1] += v2.v[1];
	- v[2] += v2.v[2];
	+ m_v[0] += v2.m_v[0];
	+ m_v[1] += v2.m_v[1];
	+ m_v[2] += v2.m_v[2];
	return *this;
	}

	inline EvtVector3C& EvtVector3C::operator-=( const EvtVector3C& v2 )
	{
	- v[0] -= v2.v[0];
	- v[1] -= v2.v[1];
	- v[2] -= v2.v[2];
	+ m_v[0] -= v2.m_v[0];
	+ m_v[1] -= v2.m_v[1];
	+ m_v[2] -= v2.m_v[2];
	return *this;
	}

	@@ -160,22 +160,24 @@

	inline EvtComplex operator*( const EvtVector3R& v1, const EvtVector3C& v2 )
	{
	- return v1.get( 0 ) * v2.v[0] + v1.get( 1 ) * v2.v[1] + v1.get( 2 ) * v2.v[2];
	+ return v1.get( 0 ) * v2.m_v[0] + v1.get( 1 ) * v2.m_v[1] +
	+ v1.get( 2 ) * v2.m_v[2];
	}

	inline EvtComplex operator*( const EvtVector3C& v1, const EvtVector3R& v2 )
	{
	- return v1.v[0] * v2.get( 0 ) + v1.v[1] * v2.get( 1 ) + v1.v[2] * v2.get( 2 );
	+ return v1.m_v[0] * v2.get( 0 ) + v1.m_v[1] * v2.get( 1 ) +
	+ v1.m_v[2] * v2.get( 2 );
	}

	inline EvtComplex operator*( const EvtVector3C& v1, const EvtVector3C& v2 )
	{
	- return v1.v[0] * v2.v[0] + v1.v[1] * v2.v[1] + v1.v[2] * v2.v[2];
	+ return v1.m_v[0] * v2.m_v[0] + v1.m_v[1] * v2.m_v[1] + v1.m_v[2] * v2.m_v[2];
	}

	inline EvtVector3C EvtVector3C::conj() const
	{
	- return EvtVector3C( ::conj( v[0] ), ::conj( v[1] ), ::conj( v[2] ) );
	+ return EvtVector3C( ::conj( m_v[0] ), ::conj( m_v[1] ), ::conj( m_v[2] ) );
	}

	#endif
	diff --git a/EvtGenBase/EvtVector3R.hh b/EvtGenBase/EvtVector3R.hh
	--- a/EvtGenBase/EvtVector3R.hh
	+++ b/EvtGenBase/EvtVector3R.hh
	@@ -53,38 +53,38 @@
	double d3mag() const;

	private:
	- double v[3];
	+ double m_v[3];
	};

	inline EvtVector3R& EvtVector3R::operator*=( const double c )
	{
	- v[0] *= c;
	- v[1] *= c;
	- v[2] *= c;
	+ m_v[0] *= c;
	+ m_v[1] *= c;
	+ m_v[2] *= c;
	return *this;
	}

	inline EvtVector3R& EvtVector3R::operator/=( const double c )
	{
	- v[0] /= c;
	- v[1] /= c;
	- v[2] /= c;
	+ m_v[0] /= c;
	+ m_v[1] /= c;
	+ m_v[2] /= c;
	return *this;
	}

	inline EvtVector3R& EvtVector3R::operator+=( const EvtVector3R& v2 )
	{
	- v[0] += v2.v[0];
	- v[1] += v2.v[1];
	- v[2] += v2.v[2];
	+ m_v[0] += v2.m_v[0];
	+ m_v[1] += v2.m_v[1];
	+ m_v[2] += v2.m_v[2];
	return *this;
	}

	inline EvtVector3R& EvtVector3R::operator-=( const EvtVector3R& v2 )
	{
	- v[0] -= v2.v[0];
	- v[1] -= v2.v[1];
	- v[2] -= v2.v[2];
	+ m_v[0] -= v2.m_v[0];
	+ m_v[1] -= v2.m_v[1];
	+ m_v[2] -= v2.m_v[2];
	return *this;
	}

	@@ -105,7 +105,7 @@

	inline double operator*( const EvtVector3R& v1, const EvtVector3R& v2 )
	{
	- return v1.v[0] * v2.v[0] + v1.v[1] * v2.v[1] + v1.v[2] * v2.v[2];
	+ return v1.m_v[0] * v2.m_v[0] + v1.m_v[1] * v2.m_v[1] + v1.m_v[2] * v2.m_v[2];
	}

	inline EvtVector3R operator+( const EvtVector3R& v1, const EvtVector3R& v2 )
	@@ -120,19 +120,19 @@

	inline double EvtVector3R::get( int i ) const
	{
	- return v[i];
	+ return m_v[i];
	}

	inline void EvtVector3R::set( int i, double d )
	{
	- v[i] = d;
	+ m_v[i] = d;
	}

	inline void EvtVector3R::set( double x, double y, double z )
	{
	- v[0] = x;
	- v[1] = y;
	- v[2] = z;
	+ m_v[0] = x;
	+ m_v[1] = y;
	+ m_v[2] = z;
	}

	#endif
	diff --git a/EvtGenBase/EvtVector4C.hh b/EvtGenBase/EvtVector4C.hh
	--- a/EvtGenBase/EvtVector4C.hh
	+++ b/EvtGenBase/EvtVector4C.hh
	@@ -67,7 +67,7 @@
	double dot( const EvtVector4C& p2 );

	private:
	- EvtComplex v[4];
	+ EvtComplex m_v[4];
	};

	EvtVector4C rotateEuler( const EvtVector4C& e, double alpha, double beta,
	@@ -77,54 +77,54 @@

	inline EvtVector4C& EvtVector4C::operator+=( const EvtVector4C& v2 )
	{
	- v[0] += v2.v[0];
	- v[1] += v2.v[1];
	- v[2] += v2.v[2];
	- v[3] += v2.v[3];
	+ m_v[0] += v2.m_v[0];
	+ m_v[1] += v2.m_v[1];
	+ m_v[2] += v2.m_v[2];
	+ m_v[3] += v2.m_v[3];

	return *this;
	}

	inline EvtVector4C& EvtVector4C::operator-=( const EvtVector4C& v2 )
	{
	- v[0] -= v2.v[0];
	- v[1] -= v2.v[1];
	- v[2] -= v2.v[2];
	- v[3] -= v2.v[3];
	+ m_v[0] -= v2.m_v[0];
	+ m_v[1] -= v2.m_v[1];
	+ m_v[2] -= v2.m_v[2];
	+ m_v[3] -= v2.m_v[3];

	return *this;
	}

	inline void EvtVector4C::set( int i, const EvtComplex& c )
	{
	- v[i] = c;
	+ m_v[i] = c;
	}

	inline EvtVector3C EvtVector4C::vec() const
	{
	- return EvtVector3C( v[1], v[2], v[3] );
	+ return EvtVector3C( m_v[1], m_v[2], m_v[3] );
	}

	inline void EvtVector4C::set( const EvtComplex& e, const EvtComplex& p1,
	const EvtComplex& p2, const EvtComplex& p3 )
	{
	- v[0] = e;
	- v[1] = p1;
	- v[2] = p2;
	- v[3] = p3;
	+ m_v[0] = e;
	+ m_v[1] = p1;
	+ m_v[2] = p2;
	+ m_v[3] = p3;
	}

	inline void EvtVector4C::set( double e, double p1, double p2, double p3 )
	{
	- v[0] = EvtComplex( e );
	- v[1] = EvtComplex( p1 );
	- v[2] = EvtComplex( p2 );
	- v[3] = EvtComplex( p3 );
	+ m_v[0] = EvtComplex( e );
	+ m_v[1] = EvtComplex( p1 );
	+ m_v[2] = EvtComplex( p2 );
	+ m_v[3] = EvtComplex( p3 );
	}

	inline const EvtComplex& EvtVector4C::get( int i ) const
	{
	- return v[i];
	+ return m_v[i];
	}

	inline EvtVector4C operator+( const EvtVector4C& v1, const EvtVector4C& v2 )
	@@ -139,22 +139,24 @@

	inline EvtComplex EvtVector4C::cont( const EvtVector4C& v4 ) const
	{
	- return v[0] * v4.v[0] - v[1] * v4.v[1] - v[2] * v4.v[2] - v[3] * v4.v[3];
	+ return m_v[0] * v4.m_v[0] - m_v[1] * v4.m_v[1] - m_v[2] * v4.m_v[2] -
	+ m_v[3] * v4.m_v[3];
	}

	inline EvtVector4C& EvtVector4C::operator*=( const EvtComplex& c )
	{
	- v[0] *= c;
	- v[1] *= c;
	- v[2] *= c;
	- v[3] *= c;
	+ m_v[0] *= c;
	+ m_v[1] *= c;
	+ m_v[2] *= c;
	+ m_v[3] *= c;

	return *this;
	}

	inline EvtVector4C operator*( double d, const EvtVector4C& v2 )
	{
	- return EvtVector4C( v2.v[0] * d, v2.v[1] * d, v2.v[2] * d, v2.v[3] * d );
	+ return EvtVector4C( v2.m_v[0] * d, v2.m_v[1] * d, v2.m_v[2] * d,
	+ v2.m_v[3] * d );
	}

	inline EvtVector4C operator*( const EvtComplex& c, const EvtVector4C& v2 )
	@@ -175,34 +177,34 @@

	inline EvtVector4C::EvtVector4C( const EvtVector4R& v1 )
	{
	- v[0] = EvtComplex( v1.get( 0 ) );
	- v[1] = EvtComplex( v1.get( 1 ) );
	- v[2] = EvtComplex( v1.get( 2 ) );
	- v[3] = EvtComplex( v1.get( 3 ) );
	+ m_v[0] = EvtComplex( v1.get( 0 ) );
	+ m_v[1] = EvtComplex( v1.get( 1 ) );
	+ m_v[2] = EvtComplex( v1.get( 2 ) );
	+ m_v[3] = EvtComplex( v1.get( 3 ) );
	}

	inline EvtComplex operator*( const EvtVector4R& v1, const EvtVector4C& v2 )
	{
	- return v1.get( 0 ) * v2.v[0] - v1.get( 1 ) * v2.v[1] -
	- v1.get( 2 ) * v2.v[2] - v1.get( 3 ) * v2.v[3];
	+ return v1.get( 0 ) * v2.m_v[0] - v1.get( 1 ) * v2.m_v[1] -
	+ v1.get( 2 ) * v2.m_v[2] - v1.get( 3 ) * v2.m_v[3];
	}

	inline EvtComplex operator*( const EvtVector4C& v1, const EvtVector4R& v2 )
	{
	- return v1.v[0] * v2.get( 0 ) - v1.v[1] * v2.get( 1 ) -
	- v1.v[2] * v2.get( 2 ) - v1.v[3] * v2.get( 3 );
	+ return v1.m_v[0] * v2.get( 0 ) - v1.m_v[1] * v2.get( 1 ) -
	+ v1.m_v[2] * v2.get( 2 ) - v1.m_v[3] * v2.get( 3 );
	}

	inline EvtComplex operator*( const EvtVector4C& v1, const EvtVector4C& v2 )
	{
	- return v1.v[0] * v2.v[0] - v1.v[1] * v2.v[1] - v1.v[2] * v2.v[2] -
	- v1.v[3] * v2.v[3];
	+ return v1.m_v[0] * v2.m_v[0] - v1.m_v[1] * v2.m_v[1] -
	+ v1.m_v[2] * v2.m_v[2] - v1.m_v[3] * v2.m_v[3];
	}

	inline EvtVector4C EvtVector4C::conj() const
	{
	- return EvtVector4C( ::conj( v[0] ), ::conj( v[1] ), ::conj( v[2] ),
	- ::conj( v[3] ) );
	+ return EvtVector4C( ::conj( m_v[0] ), ::conj( m_v[1] ), ::conj( m_v[2] ),
	+ ::conj( m_v[3] ) );
	}

	#endif
	diff --git a/EvtGenBase/EvtVector4R.hh b/EvtGenBase/EvtVector4R.hh
	--- a/EvtGenBase/EvtVector4R.hh
	+++ b/EvtGenBase/EvtVector4R.hh
	@@ -65,7 +65,7 @@
	double magr3( const EvtVector4R& p1 ) const;

	private:
	- double v[4];
	+ double m_v[4];

	inline double Square( double x ) const { return x * x; }
	};
	@@ -79,27 +79,27 @@

	inline EvtVector4R& EvtVector4R::operator+=( const EvtVector4R& v2 )
	{
	- v[0] += v2.v[0];
	- v[1] += v2.v[1];
	- v[2] += v2.v[2];
	- v[3] += v2.v[3];
	+ m_v[0] += v2.m_v[0];
	+ m_v[1] += v2.m_v[1];
	+ m_v[2] += v2.m_v[2];
	+ m_v[3] += v2.m_v[3];

	return *this;
	}

	inline EvtVector4R& EvtVector4R::operator-=( const EvtVector4R& v2 )
	{
	- v[0] -= v2.v[0];
	- v[1] -= v2.v[1];
	- v[2] -= v2.v[2];
	- v[3] -= v2.v[3];
	+ m_v[0] -= v2.m_v[0];
	+ m_v[1] -= v2.m_v[1];
	+ m_v[2] -= v2.m_v[2];
	+ m_v[3] -= v2.m_v[3];

	return *this;
	}

	inline double EvtVector4R::mass2() const
	{
	- return v[0] * v[0] - v[1] * v[1] - v[2] * v[2] - v[3] * v[3];
	+ return m_v[0] * m_v[0] - m_v[1] * m_v[1] - m_v[2] * m_v[2] - m_v[3] * m_v[3];
	}

	inline EvtVector4R operator*( double c, const EvtVector4R& v2 )
	@@ -119,10 +119,10 @@

	inline EvtVector4R& EvtVector4R::operator*=( double c )
	{
	- v[0] *= c;
	- v[1] *= c;
	- v[2] *= c;
	- v[3] *= c;
	+ m_v[0] *= c;
	+ m_v[1] *= c;
	+ m_v[2] *= c;
	+ m_v[3] *= c;

	return *this;
	}
	@@ -130,23 +130,24 @@
	inline EvtVector4R& EvtVector4R::operator/=( double c )
	{
	double cinv = 1.0 / c;
	- v[0] *= cinv;
	- v[1] *= cinv;
	- v[2] *= cinv;
	- v[3] *= cinv;
	+ m_v[0] *= cinv;
	+ m_v[1] *= cinv;
	+ m_v[2] *= cinv;
	+ m_v[3] *= cinv;

	return *this;
	}

	inline double operator*( const EvtVector4R& v1, const EvtVector4R& v2 )
	{
	- return v1.v[0] * v2.v[0] - v1.v[1] * v2.v[1] - v1.v[2] * v2.v[2] -
	- v1.v[3] * v2.v[3];
	+ return v1.m_v[0] * v2.m_v[0] - v1.m_v[1] * v2.m_v[1] -
	+ v1.m_v[2] * v2.m_v[2] - v1.m_v[3] * v2.m_v[3];
	}

	inline double EvtVector4R::cont( const EvtVector4R& v4 ) const
	{
	- return v[0] * v4.v[0] - v[1] * v4.v[1] - v[2] * v4.v[2] - v[3] * v4.v[3];
	+ return m_v[0] * v4.m_v[0] - m_v[1] * v4.m_v[1] - m_v[2] * v4.m_v[2] -
	+ m_v[3] * v4.m_v[3];
	}

	inline EvtVector4R operator-( const EvtVector4R& v1, const EvtVector4R& v2 )
	@@ -161,20 +162,20 @@

	inline double EvtVector4R::get( int i ) const
	{
	- return v[i];
	+ return m_v[i];
	}

	inline void EvtVector4R::set( int i, double d )
	{
	- v[i] = d;
	+ m_v[i] = d;
	}

	inline void EvtVector4R::set( double e, double p1, double p2, double p3 )
	{
	- v[0] = e;
	- v[1] = p1;
	- v[2] = p2;
	- v[3] = p3;
	+ m_v[0] = e;
	+ m_v[1] = p1;
	+ m_v[2] = p2;
	+ m_v[3] = p3;
	}

	#endif
	diff --git a/EvtGenBase/EvtVectorParticle.hh b/EvtGenBase/EvtVectorParticle.hh
	--- a/EvtGenBase/EvtVectorParticle.hh
	+++ b/EvtGenBase/EvtVectorParticle.hh
	@@ -40,22 +40,22 @@
	const EvtVector4C&, const EvtVector4C& );
	EvtVector4C epsParent( int i ) const override
	{
	- assert( i >= 0 && i < _eps.size() );
	+ assert( i >= 0 && i < m_eps.size() );

	- return boostTo( _eps[i], this->getP4() );
	+ return boostTo( m_eps[i], this->getP4() );
	}
	EvtVector4C eps( int i ) const override
	{
	- assert( i >= 0 && i < _eps.size() );
	+ assert( i >= 0 && i < m_eps.size() );

	- return _eps[i];
	+ return m_eps[i];
	}
	EvtSpinDensity rotateToHelicityBasis() const override;
	EvtSpinDensity rotateToHelicityBasis( double alpha, double beta,
	double gamma ) const override;

	private:
	- std::array<EvtVector4C, 3> _eps;
	+ std::array<EvtVector4C, 3> m_eps;

	EvtVectorParticle( const EvtVectorParticle& vector );
	EvtVectorParticle& operator=( const EvtVectorParticle& vector );
	diff --git a/EvtGenBase/EvtdFunctionSingle.hh b/EvtGenBase/EvtdFunctionSingle.hh
	--- a/EvtGenBase/EvtdFunctionSingle.hh
	+++ b/EvtGenBase/EvtdFunctionSingle.hh
	@@ -35,14 +35,14 @@
	private:
	int fact( int n );

	- int _j;
	- int _m1;
	- int _m2;
	+ int m_j;
	+ int m_m1;
	+ int m_m2;

	- double* _coef;
	+ double* m_coef;

	- int _kmin;
	- int _kmax;
	+ int m_kmin;
	+ int m_kmax;
	};

	#endif
	diff --git a/EvtGenExternal/EvtExternalGenFactory.hh b/EvtGenExternal/EvtExternalGenFactory.hh
	--- a/EvtGenExternal/EvtExternalGenFactory.hh
	+++ b/EvtGenExternal/EvtExternalGenFactory.hh
	@@ -30,7 +30,7 @@

	class EvtExternalGenFactory {
	public:
	- enum genId
	+ enum GenId
	{
	PythiaGenId = 0,
	TauolaGenId
	@@ -38,7 +38,7 @@

	static EvtExternalGenFactory* getInstance();

	- EvtAbsExternalGen* getGenerator( int genId = 0 );
	+ EvtAbsExternalGen* getGenerator( GenId genId = GenId::PythiaGenId );

	void initialiseAllGenerators();

	@@ -54,14 +54,14 @@
	EvtExternalGenFactory();
	~EvtExternalGenFactory();

	- typedef std::map<int, EvtAbsExternalGen*> ExtGenMap;
	- typedef std::map<int, std::map<std::string, std::vector<std::string>>> ExtGenCommandMap;
	+ typedef std::map<GenId, EvtAbsExternalGen*> ExtGenMap;
	+ //typedef std::map<GenId, std::map<std::string, std::vector<std::string>>> ExtGenCommandMap;

	private:
	EvtExternalGenFactory( const EvtExternalGenFactory& ){};

	- ExtGenMap _extGenMap;
	- ExtGenCommandMap _extGenCommandMap;
	+ ExtGenMap m_extGenMap;
	+ //ExtGenCommandMap m_extGenCommandMap;
	};

	#endif
	diff --git a/EvtGenExternal/EvtPHOTOS.hh b/EvtGenExternal/EvtPHOTOS.hh
	--- a/EvtGenExternal/EvtPHOTOS.hh
	+++ b/EvtGenExternal/EvtPHOTOS.hh
	@@ -75,7 +75,7 @@

	bool m_initialised = false;

	- static std::mutex photos_mutex;
	+ static std::mutex m_photos_mutex;
	};

	#endif
	diff --git a/EvtGenExternal/EvtPythia.hh b/EvtGenExternal/EvtPythia.hh
	--- a/EvtGenExternal/EvtPythia.hh
	+++ b/EvtGenExternal/EvtPythia.hh
	@@ -53,11 +53,11 @@
	void command( std::string ) override;

	protected:
	- EvtAbsExternalGen* _pythiaEngine;
	+ EvtAbsExternalGen* m_pythiaEngine;

	private:
	void fixPolarisations( EvtParticle* p );
	- std::vector<std::string> _commandList;
	+ std::vector<std::string> m_commandList;
	};

	#endif
	diff --git a/EvtGenExternal/EvtPythiaEngine.hh b/EvtGenExternal/EvtPythiaEngine.hh
	--- a/EvtGenExternal/EvtPythiaEngine.hh
	+++ b/EvtGenExternal/EvtPythiaEngine.hh
	@@ -70,21 +70,21 @@

	int getModeInt( EvtDecayBase* decayModel );

	- std::unique_ptr<Pythia8::Pythia> _genericPythiaGen;
	- std::unique_ptr<Pythia8::Pythia> _aliasPythiaGen;
	- Pythia8::Pythia* _thePythiaGenerator;
	+ std::unique_ptr<Pythia8::Pythia> m_genericPythiaGen;
	+ std::unique_ptr<Pythia8::Pythia> m_aliasPythiaGen;
	+ Pythia8::Pythia* m_thePythiaGenerator;

	- std::vector<int> _daugPDGVector;
	- std::vector<EvtVector4R> _daugP4Vector;
	+ std::vector<int> m_daugPDGVector;
	+ std::vector<EvtVector4R> m_daugP4Vector;

	typedef std::map<int, std::vector<int>> PythiaModeMap;
	- PythiaModeMap _pythiaModeMap;
	+ PythiaModeMap m_pythiaModeMap;

	- bool _convertPhysCodes, _initialised, _useEvtGenRandom;
	+ bool m_convertPhysCodes, m_initialised, m_useEvtGenRandom;

	- std::shared_ptr<EvtPythiaRandom> _evtgenRandom;
	+ std::shared_ptr<EvtPythiaRandom> m_evtgenRandom;

	- std::map<int, int> _addedPDGCodes;
	+ std::map<int, int> m_addedPDGCodes;
	};

	#endif
	diff --git a/EvtGenExternal/EvtTauola.hh b/EvtGenExternal/EvtTauola.hh
	--- a/EvtGenExternal/EvtTauola.hh
	+++ b/EvtGenExternal/EvtTauola.hh
	@@ -41,7 +41,7 @@
	void decay( EvtParticle* p ) override;

	protected:
	- EvtAbsExternalGen* _tauolaEngine = nullptr;
	+ EvtAbsExternalGen* m_tauolaEngine = nullptr;

	private:
	};
	diff --git a/EvtGenExternal/EvtTauolaEngine.hh b/EvtGenExternal/EvtTauolaEngine.hh
	--- a/EvtGenExternal/EvtTauolaEngine.hh
	+++ b/EvtGenExternal/EvtTauolaEngine.hh
	@@ -58,9 +58,9 @@

	protected:
	private:
	- bool _initialised;
	- int _tauPDG, _nTauolaModes;
	- int _neutPropType, _posPropType, _negPropType;
	+ bool m_initialised;
	+ int m_tauPDG, m_nTauolaModes;
	+ int m_neutPropType, m_posPropType, m_negPropType;

	GenParticlePtr createGenParticle( EvtParticle* theParticle );

	diff --git a/EvtGenModels/EvtBBScalar.hh b/EvtGenModels/EvtBBScalar.hh
	--- a/EvtGenModels/EvtBBScalar.hh
	+++ b/EvtGenModels/EvtBBScalar.hh
	@@ -40,25 +40,6 @@
	// hep-ph/0204185, hep-ph/0211240
	// This model is intended to be applicable to all decays of the type B-> baryon baryon scalar

	-struct FormFactor {
	- double value;
	- double sigma1;
	- double sigma2;
	- double mV;
	-};
	-
	-enum Baryons
	-{
	- Lambda,
	- Proton,
	- Neutron,
	- Sigma0,
	- Sigma_minus,
	- Xi0,
	- Xi_minus,
	- nBaryons
	-};
	-
	class EvtBBScalar : public EvtDecayAmp {
	public:
	EvtBBScalar();
	@@ -69,31 +50,50 @@
	void initProbMax() override;

	private:
	+ struct FormFactor {
	+ double m_value;
	+ double m_sigma1;
	+ double m_sigma2;
	+ double m_mV;
	+ };
	+
	+ enum Baryons
	+ {
	+ Lambda,
	+ Proton,
	+ Neutron,
	+ Sigma0,
	+ Sigma_minus,
	+ Xi0,
	+ Xi_minus,
	+ nBaryons
	+ };
	+
	// used values of constants
	- static const EvtComplex I;
	- static const EvtComplex V_ub;
	- static const EvtComplex V_us_star;
	- static const EvtComplex a1;
	- static const EvtComplex V_tb;
	- static const EvtComplex V_ts_star;
	- static const EvtComplex a4;
	- static const EvtComplex a6;
	+ static const EvtComplex m_I;
	+ static const EvtComplex m_V_ub;
	+ static const EvtComplex m_V_us_star;
	+ static const EvtComplex m_a1;
	+ static const EvtComplex m_V_tb;
	+ static const EvtComplex m_V_ts_star;
	+ static const EvtComplex m_a4;
	+ static const EvtComplex m_a6;

	// used parameters in the calculation of the magnetic form factors
	- static const double x[];
	- static const double y[];
	+ static const double m_x[];
	+ static const double m_y[];
	// quark masses as used in the model
	- static const double m_s;
	- static const double m_u;
	- static const double m_b;
	+ static const double m_ms;
	+ static const double m_mu;
	+ static const double m_mb;

	- // used to choose the right value for the form factor depending on the type of scalar
	- std::string _scalarType;
	- mutable std::map<std::string, FormFactor> _f0Map;
	- mutable std::map<std::string, FormFactor> _f1Map;
	+ // used to choose the right m_value for the form factor depending on the type of scalar
	+ std::string m_scalarType;
	+ mutable std::map<std::string, FormFactor> m_f0Map;
	+ mutable std::map<std::string, FormFactor> m_f1Map;

	// only consider F1+F2 here
	- std::bitset<nBaryons> _baryonCombination;
	+ std::bitset<nBaryons> m_baryonCombination;
	void setKnownBaryonTypes( const EvtId& baryon );

	double B_pi_f1( double t ) const;
	@@ -115,12 +115,12 @@
	double F_S( double t ) const;

	// (mB1 - mB2)/(mq1 - mq1)
	- double _massRatio;
	- double _baryonMassSum;
	+ double m_massRatio;
	+ double m_baryonMassSum;
	double formFactorFit( double t, const std::vector<double>& params ) const;

	- static const EvtComplex const_B;
	- static const EvtComplex const_C;
	+ static const EvtComplex m_const_B;
	+ static const EvtComplex m_const_C;
	const EvtVector4C amp_A( const EvtVector4R& p4B, const EvtVector4R& p4Scalar );
	const EvtComplex amp_B( const EvtDiracParticle* baryon1,
	const EvtDiracSpinor& b1Pol,
	diff --git a/EvtGenModels/EvtBCSFF.hh b/EvtGenModels/EvtBCSFF.hh
	--- a/EvtGenModels/EvtBCSFF.hh
	+++ b/EvtGenModels/EvtBCSFF.hh
	@@ -49,8 +49,8 @@
	double, double, double, double, double* ) override;

	private:
	- int idScalar, whichfit;
	- double MBc, MD0;
	+ int m_idScalar, m_whichfit;
	+ double m_MBc, m_MD0;
	};

	#endif
	diff --git a/EvtGenModels/EvtBCTFF.hh b/EvtGenModels/EvtBCTFF.hh
	--- a/EvtGenModels/EvtBCTFF.hh
	+++ b/EvtGenModels/EvtBCTFF.hh
	@@ -49,8 +49,8 @@
	double, double, double, double, double* ) override;

	private:
	- int idTensor, whichfit;
	- double MBc;
	+ int m_idTensor, m_whichfit;
	+ double m_MBc;
	};

	#endif
	diff --git a/EvtGenModels/EvtBCVFF.hh b/EvtGenModels/EvtBCVFF.hh
	--- a/EvtGenModels/EvtBCVFF.hh
	+++ b/EvtGenModels/EvtBCVFF.hh
	@@ -49,8 +49,8 @@
	double, double, double, double, double* ) override;

	private:
	- int idVector, whichfit;
	- double MBc, MD0, Mpsi, Mpsi2S, kappa, Mchi;
	+ int m_idVector, m_whichfit;
	+ double m_MBc, m_MD0, m_Mpsi, m_Mpsi2S, m_kappa, m_Mchi;
	};

	#endif
	diff --git a/EvtGenModels/EvtBCVFF2.hh b/EvtGenModels/EvtBCVFF2.hh
	--- a/EvtGenModels/EvtBCVFF2.hh
	+++ b/EvtGenModels/EvtBCVFF2.hh
	@@ -58,7 +58,7 @@
	double, double, double, double, double* ) override;

	private:
	- int idVector, whichfit;
	+ int m_idVector, m_whichfit;
	};

	#endif
	diff --git a/EvtGenModels/EvtBLLNuL.hh b/EvtGenModels/EvtBLLNuL.hh
	--- a/EvtGenModels/EvtBLLNuL.hh
	+++ b/EvtGenModels/EvtBLLNuL.hh
	@@ -46,7 +46,7 @@
	virtual void decay( EvtParticle* p ) override;

	private:
	- EvtBLLNuLAmp calcAmp_;
	+ EvtBLLNuLAmp m_calcAmp;
	};

	#endif
	diff --git a/EvtGenModels/EvtBLLNuLAmp.hh b/EvtGenModels/EvtBLLNuLAmp.hh
	--- a/EvtGenModels/EvtBLLNuLAmp.hh
	+++ b/EvtGenModels/EvtBLLNuLAmp.hh
	@@ -51,18 +51,18 @@

	EvtComplex propagator( double qSq, int numForm = 0 ) const;

	- double getMass() const { return m0_; }
	- double getMassSq() const { return m0Sq_; }
	- double getWidth() const { return w0_; }
	- double getCoupling() const { return c_; }
	+ double getMass() const { return m_m0; }
	+ double getMassSq() const { return m_m0Sq; }
	+ double getWidth() const { return m_w0; }
	+ double getCoupling() const { return m_c; }

	private:
	- double m0_; // pole mass
	- double m0Sq_;
	- double w0_; // width
	- double c_; // coupling constant
	- EvtComplex I_;
	- EvtComplex Imw_;
	+ double m_m0; // pole mass
	+ double m_m0Sq;
	+ double m_w0; // width
	+ double m_c; // coupling constant
	+ EvtComplex m_I;
	+ EvtComplex m_Imw;
	};

	protected:
	@@ -84,35 +84,35 @@

	private:
	// Kinematic cut-offs
	- double qSqMin_;
	- double kSqMin_;
	+ double m_qSqMin;
	+ double m_kSqMin;

	// If we have identical charged lepton flavours
	- bool symmetry_;
	+ bool m_symmetry;

	// B+, B- Ids
	- EvtId BpId_, BnId_;
	+ EvtId m_BpId, m_BnId;

	// Form factor constants
	- double coupling_, sqrt2_;
	- double fBu_;
	+ double m_coupling, m_sqrt2;
	+ double m_fBu;

	// Resonance poles
	- EvtBLLNuLAmp::ResPole Bstar_, Upsilon_;
	+ EvtBLLNuLAmp::ResPole m_Bstar, m_Upsilon;

	- std::vector<EvtBLLNuLAmp::ResPole> resPoles_;
	- int nPoles_;
	+ std::vector<EvtBLLNuLAmp::ResPole> m_resPoles;
	+ int m_nPoles;

	// Complex number constants
	- EvtComplex zero_, unitI_;
	+ EvtComplex m_zero, m_unitI;
	};

	inline void EvtBLLNuLAmp::setParameters( double qSqMin, double kSqMin,
	bool symmetry )
	{
	- qSqMin_ = qSqMin;
	- kSqMin_ = kSqMin;
	- symmetry_ = symmetry;
	+ m_qSqMin = qSqMin;
	+ m_kSqMin = kSqMin;
	+ m_symmetry = symmetry;
	}

	#endif
	diff --git a/EvtGenModels/EvtBTo3hCP.hh b/EvtGenModels/EvtBTo3hCP.hh
	--- a/EvtGenModels/EvtBTo3hCP.hh
	+++ b/EvtGenModels/EvtBTo3hCP.hh
	@@ -91,29 +91,29 @@
	double h( double s );
	double dh_ds( double s );

	- EvtComplex Mat_S1, Mat_S2, Mat_S3, Mat_S4, Mat_S5, Nat_S1, Nat_S2, Nat_S3,
	- Nat_S4, Nat_S5, MatKstarp, MatKstar0, MatKrho, NatKstarp, NatKstar0,
	- NatKrho;
	- double alphaCP = 1.365;
	- double betaCP = 0.362;
	- double MA2 = 27.927981186;
	- double MB2 = 27.929242450;
	- double MC2 = 28.153482608;
	- double pi = 3.141592653;
	- double Mass_rho = 0.770;
	- double Gam_rho = 0.150;
	- double M_B = 5.2794;
	- double M_pip = 0.13957;
	- double M_pim = 0.13957;
	- double M_pi0 = 0.134976;
	- double M_Kp = 0.49368;
	- double Mass_Kstarp = 0.8916;
	- double Mass_Kstar0 = 0.8961;
	- double Gam_Kstarp = 0.0498;
	- double Gam_Kstar0 = 0.0505;
	+ EvtComplex m_Mat_S1, m_Mat_S2, m_Mat_S3, m_Mat_S4, m_Mat_S5, m_Nat_S1,
	+ m_Nat_S2, m_Nat_S3, m_Nat_S4, m_Nat_S5, m_MatKstarp, m_MatKstar0,
	+ m_MatKrho, m_NatKstarp, m_NatKstar0, m_NatKrho;
	+ double m_alphaCP = 1.365;
	+ double m_betaCP = 0.362;
	+ double m_MA2 = 27.927981186;
	+ double m_MB2 = 27.929242450;
	+ double m_MC2 = 28.153482608;
	+ double m_pi = 3.141592653;
	+ double m_Mass_rho = 0.770;
	+ double m_Gam_rho = 0.150;
	+ double m_M_B = 5.2794;
	+ double m_M_pip = 0.13957;
	+ double m_M_pim = 0.13957;
	+ double m_M_pi0 = 0.134976;
	+ double m_M_Kp = 0.49368;
	+ double m_Mass_Kstarp = 0.8916;
	+ double m_Mass_Kstar0 = 0.8961;
	+ double m_Gam_Kstarp = 0.0498;
	+ double m_Gam_Kstar0 = 0.0505;

	- double rotMatrix[3][3];
	- double factor_max = 1;
	+ double m_rotMatrix[3][3];
	+ double m_factor_max = 1;
	};

	#endif
	diff --git a/EvtGenModels/EvtBTo3piCP.hh b/EvtGenModels/EvtBTo3piCP.hh
	--- a/EvtGenModels/EvtBTo3piCP.hh
	+++ b/EvtGenModels/EvtBTo3piCP.hh
	@@ -41,7 +41,7 @@
	void decay( EvtParticle* p ) override;

	private:
	- EvtBTo3hCP generator;
	+ EvtBTo3hCP m_generator;
	};

	#endif
	diff --git a/EvtGenModels/EvtBToDDalitzCPK.hh b/EvtGenModels/EvtBToDDalitzCPK.hh
	--- a/EvtGenModels/EvtBToDDalitzCPK.hh
	+++ b/EvtGenModels/EvtBToDDalitzCPK.hh
	@@ -43,6 +43,6 @@
	void initProbMax() override;

	private:
	- int _flag;
	+ int m_flag;
	};
	#endif // EVTGENMODELS_EVTBTODDALITZCPK_HH
	diff --git a/EvtGenModels/EvtBToDiBaryonlnupQCD.hh b/EvtGenModels/EvtBToDiBaryonlnupQCD.hh
	--- a/EvtGenModels/EvtBToDiBaryonlnupQCD.hh
	+++ b/EvtGenModels/EvtBToDiBaryonlnupQCD.hh
	@@ -45,8 +45,8 @@
	void init() override;

	private:
	- std::unique_ptr<EvtBToDiBaryonlnupQCDFF> ffModel_;
	- std::unique_ptr<EvtSLDiBaryonAmp> calcAmp_;
	+ std::unique_ptr<EvtBToDiBaryonlnupQCDFF> m_ffModel;
	+ std::unique_ptr<EvtSLDiBaryonAmp> m_calcAmp;
	};

	#endif
	diff --git a/EvtGenModels/EvtBToDiBaryonlnupQCDFF.hh b/EvtGenModels/EvtBToDiBaryonlnupQCDFF.hh
	--- a/EvtGenModels/EvtBToDiBaryonlnupQCDFF.hh
	+++ b/EvtGenModels/EvtBToDiBaryonlnupQCDFF.hh
	@@ -31,8 +31,8 @@
	public:
	class FormFactors final {
	public:
	- double F1, F2, F3, F4, F5;
	- double G1, G2, G3, G4, G5;
	+ double m_F1, m_F2, m_F3, m_F4, m_F5;
	+ double m_G1, m_G2, m_G3, m_G4, m_G5;
	};

	EvtBToDiBaryonlnupQCDFF();
	@@ -49,8 +49,8 @@
	EvtBToDiBaryonlnupQCDFF::FormFactors& FF ) const;

	private:
	- std::vector<double> DPars;
	- int nDPars;
	+ std::vector<double> m_DPars;
	+ int m_nDPars;
	};

	#endif
	diff --git a/EvtGenModels/EvtBToKpipiCP.hh b/EvtGenModels/EvtBToKpipiCP.hh
	--- a/EvtGenModels/EvtBToKpipiCP.hh
	+++ b/EvtGenModels/EvtBToKpipiCP.hh
	@@ -51,7 +51,7 @@
	void decay( EvtParticle* p ) override;

	private:
	- EvtBTo3hCP generator;
	+ EvtBTo3hCP m_generator;
	};

	#endif
	diff --git a/EvtGenModels/EvtBToPlnuBK.hh b/EvtGenModels/EvtBToPlnuBK.hh
	--- a/EvtGenModels/EvtBToPlnuBK.hh
	+++ b/EvtGenModels/EvtBToPlnuBK.hh
	@@ -43,8 +43,8 @@
	void decay( EvtParticle* p ) override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> BKmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_BKmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtBToPlnuBKFF.hh b/EvtGenModels/EvtBToPlnuBKFF.hh
	--- a/EvtGenModels/EvtBToPlnuBKFF.hh
	+++ b/EvtGenModels/EvtBToPlnuBKFF.hh
	@@ -51,8 +51,8 @@
	double, double, double, double, double* ) override;

	private:
	- double _alpha;
	- double _beta;
	+ double m_alpha;
	+ double m_beta;
	};

	#endif
	diff --git a/EvtGenModels/EvtBToVlnuBall.hh b/EvtGenModels/EvtBToVlnuBall.hh
	--- a/EvtGenModels/EvtBToVlnuBall.hh
	+++ b/EvtGenModels/EvtBToVlnuBall.hh
	@@ -42,7 +42,7 @@
	void init() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> _Ballmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> _calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_Ballmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	};
	#endif
	diff --git a/EvtGenModels/EvtBToVlnuBallFF.hh b/EvtGenModels/EvtBToVlnuBallFF.hh
	--- a/EvtGenModels/EvtBToVlnuBallFF.hh
	+++ b/EvtGenModels/EvtBToVlnuBallFF.hh
	@@ -52,14 +52,14 @@
	double, double, double, double, double* ) override;

	private:
	- double _r2_A1;
	- double _mfit2_A1;
	- double _r1_A2;
	- double _r2_A2;
	- double _mfit2_A2;
	- double _r1_V;
	- double _r2_V;
	- double _mfit2_V;
	+ double m_r2_A1;
	+ double m_mfit2_A1;
	+ double m_r1_A2;
	+ double m_r2_A2;
	+ double m_mfit2_A2;
	+ double m_r1_V;
	+ double m_r2_V;
	+ double m_mfit2_V;
	};

	#endif
	diff --git a/EvtGenModels/EvtBaryonPCR.hh b/EvtGenModels/EvtBaryonPCR.hh
	--- a/EvtGenModels/EvtBaryonPCR.hh
	+++ b/EvtGenModels/EvtBaryonPCR.hh
	@@ -43,8 +43,8 @@
	void init() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> baryonpcrffmodel;
	- std::unique_ptr<EvtSemiLeptonicBaryonAmp> calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_baryonpcrffmodel;
	+ std::unique_ptr<EvtSemiLeptonicBaryonAmp> m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtBcSMuNu.hh b/EvtGenModels/EvtBcSMuNu.hh
	--- a/EvtGenModels/EvtBcSMuNu.hh
	+++ b/EvtGenModels/EvtBcSMuNu.hh
	@@ -44,10 +44,10 @@
	void initProbMax() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> ffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	- int whichfit;
	- int idScalar;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_ffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	+ int m_whichfit;
	+ int m_idScalar;
	};

	#endif
	diff --git a/EvtGenModels/EvtBcTMuNu.hh b/EvtGenModels/EvtBcTMuNu.hh
	--- a/EvtGenModels/EvtBcTMuNu.hh
	+++ b/EvtGenModels/EvtBcTMuNu.hh
	@@ -42,10 +42,10 @@
	void initProbMax() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> ffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	- int whichfit;
	- int idTensor;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_ffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	+ int m_whichfit;
	+ int m_idTensor;
	};

	#endif
	diff --git a/EvtGenModels/EvtBcToNPi.hh b/EvtGenModels/EvtBcToNPi.hh
	--- a/EvtGenModels/EvtBcToNPi.hh
	+++ b/EvtGenModels/EvtBcToNPi.hh
	@@ -46,30 +46,30 @@
	void decay( EvtParticle* p ) override;

	protected:
	- int nCall;
	- double maxAmp2;
	+ int m_nCall;
	+ double m_maxAmp2;

	// Bc form factors
	- double _maxProb;
	- double FA0_N, FA0_c1, FA0_c2;
	- double FAm_N, FAm_c1, FAm_c2;
	- double FAp_N, FAp_c1, FAp_c2;
	- double FV_N, FV_c1, FV_c2;
	+ double m_maxProb;
	+ double m_FA0_N, m_FA0_c1, m_FA0_c2;
	+ double m_FAm_N, m_FAm_c1, m_FAm_c2;
	+ double m_FAp_N, m_FAp_c1, m_FAp_c2;
	+ double m_FV_N, m_FV_c1, m_FV_c2;

	- double Fp_N, Fp_c1, Fp_c2;
	- double Fm_N, Fm_c1, Fm_c2;
	+ double m_Fp_N, m_Fp_c1, m_Fp_c2;
	+ double m_Fm_N, m_Fm_c1, m_Fm_c2;

	// W -> pi... form factors
	- double _beta;
	- double _mRho;
	- double _gammaRho;
	- double _mRhopr;
	- double _gammaRhopr;
	- double _mA1;
	- double _gammaA1;
	-
	- double _ee( double M, double m1, double m2 );
	- double _pp( double M, double m1, double m2 );
	+ double m_beta;
	+ double m_mRho;
	+ double m_gammaRho;
	+ double m_mRhopr;
	+ double m_gammaRhopr;
	+ double m_mA1;
	+ double m_gammaA1;
	+
	+ double energy1( double M, double m1, double m2 );
	+ double mom1( double M, double m1, double m2 );
	EvtComplex Fpi( EvtVector4R q1, EvtVector4R q2 );
	double pi3G( double m2, int dupD );

	diff --git a/EvtGenModels/EvtBcVMuNu.hh b/EvtGenModels/EvtBcVMuNu.hh
	--- a/EvtGenModels/EvtBcVMuNu.hh
	+++ b/EvtGenModels/EvtBcVMuNu.hh
	@@ -42,10 +42,10 @@
	void initProbMax() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> ffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	- int whichfit;
	- int idVector;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_ffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	+ int m_whichfit;
	+ int m_idVector;
	};

	#endif
	diff --git a/EvtGenModels/EvtBcVNpi.hh b/EvtGenModels/EvtBcVNpi.hh
	--- a/EvtGenModels/EvtBcVNpi.hh
	+++ b/EvtGenModels/EvtBcVNpi.hh
	@@ -44,10 +44,10 @@
	void decay( EvtParticle* p ) override;

	protected:
	- int nCall;
	- int whichfit, idVector;
	- std::unique_ptr<EvtBCVFF> ffmodel;
	- std::unique_ptr<EvtWnPi> wcurr;
	+ int m_nCall;
	+ int m_whichfit, m_idVector;
	+ std::unique_ptr<EvtBCVFF> m_ffmodel;
	+ std::unique_ptr<EvtWnPi> m_wcurr;

	EvtComplex Fpi( EvtVector4R q1, EvtVector4R q2 );
	EvtComplex BWa( EvtVector4R q );
	diff --git a/EvtGenModels/EvtBsMuMuKK.hh b/EvtGenModels/EvtBsMuMuKK.hh
	--- a/EvtGenModels/EvtBsMuMuKK.hh
	+++ b/EvtGenModels/EvtBsMuMuKK.hh
	@@ -66,23 +66,29 @@
	const double phis, const int eta ) const;

	private:
	- double MBs, MJpsi, Mf0, Mphi, Mf2p, MKp, MKm, MK0, Mpip, Mpi0, Mmu;
	- double Gamma0phi, Gamma0f2p;
	- double kin_lower_limit, kin_upper_limit, kin_middle;
	- double p30Kp_mid_CMS, p30Kp_ll_CMS, p30Kp_phi_CMS, p30Kp_f2p_CMS;
	- double p30Jpsi_mid_CMS, p30Jpsi_ll_CMS, p30Jpsi_phi_CMS, p30Jpsi_f2p_CMS;
	- double int_const_NR, int_Flatte_f0, int_BW_phi, int_BW_f2p;
	- double f_S_NR, f_f0, f_phi, f_f2p, f_phi_0, f_phi_perp, f_f2p_0, f_f2p_perp;
	- double A_S_NR, A_f0, A_phi_0, A_phi_perp, A_phi_par, A_f2p_0, A_f2p_perp;
	- double A_f2p_par;
	- double delta_S_NR, delta_f0, delta_phi_0, delta_phi_perp, delta_phi_par;
	- double delta_f2p_0, delta_f2p_perp, delta_f2p_par;
	- double phis_S_NR, phis_f0, phis_phi_0, phis_phi_perp, phis_phi_par;
	- double phis_f2p_0, phis_f2p_perp, phis_f2p_par;
	- double lambda_S_NR_abs, lambda_f0_abs, lambda_phi_0_abs, lambda_phi_perp_abs;
	- double lambda_phi_par_abs, lambda_f2p_0_abs, lambda_f2p_perp_abs;
	- double lambda_f2p_par_abs;
	- double Gamma, deltaGamma, ctau, deltaMs;
	+ double m_MBs, m_MJpsi, m_Mf0, m_Mphi, m_Mf2p, m_MKp, m_MKm, m_MK0, m_Mpip,
	+ m_Mpi0, m_Mmu;
	+ double m_Gamma0phi, m_Gamma0f2p;
	+ double m_kin_lower_limit, m_kin_upper_limit, m_kin_middle;
	+ double m_p30Kp_mid_CMS, m_p30Kp_ll_CMS, m_p30Kp_phi_CMS, m_p30Kp_f2p_CMS;
	+ double m_p30Jpsi_mid_CMS, m_p30Jpsi_ll_CMS, m_p30Jpsi_phi_CMS,
	+ m_p30Jpsi_f2p_CMS;
	+ double m_int_const_NR, m_int_Flatte_f0, m_int_BW_phi, m_int_BW_f2p;
	+ double m_f_S_NR, m_f_f0, m_f_phi, m_f_f2p, m_f_phi_0, m_f_phi_perp,
	+ m_f_f2p_0, m_f_f2p_perp;
	+ double m_A_S_NR, m_A_f0, m_A_phi_0, m_A_phi_perp, m_A_phi_par, m_A_f2p_0,
	+ m_A_f2p_perp;
	+ double m_A_f2p_par;
	+ double m_delta_S_NR, m_delta_f0, m_delta_phi_0, m_delta_phi_perp,
	+ m_delta_phi_par;
	+ double m_delta_f2p_0, m_delta_f2p_perp, m_delta_f2p_par;
	+ double m_phis_S_NR, m_phis_f0, m_phis_phi_0, m_phis_phi_perp, m_phis_phi_par;
	+ double m_phis_f2p_0, m_phis_f2p_perp, m_phis_f2p_par;
	+ double m_lambda_S_NR_abs, m_lambda_f0_abs, m_lambda_phi_0_abs,
	+ m_lambda_phi_perp_abs;
	+ double m_lambda_phi_par_abs, m_lambda_f2p_0_abs, m_lambda_f2p_perp_abs;
	+ double m_lambda_f2p_par_abs;
	+ double m_Gamma, m_deltaGamma, m_ctau, m_deltaMs;
	};

	#endif
	diff --git a/EvtGenModels/EvtBtoKD3P.hh b/EvtGenModels/EvtBtoKD3P.hh
	--- a/EvtGenModels/EvtBtoKD3P.hh
	+++ b/EvtGenModels/EvtBtoKD3P.hh
	@@ -66,13 +66,13 @@

	protected:
	// parameters:
	- double _r;
	- EvtComplex _exp;
	+ double m_r;
	+ EvtComplex m_exp;

	// other:
	- const EvtDecayBase* _model1 = nullptr;
	- const EvtDecayBase* _model2 = nullptr;
	- bool _decayedOnce = false;
	+ const EvtDecayBase* m_model1 = nullptr;
	+ const EvtDecayBase* m_model2 = nullptr;
	+ bool m_decayedOnce = false;
	};

	#endif
	diff --git a/EvtGenModels/EvtBtoXsgamma.hh b/EvtGenModels/EvtBtoXsgamma.hh
	--- a/EvtGenModels/EvtBtoXsgamma.hh
	+++ b/EvtGenModels/EvtBtoXsgamma.hh
	@@ -44,7 +44,7 @@
	void decay( EvtParticle* p ) override;

	private:
	- std::unique_ptr<EvtBtoXsgammaAbsModel> _model;
	+ std::unique_ptr<EvtBtoXsgammaAbsModel> m_model;
	};

	#endif
	diff --git a/EvtGenModels/EvtBtoXsgammaFixedMass.hh b/EvtGenModels/EvtBtoXsgammaFixedMass.hh
	--- a/EvtGenModels/EvtBtoXsgammaFixedMass.hh
	+++ b/EvtGenModels/EvtBtoXsgammaFixedMass.hh
	@@ -34,7 +34,7 @@

	private:
	//Input parameters
	- double _mH;
	+ double m_mH;
	};

	#endif
	diff --git a/EvtGenModels/EvtBtoXsgammaFlatEnergy.hh b/EvtGenModels/EvtBtoXsgammaFlatEnergy.hh
	--- a/EvtGenModels/EvtBtoXsgammaFlatEnergy.hh
	+++ b/EvtGenModels/EvtBtoXsgammaFlatEnergy.hh
	@@ -34,11 +34,11 @@

	private:
	//Input parameters
	- double _eMin;
	- double _eMax;
	+ double m_eMin;
	+ double m_eMax;
	//
	- double _mB0;
	- double _eRange;
	+ double m_mB0;
	+ double m_eRange;
	};

	#endif
	diff --git a/EvtGenModels/EvtBtoXsgammaKagan.hh b/EvtGenModels/EvtBtoXsgammaKagan.hh
	--- a/EvtGenModels/EvtBtoXsgammaKagan.hh
	+++ b/EvtGenModels/EvtBtoXsgammaKagan.hh
	@@ -62,52 +62,52 @@

	private:
	//Input parameters
	- double _mb;
	- double _mB;
	- double _delta;
	- double _nIntervalS;
	- double _nIntervalmH;
	- double _lambdabar;
	- double _lam1;
	- double _mHmin;
	- double _mHmax;
	+ double m_mb;
	+ double m_mB;
	+ double m_delta;
	+ double m_nIntervalS;
	+ double m_nIntervalmH;
	+ double m_lambdabar;
	+ double m_lam1;
	+ double m_mHmin;
	+ double m_mHmax;
	//Other parameters
	- double _r7;
	- double _gam77;
	- double _gam27;
	- double _gam87;
	- double _beta0;
	- double _beta1;
	- double _alphasmZ;
	- double _mZ;
	- double _z;
	- double _fz;
	- double _lam2;
	- double _kappabar;
	- double _rer2;
	- double _rer8;
	- double _kSLemmu;
	- double _mW;
	- double _mt;
	- double _ms;
	- double _mu;
	-
	- double _c2mu;
	- double _c70mu;
	- double _c80mu;
	- double _c71mu;
	- double _c7emmu;
	-
	- double _cDeltatot;
	-
	- double _alpha;
	- double _alphasmW;
	- double _alphasmt;
	- double _alphasmu;
	- double _alphasmubar;
	- double _etamu;
	-
	- std::vector<double> _mHVect;
	+ double m_r7;
	+ double m_gam77;
	+ double m_gam27;
	+ double m_gam87;
	+ double m_beta0;
	+ double m_beta1;
	+ double m_alphasmZ;
	+ double m_mZ;
	+ double m_z;
	+ double m_fz;
	+ double m_lam2;
	+ double m_kappabar;
	+ double m_rer2;
	+ double m_rer8;
	+ double m_kSLemmu;
	+ double m_mW;
	+ double m_mt;
	+ double m_ms;
	+ double m_mu;
	+
	+ double m_c2mu;
	+ double m_c70mu;
	+ double m_c80mu;
	+ double m_c71mu;
	+ double m_c7emmu;
	+
	+ double m_cDeltatot;
	+
	+ double m_alpha;
	+ double m_alphasmW;
	+ double m_alphasmt;
	+ double m_alphasmu;
	+ double m_alphasmubar;
	+ double m_etamu;
	+
	+ std::vector<double> m_mHVect;

	static double ReG( double );
	static double ImG( double );
	@@ -140,9 +140,9 @@
	static double FermiFunc( double, const std::vector<double>& coeffs );
	static double diLogFunc( double );
	static double diLogMathematica( double );
	- std::vector<double> massHad, brHad;
	- static double intervalMH;
	- static bool bbprod;
	+ std::vector<double> m_massHad, m_brHad;
	+ static double m_intervalMH;
	+ static bool m_bbprod;
	};

	#endif
	diff --git a/EvtGenModels/EvtBtoXsll.hh b/EvtGenModels/EvtBtoXsll.hh
	--- a/EvtGenModels/EvtBtoXsll.hh
	+++ b/EvtGenModels/EvtBtoXsll.hh
	@@ -50,14 +50,14 @@
	void decay( EvtParticle* p ) override;

	private:
	- std::unique_ptr<EvtBtoXsllUtil> _calcprob;
	- double _dGdsProbMax;
	- double _dGdsdupProbMax;
	- double _mb;
	- double _ms;
	- double _mq;
	- double _pf;
	- double _mxmin;
	+ std::unique_ptr<EvtBtoXsllUtil> m_calcprob;
	+ double m_dGdsProbMax;
	+ double m_dGdsdupProbMax;
	+ double m_mb;
	+ double m_ms;
	+ double m_mq;
	+ double m_pf;
	+ double m_mxmin;
	};

	#endif
	diff --git a/EvtGenModels/EvtCBTo3piMPP.hh b/EvtGenModels/EvtCBTo3piMPP.hh
	--- a/EvtGenModels/EvtCBTo3piMPP.hh
	+++ b/EvtGenModels/EvtCBTo3piMPP.hh
	@@ -39,7 +39,7 @@
	void decay( EvtParticle* p ) override;

	private:
	- EvtBTo3hCP generator;
	+ EvtBTo3hCP m_generator;
	};

	#endif
	diff --git a/EvtGenModels/EvtCBTo3piP00.hh b/EvtGenModels/EvtCBTo3piP00.hh
	--- a/EvtGenModels/EvtCBTo3piP00.hh
	+++ b/EvtGenModels/EvtCBTo3piP00.hh
	@@ -41,7 +41,7 @@
	void decay( EvtParticle* p ) override;

	private:
	- EvtBTo3hCP generator;
	+ EvtBTo3hCP m_generator;
	};

	#endif
	diff --git a/EvtGenModels/EvtD0gammaDalitz.hh b/EvtGenModels/EvtD0gammaDalitz.hh
	--- a/EvtGenModels/EvtD0gammaDalitz.hh
	+++ b/EvtGenModels/EvtD0gammaDalitz.hh
	@@ -33,53 +33,53 @@

	class EvtD0gammaDalitz : public EvtDecayAmp {
	private:
	- int _d1;
	- int _d2;
	- int _d3;
	+ int m_d1;
	+ int m_d2;
	+ int m_d3;

	- bool _isKsPiPi;
	+ bool m_isKsPiPi;

	// Useful constants.
	- static const EvtSpinType::spintype& _SCALAR;
	- static const EvtSpinType::spintype& _VECTOR;
	- static const EvtSpinType::spintype& _TENSOR;
	+ static const EvtSpinType::spintype& m_SCALAR;
	+ static const EvtSpinType::spintype& m_VECTOR;
	+ static const EvtSpinType::spintype& m_TENSOR;

	- static const EvtDalitzReso::CouplingType& _EtaPic;
	- static const EvtDalitzReso::CouplingType& _PicPicKK;
	+ static const EvtDalitzReso::CouplingType& m_EtaPic;
	+ static const EvtDalitzReso::CouplingType& m_PicPicKK;

	- static const EvtDalitzReso::NumType& _RBW;
	- static const EvtDalitzReso::NumType& _GS;
	- static const EvtDalitzReso::NumType& _KMAT;
	+ static const EvtDalitzReso::NumType& m_RBW;
	+ static const EvtDalitzReso::NumType& m_GS;
	+ static const EvtDalitzReso::NumType& m_KMAT;

	- static const EvtCyclic3::Pair& _AB;
	- static const EvtCyclic3::Pair& _AC;
	- static const EvtCyclic3::Pair& _BC;
	+ static const EvtCyclic3::Pair& m_AB;
	+ static const EvtCyclic3::Pair& m_AC;
	+ static const EvtCyclic3::Pair& m_BC;

	// Values to be read or computed based on values in the evt.pdl file.
	// IDs of the relevant particles.
	- EvtId _BP;
	- EvtId _BM;
	- EvtId _B0;
	- EvtId _B0B;
	- EvtId _D0;
	- EvtId _D0B;
	- EvtId _KM;
	- EvtId _KP;
	- EvtId _K0;
	- EvtId _K0B;
	- EvtId _KL;
	- EvtId _KS;
	- EvtId _PIM;
	- EvtId _PIP;
	+ EvtId m_BP;
	+ EvtId m_BM;
	+ EvtId m_B0;
	+ EvtId m_B0B;
	+ EvtId m_D0;
	+ EvtId m_D0B;
	+ EvtId m_KM;
	+ EvtId m_KP;
	+ EvtId m_K0;
	+ EvtId m_K0B;
	+ EvtId m_KL;
	+ EvtId m_KS;
	+ EvtId m_PIM;
	+ EvtId m_PIP;

	// Flavor of the B mother.
	- EvtId _bFlavor;
	+ EvtId m_bFlavor;

	// Masses of the relevant particles.
	- double _mD0;
	- double _mKs;
	- double _mPi;
	- double _mK;
	+ double m_mD0;
	+ double m_mKs;
	+ double m_mPi;
	+ double m_mK;

	void readPDGValues();
	void reportInvalidAndExit() const;
	diff --git a/EvtGenModels/EvtD0mixDalitz.hh b/EvtGenModels/EvtD0mixDalitz.hh
	--- a/EvtGenModels/EvtD0mixDalitz.hh
	+++ b/EvtGenModels/EvtD0mixDalitz.hh
	@@ -35,63 +35,63 @@

	class EvtD0mixDalitz : public EvtDecayAmp {
	private:
	- int _d1;
	- int _d2;
	- int _d3;
	+ int m_d1;
	+ int m_d2;
	+ int m_d3;

	// Mixing parameters.
	- double _x;
	- double _y;
	+ double m_x;
	+ double m_y;

	// q/p CP violation in the mixing.
	- EvtComplex _qp;
	+ EvtComplex m_qp;

	// Checker of the decay mode.
	- bool _isKsPiPi;
	- bool _isRBWmodel;
	+ bool m_isKsPiPi;
	+ bool m_isRBWmodel;

	// Useful constants.
	- static const EvtSpinType::spintype& _SCALAR;
	- static const EvtSpinType::spintype& _VECTOR;
	- static const EvtSpinType::spintype& _TENSOR;
	+ static const EvtSpinType::spintype& m_SCALAR;
	+ static const EvtSpinType::spintype& m_VECTOR;
	+ static const EvtSpinType::spintype& m_TENSOR;

	- static const EvtDalitzReso::CouplingType& _EtaPic;
	- static const EvtDalitzReso::CouplingType& _PicPicKK;
	+ static const EvtDalitzReso::CouplingType& m_EtaPic;
	+ static const EvtDalitzReso::CouplingType& m_PicPicKK;

	- static const EvtDalitzReso::NumType& _RBW;
	- static const EvtDalitzReso::NumType& _GS;
	- static const EvtDalitzReso::NumType& _KMAT;
	+ static const EvtDalitzReso::NumType& m_RBW;
	+ static const EvtDalitzReso::NumType& m_GS;
	+ static const EvtDalitzReso::NumType& m_KMAT;

	- static const EvtCyclic3::Pair& _AB;
	- static const EvtCyclic3::Pair& _AC;
	- static const EvtCyclic3::Pair& _BC;
	+ static const EvtCyclic3::Pair& m_AB;
	+ static const EvtCyclic3::Pair& m_AC;
	+ static const EvtCyclic3::Pair& m_BC;

	// Values to be read or computed based on values in the evt.pdl file.
	// IDs of the relevant particles.
	- EvtId _D0;
	- EvtId _D0B;
	- EvtId _KM;
	- EvtId _KP;
	- EvtId _K0;
	- EvtId _K0B;
	- EvtId _KL;
	- EvtId _KS;
	- EvtId _PIM;
	- EvtId _PIP;
	+ EvtId m_D0;
	+ EvtId m_D0B;
	+ EvtId m_KM;
	+ EvtId m_KP;
	+ EvtId m_K0;
	+ EvtId m_K0B;
	+ EvtId m_KL;
	+ EvtId m_KS;
	+ EvtId m_PIM;
	+ EvtId m_PIP;

	// Masses of the relevant particles.
	- double _mD0;
	- double _mKs;
	- double _mPi;
	- double _mK;
	+ double m_mD0;
	+ double m_mKs;
	+ double m_mPi;
	+ double m_mK;

	// Life time and decay rate.
	- double _ctau;
	- double _gamma;
	+ double m_ctau;
	+ double m_gamma;

	// Some useful integrals over the Dalitz plot.
	- EvtComplex _iChi;
	- EvtComplex _iChi2;
	+ EvtComplex m_iChi;
	+ EvtComplex m_iChi2;

	void readPDGValues();
	EvtComplex dalitzKsPiPi( const EvtDalitzPoint& point );
	@@ -111,14 +111,14 @@

	public:
	EvtD0mixDalitz() :
	- _d1( 0 ),
	- _d2( 0 ),
	- _d3( 0 ),
	- _x( 0. ),
	- _y( 0. ),
	- _qp( 1. ),
	- _isKsPiPi( false ),
	- _isRBWmodel( true )
	+ m_d1( 0 ),
	+ m_d2( 0 ),
	+ m_d3( 0 ),
	+ m_x( 0. ),
	+ m_y( 0. ),
	+ m_qp( 1. ),
	+ m_isKsPiPi( false ),
	+ m_isRBWmodel( true )
	{
	}

	diff --git a/EvtGenModels/EvtDDalitz.hh b/EvtGenModels/EvtDDalitz.hh
	--- a/EvtGenModels/EvtDDalitz.hh
	+++ b/EvtGenModels/EvtDDalitz.hh
	@@ -39,14 +39,14 @@
	void decay( EvtParticle* p ) override;

	private:
	- int _d1, _d2, _d3, _flag;
	+ int m_d1, m_d2, m_d3, m_flag;

	EvtComplex amplDtoK0PiPi( EvtVector4R p4_p, EvtVector4R moms1,
	EvtVector4R moms2, EvtVector4R moms3 );
	EvtComplex amplDtoK0KK( EvtVector4R p4_p, EvtVector4R moms1,
	EvtVector4R moms2, EvtVector4R moms3 );

	- vector<EvtFlatteParam> _kkpi_params;
	+ vector<EvtFlatteParam> m_kkpi_params;
	};

	#endif
	diff --git a/EvtGenModels/EvtDMix.hh b/EvtGenModels/EvtDMix.hh
	--- a/EvtGenModels/EvtDMix.hh
	+++ b/EvtGenModels/EvtDMix.hh
	@@ -38,9 +38,9 @@
	void decay( EvtParticle* p ) override;

	private:
	- double _rd;
	- double _xpr;
	- double _ypr;
	+ double m_rd;
	+ double m_xpr;
	+ double m_ypr;
	};

	#endif
	diff --git a/EvtGenModels/EvtDToKpienu.hh b/EvtGenModels/EvtDToKpienu.hh
	--- a/EvtGenModels/EvtDToKpienu.hh
	+++ b/EvtGenModels/EvtDToKpienu.hh
	@@ -74,46 +74,46 @@
	const double rBW ) const;
	EvtComplex getCoef( const double rho, const double phi ) const;

	- int nAmps;
	- std::array<int, 5> type;
	+ int m_nAmps;
	+ std::array<int, 5> m_type;

	- double rS;
	- double rS1;
	- double a_delta;
	- double b_delta;
	- double m0_1430_S;
	- double width0_1430_S;
	+ double m_rS;
	+ double m_rS1;
	+ double m_a_delta;
	+ double m_b_delta;
	+ double m_m0_1430_S;
	+ double m_width0_1430_S;

	- double mV;
	- double mA;
	- double V_0;
	- double A1_0;
	- double A2_0;
	- double m0;
	- double width0;
	- double rBW;
	- double rho;
	- double phi;
	- double m0_1410;
	- double width0_1410;
	- double rho_1410;
	- double phi_1410;
	- double TV_0;
	- double T1_0;
	- double T2_0;
	- double m0_1430;
	- double width0_1430;
	- double rho_1430;
	- double phi_1430;
	+ double m_mV;
	+ double m_mA;
	+ double m_V_0;
	+ double m_A1_0;
	+ double m_A2_0;
	+ double m_m0;
	+ double m_width0;
	+ double m_rBW;
	+ double m_rho;
	+ double m_phi;
	+ double m_m0_1410;
	+ double m_width0_1410;
	+ double m_rho_1410;
	+ double m_phi_1410;
	+ double m_TV_0;
	+ double m_T1_0;
	+ double m_T2_0;
	+ double m_m0_1430;
	+ double m_width0_1430;
	+ double m_rho_1430;
	+ double m_phi_1430;

	- double mD;
	- double mPi;
	- double mK;
	- double Pi;
	- double root2;
	- double root2d3;
	- double root1d2;
	- double root3d2;
	+ double m_mD;
	+ double m_mPi;
	+ double m_mK;
	+ double m_Pi;
	+ double m_root2;
	+ double m_root2d3;
	+ double m_root1d2;
	+ double m_root3d2;
	};

	#endif
	diff --git a/EvtGenModels/EvtDalitzDecayInfo.hh b/EvtGenModels/EvtDalitzDecayInfo.hh
	--- a/EvtGenModels/EvtDalitzDecayInfo.hh
	+++ b/EvtGenModels/EvtDalitzDecayInfo.hh
	@@ -32,34 +32,34 @@
	class EvtDalitzDecayInfo final {
	public:
	EvtDalitzDecayInfo( EvtId d1, EvtId d2, EvtId d3 ) :
	- _d1( d1 ), _d2( d2 ), _d3( d3 ), _probMax( 0. )
	+ m_d1( d1 ), m_d2( d2 ), m_d3( d3 ), m_probMax( 0. )
	{
	}

	void addResonance( EvtComplex amp, EvtDalitzReso res )
	{
	- _resonances.push_back( std::pair<EvtComplex, EvtDalitzReso>( amp, res ) );
	+ m_resonances.push_back( std::pair<EvtComplex, EvtDalitzReso>( amp, res ) );
	}
	void addResonance( std::pair<EvtComplex, EvtDalitzReso> res )
	{
	- _resonances.push_back( res );
	+ m_resonances.push_back( res );
	}
	- void setProbMax( double probMax ) { _probMax = probMax; }
	+ void setProbMax( double probMax ) { m_probMax = probMax; }

	const std::vector<std::pair<EvtComplex, EvtDalitzReso>>& getResonances() const
	{
	- return _resonances;
	+ return m_resonances;
	}
	- double getProbMax() const { return _probMax; }
	+ double getProbMax() const { return m_probMax; }

	- inline const EvtId& daughter1() const { return _d1; }
	- inline const EvtId& daughter2() const { return _d2; }
	- inline const EvtId& daughter3() const { return _d3; }
	+ inline const EvtId& daughter1() const { return m_d1; }
	+ inline const EvtId& daughter2() const { return m_d2; }
	+ inline const EvtId& daughter3() const { return m_d3; }

	private:
	- EvtId _d1, _d2, _d3;
	- std::vector<std::pair<EvtComplex, EvtDalitzReso>> _resonances;
	- double _probMax;
	+ EvtId m_d1, m_d2, m_d3;
	+ std::vector<std::pair<EvtComplex, EvtDalitzReso>> m_resonances;
	+ double m_probMax;
	};

	#endif
	diff --git a/EvtGenModels/EvtDalitzTable.hh b/EvtGenModels/EvtDalitzTable.hh
	--- a/EvtGenModels/EvtDalitzTable.hh
	+++ b/EvtGenModels/EvtDalitzTable.hh
	@@ -66,8 +66,8 @@
	EvtId* resDaughter, EvtId* daughter,
	std::vector<std::pair<EvtCyclic3::Pair, EvtCyclic3::Pair>>& angAndResPairs );

	- std::map<EvtId, std::vector<EvtDalitzDecayInfo>> _dalitztable;
	- std::vector<std::string> _readFiles;
	+ std::map<EvtId, std::vector<EvtDalitzDecayInfo>> m_dalitztable;
	+ std::vector<std::string> m_readFiles;

	EvtDalitzTable( const EvtDalitzTable& );
	EvtDalitzTable& operator=( const EvtDalitzTable& );
	diff --git a/EvtGenModels/EvtFlatQ2.hh b/EvtGenModels/EvtFlatQ2.hh
	--- a/EvtGenModels/EvtFlatQ2.hh
	+++ b/EvtGenModels/EvtFlatQ2.hh
	@@ -38,7 +38,7 @@
	void decay( EvtParticle* p ) override;

	private:
	- bool _usePhsp;
	+ bool m_usePhsp;
	};

	#endif
	diff --git a/EvtGenModels/EvtGenericDalitz.hh b/EvtGenModels/EvtGenericDalitz.hh
	--- a/EvtGenModels/EvtGenericDalitz.hh
	+++ b/EvtGenModels/EvtGenericDalitz.hh
	@@ -45,8 +45,8 @@
	std::string getParamName( int i ) override;

	private:
	- int _d1, _d2, _d3;
	- std::vector<std::pair<EvtComplex, EvtDalitzReso>> _resonances;
	+ int m_d1, m_d2, m_d3;
	+ std::vector<std::pair<EvtComplex, EvtDalitzReso>> m_resonances;
	};

	#endif
	diff --git a/EvtGenModels/EvtHQET.hh b/EvtGenModels/EvtHQET.hh
	--- a/EvtGenModels/EvtHQET.hh
	+++ b/EvtGenModels/EvtHQET.hh
	@@ -41,7 +41,7 @@
	void init() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> hqetffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_hqetffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	};
	#endif
	diff --git a/EvtGenModels/EvtHQET2.hh b/EvtGenModels/EvtHQET2.hh
	--- a/EvtGenModels/EvtHQET2.hh
	+++ b/EvtGenModels/EvtHQET2.hh
	@@ -42,7 +42,7 @@
	void init() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> hqetffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_hqetffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	};
	#endif
	diff --git a/EvtGenModels/EvtHQET2FF.hh b/EvtGenModels/EvtHQET2FF.hh
	--- a/EvtGenModels/EvtHQET2FF.hh
	+++ b/EvtGenModels/EvtHQET2FF.hh
	@@ -53,14 +53,14 @@
	double, double, double, double, double* ) override;

	private:
	- double r1_1;
	- double rho2;
	- double r2_1;
	- double ha1_1;
	- double v1_1;
	- double r0_1;
	- double delta;
	- bool extended;
	+ double m_r1_1;
	+ double m_rho2;
	+ double m_r2_1;
	+ double m_ha1_1;
	+ double m_v1_1;
	+ double m_r0_1;
	+ double m_delta;
	+ bool m_extended;
	};

	#endif
	diff --git a/EvtGenModels/EvtHQETFF.hh b/EvtGenModels/EvtHQETFF.hh
	--- a/EvtGenModels/EvtHQETFF.hh
	+++ b/EvtGenModels/EvtHQETFF.hh
	@@ -49,10 +49,10 @@
	double, double, double, double, double* ) override;

	private:
	- double r1;
	- double rho2;
	- double r2;
	- double c;
	+ double m_r1;
	+ double m_rho2;
	+ double m_r2;
	+ double m_c;
	};

	#endif
	diff --git a/EvtGenModels/EvtHelAmp.hh b/EvtGenModels/EvtHelAmp.hh
	--- a/EvtGenModels/EvtHelAmp.hh
	+++ b/EvtGenModels/EvtHelAmp.hh
	@@ -45,7 +45,7 @@
	private:
	void fillHelicity( int* lambda2, int n, int J2, EvtId id );

	- std::unique_ptr<EvtEvalHelAmp> _evalHelAmp;
	+ std::unique_ptr<EvtEvalHelAmp> m_evalHelAmp;
	};

	#endif
	diff --git a/EvtGenModels/EvtISGW.hh b/EvtGenModels/EvtISGW.hh
	--- a/EvtGenModels/EvtISGW.hh
	+++ b/EvtGenModels/EvtISGW.hh
	@@ -38,8 +38,8 @@
	void initProbMax() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> isgwffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_isgwffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtISGW2.hh b/EvtGenModels/EvtISGW2.hh
	--- a/EvtGenModels/EvtISGW2.hh
	+++ b/EvtGenModels/EvtISGW2.hh
	@@ -45,8 +45,8 @@
	void init() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> isgw2ffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_isgw2ffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtIntervalDecayAmp.hh b/EvtGenModels/EvtIntervalDecayAmp.hh
	--- a/EvtGenModels/EvtIntervalDecayAmp.hh
	+++ b/EvtGenModels/EvtIntervalDecayAmp.hh
	@@ -44,14 +44,14 @@
	template <class T>
	class EvtIntervalDecayAmp : public EvtDecayAmp {
	public:
	- EvtIntervalDecayAmp() : _probMax( 0. ), _nScan( 0 ), _fact( nullptr ) {}
	+ EvtIntervalDecayAmp() : m_probMax( 0. ), m_nScan( 0 ), m_fact( nullptr ) {}

	EvtIntervalDecayAmp( const EvtIntervalDecayAmp<T>& other ) :
	- _probMax( other._probMax ), _nScan( other._nScan ), COPY_PTR( _fact )
	+ m_probMax( other.m_probMax ), m_nScan( other.m_nScan ), COPY_PTR( m_fact )
	{
	}

	- virtual ~EvtIntervalDecayAmp() { delete _fact; }
	+ virtual ~EvtIntervalDecayAmp() { delete m_fact; }

	// Initialize model

	@@ -71,39 +71,39 @@
	if ( VERBOSE )
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Create factory and interval" << std::endl;
	- _fact = createFactory( parser );
	+ m_fact = createFactory( parser );

	// Maximum PDF value over the Dalitz plot can be specified, or a scan
	// can be performed.

	- _probMax = parser.pdfMax();
	- _nScan = parser.nScan();
	+ m_probMax = parser.pdfMax();
	+ m_nScan = parser.nScan();
	if ( VERBOSE )
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "Pdf maximum " << _probMax << std::endl;
	+ << "Pdf maximum " << m_probMax << std::endl;
	if ( VERBOSE )
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "Scan number " << _nScan << std::endl;
	+ << "Scan number " << m_nScan << std::endl;
	}

	void initProbMax() override
	{
	- if ( 0 == _nScan ) {
	- if ( _probMax > 0 )
	- setProbMax( _probMax );
	+ if ( 0 == m_nScan ) {
	+ if ( m_probMax > 0 )
	+ setProbMax( m_probMax );
	else
	assert( 0 );
	} else {
	double factor = 1.2; // increase maximum probability by 20%
	- EvtAmpPdf<T> pdf( *_fact->getAmp() );
	- EvtPdfSum<T>* pc = _fact->getPC();
	+ EvtAmpPdf<T> pdf( *m_fact->getAmp() );
	+ EvtPdfSum<T>* pc = m_fact->getPC();
	EvtPdfDiv<T> pdfdiv( pdf, *pc );
	- printf( "Sampling %d points to find maximum\n", _nScan );
	- EvtPdfMax<T> x = pdfdiv.findMax( *pc, _nScan );
	- _probMax = factor * x.value();
	+ printf( "Sampling %d points to find maximum\n", m_nScan );
	+ EvtPdfMax<T> x = pdfdiv.findMax( *pc, m_nScan );
	+ m_probMax = factor * x.value();
	printf( "Found maximum %f\n", x.value() );
	- printf( "Increase to %f\n", _probMax );
	- setProbMax( _probMax );
	+ printf( "Increase to %f\n", m_probMax );
	+ setProbMax( m_probMax );
	}
	}

	@@ -120,20 +120,20 @@
	// Sample using pole-compensator pdf

	EvtPdfSum<T>* pc = getPC();
	- _x = pc->randomPoint();
	+ m_x = pc->randomPoint();

	- if ( _fact->isCPModel() ) {
	+ if ( m_fact->isCPModel() ) {
	// Time-dependent Dalitz plot changes
	// Dec 2005 (ddujmic@slac.stanford.edu)

	- EvtComplex A = _fact->getAmp()->evaluate( _x );
	- EvtComplex Abar = _fact->getAmpConj()->evaluate( _x );
	+ EvtComplex A = m_fact->getAmp()->evaluate( m_x );
	+ EvtComplex Abar = m_fact->getAmpConj()->evaluate( m_x );

	EvtCPUtil::getInstance()->OtherB( p, t, other_b );

	- double dm = _fact->dm();
	- double mixAmpli = _fact->mixAmpli();
	- double mixPhase = _fact->mixPhase();
	+ double dm = m_fact->dm();
	+ double mixAmpli = m_fact->mixAmpli();
	+ double mixPhase = m_fact->mixPhase();
	EvtComplex qoverp( cos( mixPhase ) * mixAmpli,
	sin( mixPhase ) * mixAmpli );
	EvtComplex poverq( cos( mixPhase ) / mixAmpli,
	@@ -149,19 +149,19 @@
	sin( dm * t / ( 2 * EvtConst::c ) ) * poverq;

	} else {
	- ampl = amplNonCP( _x );
	+ ampl = amplNonCP( m_x );
	}

	// Pole-compensate

	- double comp = sqrt( pc->evaluate( _x ) );
	+ double comp = sqrt( pc->evaluate( m_x ) );
	assert( comp > 0 );
	vertex( ampl / comp );

	// Now generate random angles, rotate and setup
	// the daughters

	- std::vector<EvtVector4R> v = initDaughters( _x );
	+ std::vector<EvtVector4R> v = initDaughters( m_x );

	size_t N = p->getNDaug();
	if ( v.size() != N ) {
	@@ -183,19 +183,19 @@

	// provide access to the decay point and to the amplitude of any decay point.
	// this is used by EvtBtoKD3P:
	- const T& x() const { return _x; }
	+ const T& x() const { return m_x; }
	EvtComplex amplNonCP( const T& x )
	{
	- return _fact->getAmp()->evaluate( x );
	+ return m_fact->getAmp()->evaluate( x );
	}
	- EvtPdfSum<T>* getPC() { return _fact->getPC(); }
	+ EvtPdfSum<T>* getPC() { return m_fact->getPC(); }

	protected:
	- double _probMax; // Maximum probability
	- int _nScan; // Number of points for max prob DP scan
	- T _x; // Decay point
	+ double m_probMax; // Maximum probability
	+ int m_nScan; // Number of points for max prob DP scan
	+ T m_x; // Decay point

	- EvtAmpFactory<T>* _fact; // factory
	+ EvtAmpFactory<T>* m_fact; // factory
	};

	#endif
	diff --git a/EvtGenModels/EvtItgAbsFunction.hh b/EvtGenModels/EvtItgAbsFunction.hh
	--- a/EvtGenModels/EvtItgAbsFunction.hh
	+++ b/EvtGenModels/EvtItgAbsFunction.hh
	@@ -47,12 +47,12 @@

	// Selectors (const)

	- inline double upperRange() const { return _upperRange; }
	- inline double lowerRange() const { return _lowerRange; }
	+ inline double upperRange() const { return m_upperRange; }
	+ inline double lowerRange() const { return m_lowerRange; }
	inline void getRange( double& lower, double& upper ) const
	{
	- lower = _lowerRange;
	- upper = _upperRange;
	+ lower = m_lowerRange;
	+ upper = m_upperRange;
	}
	virtual void setCoeff( int, int, double ) = 0;
	virtual double getCoeff( int, int ) = 0;
	@@ -61,13 +61,13 @@
	virtual double myFunction( double x ) const = 0;
	void setRange( double x1, double x2 )
	{
	- _lowerRange = x1;
	- _upperRange = x2;
	+ m_lowerRange = x1;
	+ m_upperRange = x2;
	};

	private:
	- double _upperRange;
	- double _lowerRange;
	+ double m_upperRange;
	+ double m_lowerRange;
	};

	#endif // EVTITGABSFUNCTION_HH
	diff --git a/EvtGenModels/EvtItgAbsIntegrator.hh b/EvtGenModels/EvtItgAbsIntegrator.hh
	--- a/EvtGenModels/EvtItgAbsIntegrator.hh
	+++ b/EvtGenModels/EvtItgAbsIntegrator.hh
	@@ -42,10 +42,10 @@

	virtual double evaluateIt( double lower, double higher ) const = 0;

	- double myFunction( double x ) const { return _myFunction( x ); }
	+ double myFunction( double x ) const { return m_myFunction( x ); }

	private:
	- const EvtItgAbsFunction& _myFunction;
	+ const EvtItgAbsFunction& m_myFunction;

	void boundsCheck( double&, double& ) const;

	diff --git a/EvtGenModels/EvtItgFourCoeffFcn.hh b/EvtGenModels/EvtItgFourCoeffFcn.hh
	--- a/EvtGenModels/EvtItgFourCoeffFcn.hh
	+++ b/EvtGenModels/EvtItgFourCoeffFcn.hh
	@@ -49,15 +49,15 @@

	private:
	// Data members
	- double ( *_myFunction )( double x, const std::vector<double>& coeffs1,
	- const std::vector<double>& coeffs2,
	- const std::vector<double>& coeffs3,
	- const std::vector<double>& coeffs4 );
	-
	- std::vector<double> _coeffs1;
	- std::vector<double> _coeffs2;
	- std::vector<double> _coeffs3;
	- std::vector<double> _coeffs4;
	+ double ( *m_myFunction )( double x, const std::vector<double>& coeffs1,
	+ const std::vector<double>& coeffs2,
	+ const std::vector<double>& coeffs3,
	+ const std::vector<double>& coeffs4 );
	+
	+ std::vector<double> m_coeffs1;
	+ std::vector<double> m_coeffs2;
	+ std::vector<double> m_coeffs3;
	+ std::vector<double> m_coeffs4;
	};

	#endif // EvtITGPTRFUNCTION_HH
	diff --git a/EvtGenModels/EvtItgFunction.hh b/EvtGenModels/EvtItgFunction.hh
	--- a/EvtGenModels/EvtItgFunction.hh
	+++ b/EvtGenModels/EvtItgFunction.hh
	@@ -47,7 +47,7 @@

	private:
	// Data members
	- double ( *_myFunction )( double x );
	+ double ( *m_myFunction )( double x );
	};

	#endif // EvtITGFUNCTION_HH
	diff --git a/EvtGenModels/EvtItgPtrFunction.hh b/EvtGenModels/EvtItgPtrFunction.hh
	--- a/EvtGenModels/EvtItgPtrFunction.hh
	+++ b/EvtGenModels/EvtItgPtrFunction.hh
	@@ -44,9 +44,9 @@

	private:
	// Data members
	- double ( *_myFunction )( double x, const std::vector<double>& coeffs1 );
	+ double ( *m_myFunction )( double x, const std::vector<double>& coeffs1 );

	- std::vector<double> _coeffs1;
	+ std::vector<double> m_coeffs1;
	};

	#endif // EVTITGPTRFUNCTION_HH
	diff --git a/EvtGenModels/EvtItgSimpsonIntegrator.hh b/EvtGenModels/EvtItgSimpsonIntegrator.hh
	--- a/EvtGenModels/EvtItgSimpsonIntegrator.hh
	+++ b/EvtGenModels/EvtItgSimpsonIntegrator.hh
	@@ -42,8 +42,8 @@
	double evaluateIt( double, double ) const override;

	private:
	- double _precision;
	- double _maxLoop;
	+ double m_precision;
	+ double m_maxLoop;

	//EvtItgSimpsonIntegrator( const EvtItgSimpsonIntegrator& ); //// Copy Constructor
	//EvtItgSimpsonIntegrator& operator= ( const EvtItgSimpsonIntegrator& ); // Assignment op
	diff --git a/EvtGenModels/EvtItgThreeCoeffFcn.hh b/EvtGenModels/EvtItgThreeCoeffFcn.hh
	--- a/EvtGenModels/EvtItgThreeCoeffFcn.hh
	+++ b/EvtGenModels/EvtItgThreeCoeffFcn.hh
	@@ -53,13 +53,13 @@

	private:
	// Data members
	- double ( *_myFunction )( double x, const std::vector<double>& coeffs1,
	- const std::vector<double>& coeffs2,
	- const std::vector<double>& coeffs3 );
	+ double ( *m_myFunction )( double x, const std::vector<double>& coeffs1,
	+ const std::vector<double>& coeffs2,
	+ const std::vector<double>& coeffs3 );

	- std::vector<double> _coeffs1;
	- std::vector<double> _coeffs2;
	- std::vector<double> _coeffs3;
	+ std::vector<double> m_coeffs1;
	+ std::vector<double> m_coeffs2;
	+ std::vector<double> m_coeffs3;
	};

	#endif // EvtITGPTRFUNCTION_HH
	diff --git a/EvtGenModels/EvtItgTwoCoeffFcn.hh b/EvtGenModels/EvtItgTwoCoeffFcn.hh
	--- a/EvtGenModels/EvtItgTwoCoeffFcn.hh
	+++ b/EvtGenModels/EvtItgTwoCoeffFcn.hh
	@@ -50,11 +50,11 @@

	private:
	// Data members
	- double ( *_myFunction )( double x, const std::vector<double>& coeffs1,
	- const std::vector<double>& coeffs2 );
	+ double ( *m_myFunction )( double x, const std::vector<double>& coeffs1,
	+ const std::vector<double>& coeffs2 );

	- std::vector<double> _coeffs1;
	- std::vector<double> _coeffs2;
	+ std::vector<double> m_coeffs1;
	+ std::vector<double> m_coeffs2;
	};

	#endif // EvtITGTWOCOEFFFUNCTION_HH
	diff --git a/EvtGenModels/EvtKKLambdaC.hh b/EvtGenModels/EvtKKLambdaC.hh
	--- a/EvtGenModels/EvtKKLambdaC.hh
	+++ b/EvtGenModels/EvtKKLambdaC.hh
	@@ -41,8 +41,8 @@
	void init() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> _ffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> _calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_ffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtKKLambdaCFF.hh b/EvtGenModels/EvtKKLambdaCFF.hh
	--- a/EvtGenModels/EvtKKLambdaCFF.hh
	+++ b/EvtGenModels/EvtKKLambdaCFF.hh
	@@ -48,8 +48,8 @@
	double, double, double, double, double* ) override;

	private:
	- int _nargs;
	- double _args[2];
	+ int m_nargs;
	+ double m_args[2];
	};

	#endif
	diff --git a/EvtGenModels/EvtLNuGamma.hh b/EvtGenModels/EvtLNuGamma.hh
	--- a/EvtGenModels/EvtLNuGamma.hh
	+++ b/EvtGenModels/EvtLNuGamma.hh
	@@ -38,7 +38,7 @@
	void initProbMax() override;
	double getFormFactor( double photonEnergy );

	- bool _fafvzero = false;
	+ bool m_fafvzero = false;
	};

	#endif
	diff --git a/EvtGenModels/EvtLambdaP_BarGamma.hh b/EvtGenModels/EvtLambdaP_BarGamma.hh
	--- a/EvtGenModels/EvtLambdaP_BarGamma.hh
	+++ b/EvtGenModels/EvtLambdaP_BarGamma.hh
	@@ -44,20 +44,20 @@
	private:
	// some constants to make the code easier to read and maintain
	// these three should be constants... (implementation of getMass() prohibits this)
	- double _mLambdab; // = 5.624; // Lambda_b mass
	- double _mLambda0; // = 1.115684; // Lambda0 mass
	- double _c7Eff; // = -0.31; // Wilson coefficient
	- double _mb; // = 4.4; // running b mass
	- double _mV; // = 5.42; // pole mass vector current
	- double _mA; // = 5.86; // pole mass axial current
	- double _GF; // = 1.166E-5; // Fermi constant
	- double _gLambdab; // = 16; // coupling constant Lambda_b -> B- p
	- double _e0; // = 1; // electromagnetic coupling (+1)
	- double _g1; // = 0.64; // heavy-light form factors at q_mSqare
	- double _g2; // = -0.10;
	- double _f1; // = 0.64;
	- double _f2; // = -0.31;
	- double _VtbVtsStar; // = 0.038; // \|V_tb V_ts^*\|
	+ double m_mLambdab; // = 5.624; // Lambda_b mass
	+ double m_mLambda0; // = 1.115684; // Lambda0 mass
	+ double m_c7Eff; // = -0.31; // Wilson coefficient
	+ double m_mb; // = 4.4; // running b mass
	+ double m_mV; // = 5.42; // pole mass vector current
	+ double m_mA; // = 5.86; // pole mass axial current
	+ double m_GF; // = 1.166E-5; // Fermi constant
	+ double m_gLambdab; // = 16; // coupling constant Lambda_b -> B- p
	+ double m_e0; // = 1; // electromagnetic coupling (+1)
	+ double m_g1; // = 0.64; // heavy-light form factors at q_mSqare
	+ double m_g2; // = -0.10;
	+ double m_f1; // = 0.64;
	+ double m_f2; // = -0.31;
	+ double m_VtbVtsStar; // = 0.038; // \|V_tb V_ts^*\|

	// user never needs to call this -> private
	// baryonic form factors f(p), g(p), at p=0
	diff --git a/EvtGenModels/EvtLambdacPHH.hh b/EvtGenModels/EvtLambdacPHH.hh
	--- a/EvtGenModels/EvtLambdacPHH.hh
	+++ b/EvtGenModels/EvtLambdacPHH.hh
	@@ -47,7 +47,7 @@

	protected:
	// Resonance enumeration
	- enum LcResLabel
	+ enum class LcResLabel
	{
	NonReson = 0,
	Kstar,
	@@ -82,22 +82,22 @@

	private:
	// Daughter ordering for K-, pi+, p
	- int _d1, _d2, _d3;
	+ int m_d1, m_d2, m_d3;

	// Resonance parameters
	- double _Nplusplus, _Nplusminus, _Nminusplus, _Nminusminus;
	- double _phiNplusplus, _phiNplusminus, _phiNminusplus, _phiNminusminus;
	- double _E1, _phiE1, _E2, _phiE2, _E3, _phiE3, _E4, _phiE4;
	- double _F1, _phiF1, _F2, _phiF2, _H1, _phiH1, _H2, _phiH2;
	-
	- double _NRNorm, _KstarNorm, _DeltaNorm, _LambdaNorm;
	- double _KstarM, _KstarW, _KstarR;
	- double _DeltaM, _DeltaW, _DeltaR;
	- double _LambdaM, _LambdaW, _LambdaR;
	- double _Lambda_cR;
	-
	- EvtVector4R _zprime, _p4_Lambda_c;
	- double _zpMag, _p4_Lambdac_Mag;
	+ double m_Nplusplus, m_Nplusminus, m_Nminusplus, m_Nminusminus;
	+ double m_phiNplusplus, m_phiNplusminus, m_phiNminusplus, m_phiNminusminus;
	+ double m_E1, m_phiE1, m_E2, m_phiE2, m_E3, m_phiE3, m_E4, m_phiE4;
	+ double m_F1, m_phiF1, m_F2, m_phiF2, m_H1, m_phiH1, m_H2, m_phiH2;
	+
	+ double m_NRNorm, m_KstarNorm, m_DeltaNorm, m_LambdaNorm;
	+ double m_KstarM, m_KstarW, m_KstarR;
	+ double m_DeltaM, m_DeltaW, m_DeltaR;
	+ double m_LambdaM, m_LambdaW, m_LambdaR;
	+ double m_Lambda_cR;
	+
	+ EvtVector4R m_zprime, m_p4_Lambda_c;
	+ double m_zpMag, m_p4_Lambdac_Mag;
	};

	#endif
	diff --git a/EvtGenModels/EvtLb2Baryonlnu.hh b/EvtGenModels/EvtLb2Baryonlnu.hh
	--- a/EvtGenModels/EvtLb2Baryonlnu.hh
	+++ b/EvtGenModels/EvtLb2Baryonlnu.hh
	@@ -45,8 +45,8 @@
	void init() override;

	private:
	- EvtSemiLeptonicFF* ffmodel;
	- EvtSLBaryonAmp* calcamp;
	+ EvtSemiLeptonicFF* m_ffmodel;
	+ EvtSLBaryonAmp* m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtLb2plnuLCSR.hh b/EvtGenModels/EvtLb2plnuLCSR.hh
	--- a/EvtGenModels/EvtLb2plnuLCSR.hh
	+++ b/EvtGenModels/EvtLb2plnuLCSR.hh
	@@ -47,8 +47,8 @@
	void init() override;

	private:
	- EvtSemiLeptonicFF* ffmodel;
	- EvtSLBaryonAmp* calcamp;
	+ EvtSemiLeptonicFF* m_ffmodel;
	+ EvtSLBaryonAmp* m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtLb2plnuLQCD.hh b/EvtGenModels/EvtLb2plnuLQCD.hh
	--- a/EvtGenModels/EvtLb2plnuLQCD.hh
	+++ b/EvtGenModels/EvtLb2plnuLQCD.hh
	@@ -47,8 +47,8 @@
	void init() override;

	private:
	- EvtSemiLeptonicFF* ffmodel;
	- EvtSLBaryonAmp* calcamp;
	+ EvtSemiLeptonicFF* m_ffmodel;
	+ EvtSLBaryonAmp* m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtMelikhov.hh b/EvtGenModels/EvtMelikhov.hh
	--- a/EvtGenModels/EvtMelikhov.hh
	+++ b/EvtGenModels/EvtMelikhov.hh
	@@ -41,8 +41,8 @@
	void initProbMax() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> Melikhovffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_Melikhovffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtMelikhovFF.hh b/EvtGenModels/EvtMelikhovFF.hh
	--- a/EvtGenModels/EvtMelikhovFF.hh
	+++ b/EvtGenModels/EvtMelikhovFF.hh
	@@ -49,7 +49,7 @@
	double, double, double, double, double* ) override;

	private:
	- int whichfit;
	+ int m_whichfit;
	};

	#endif
	diff --git a/EvtGenModels/EvtPFermi.hh b/EvtGenModels/EvtPFermi.hh
	--- a/EvtGenModels/EvtPFermi.hh
	+++ b/EvtGenModels/EvtPFermi.hh
	@@ -27,8 +27,8 @@
	// the fermi motion distribution according to
	// hep-ph/9905351 v2
	// BLNP model:
	-// F(what,Lambda,b) = pow(_b,_b)/(tgamma(_b)_Lambda)pow(what/_Lambda,_b-1)*
	-// exp(-_b*what/Lambda);
	+// F(what,Lambda,b) = pow(b,b)/(tgamma(b)Lambda)pow(what/Lambda,b-1)*
	+// exp(-b*what/Lambda);
	// the leading order shape function (exp) (hep-ph/0504071)

	class EvtPFermi final {
	@@ -57,11 +57,11 @@

	// Data members

	- double _a;
	- double _mb;
	- double _mB;
	- double _Lambda;
	- double _b;
	+ double m_a;
	+ double m_mb;
	+ double m_mB;
	+ double m_Lambda;
	+ double m_b;
	};

	#endif // EVTPFERMI_HH
	diff --git a/EvtGenModels/EvtPartWave.hh b/EvtGenModels/EvtPartWave.hh
	--- a/EvtGenModels/EvtPartWave.hh
	+++ b/EvtGenModels/EvtPartWave.hh
	@@ -46,7 +46,7 @@
	private:
	void fillHelicity( int* lambda2, int n, int J2 );

	- std::unique_ptr<EvtEvalHelAmp> _evalHelAmp;
	+ std::unique_ptr<EvtEvalHelAmp> m_evalHelAmp;
	};

	#endif
	diff --git a/EvtGenModels/EvtPsi2JpsiPiPi.hh b/EvtGenModels/EvtPsi2JpsiPiPi.hh
	--- a/EvtGenModels/EvtPsi2JpsiPiPi.hh
	+++ b/EvtGenModels/EvtPsi2JpsiPiPi.hh
	@@ -43,12 +43,12 @@
	void decay( EvtParticle* p ) override;

	private:
	- bool tree;
	- double phi; // LO vs NLO mixing angle (radians)
	- double cosPhi, cos2Phi, sinPhi, sin2Phi;
	+ bool m_tree;
	+ double m_phi; // LO vs NLO mixing angle (radians)
	+ double m_cosPhi, m_cos2Phi, m_sinPhi, m_sin2Phi;
	// NLO corrections
	- static const int nQ = 6; // number of terms in mPiPi interpolation
	- std::array<double, nQ> c0, c1, c2, s1, s2;
	+ static const int m_nQ = 6; // number of terms in mPiPi interpolation
	+ std::array<double, m_nQ> m_c0, m_c1, m_c2, m_s1, m_s2;

	void setNLOArrays();
	};
	diff --git a/EvtGenModels/EvtRareLbToLll.hh b/EvtGenModels/EvtRareLbToLll.hh
	--- a/EvtGenModels/EvtRareLbToLll.hh
	+++ b/EvtGenModels/EvtRareLbToLll.hh
	@@ -62,7 +62,7 @@
	double m_poleSize{ 0.00005 };
	bool m_electronMode{ false };

	- std::unique_ptr<EvtRareLbToLllFFBase> ffmodel_;
	- std::unique_ptr<EvtRareLbToLllWC> wcmodel_;
	+ std::unique_ptr<EvtRareLbToLllFFBase> m_ffmodel;
	+ std::unique_ptr<EvtRareLbToLllWC> m_wcmodel;
	};
	#endif //
	diff --git a/EvtGenModels/EvtRareLbToLllFF.hh b/EvtGenModels/EvtRareLbToLllFF.hh
	--- a/EvtGenModels/EvtRareLbToLllFF.hh
	+++ b/EvtGenModels/EvtRareLbToLllFF.hh
	@@ -60,11 +60,11 @@
	void param( const double a0, const double a2, const double a4,
	const double al, const double ap );

	- double a0_;
	- double a2_;
	- double a4_;
	- double al_;
	- double ap_;
	+ double m_a0;
	+ double m_a2;
	+ double m_a4;
	+ double m_al;
	+ double m_ap;
	};

	class FormFactorSet final {
	@@ -73,22 +73,22 @@

	FormFactorSet( const FormFactorSet& other );

	- EvtRareLbToLllFF::FormFactorDependence F1;
	- EvtRareLbToLllFF::FormFactorDependence F2;
	- EvtRareLbToLllFF::FormFactorDependence F3;
	- EvtRareLbToLllFF::FormFactorDependence F4;
	-
	- EvtRareLbToLllFF::FormFactorDependence G1;
	- EvtRareLbToLllFF::FormFactorDependence G2;
	- EvtRareLbToLllFF::FormFactorDependence G3;
	- EvtRareLbToLllFF::FormFactorDependence G4;
	-
	- EvtRareLbToLllFF::FormFactorDependence H1;
	- EvtRareLbToLllFF::FormFactorDependence H2;
	- EvtRareLbToLllFF::FormFactorDependence H3;
	- EvtRareLbToLllFF::FormFactorDependence H4;
	- EvtRareLbToLllFF::FormFactorDependence H5;
	- EvtRareLbToLllFF::FormFactorDependence H6;
	+ EvtRareLbToLllFF::FormFactorDependence m_F1;
	+ EvtRareLbToLllFF::FormFactorDependence m_F2;
	+ EvtRareLbToLllFF::FormFactorDependence m_F3;
	+ EvtRareLbToLllFF::FormFactorDependence m_F4;
	+
	+ EvtRareLbToLllFF::FormFactorDependence m_G1;
	+ EvtRareLbToLllFF::FormFactorDependence m_G2;
	+ EvtRareLbToLllFF::FormFactorDependence m_G3;
	+ EvtRareLbToLllFF::FormFactorDependence m_G4;
	+
	+ EvtRareLbToLllFF::FormFactorDependence m_H1;
	+ EvtRareLbToLllFF::FormFactorDependence m_H2;
	+ EvtRareLbToLllFF::FormFactorDependence m_H3;
	+ EvtRareLbToLllFF::FormFactorDependence m_H4;
	+ EvtRareLbToLllFF::FormFactorDependence m_H5;
	+ EvtRareLbToLllFF::FormFactorDependence m_H6;
	};

	void init() override;
	@@ -100,8 +100,8 @@
	double func( const double p,
	const EvtRareLbToLllFF::FormFactorDependence& dep ) const;

	- std::array<std::unique_ptr<EvtRareLbToLllFF::FormFactorSet>, 2> FF_;
	- std::map<int, EvtRareLbToLllFF::FormFactorSet*> FFMap_;
	+ std::array<std::unique_ptr<EvtRareLbToLllFF::FormFactorSet>, 2> m_FF;
	+ std::map<int, EvtRareLbToLllFF::FormFactorSet*> m_FFMap;

	void DiracFF( const EvtParticle& parent, const EvtParticle& lambda,
	const EvtRareLbToLllFF::FormFactorSet& FFset,
	diff --git a/EvtGenModels/EvtRareLbToLllFFBase.hh b/EvtGenModels/EvtRareLbToLllFFBase.hh
	--- a/EvtGenModels/EvtRareLbToLllFFBase.hh
	+++ b/EvtGenModels/EvtRareLbToLllFFBase.hh
	@@ -46,10 +46,10 @@

	void areZero();

	- double F_[4];
	- double G_[4];
	- double FT_[4];
	- double GT_[4];
	+ double m_F[4];
	+ double m_G[4];
	+ double m_FT[4];
	+ double m_GT[4];
	};

	virtual void init() = 0;
	@@ -68,7 +68,7 @@
	double calculateVdotV( const EvtParticle&, const EvtParticle&,
	double qsq ) const;

	- EvtIdSet natural_;
	+ EvtIdSet m_natural;
	};

	#endif
	diff --git a/EvtGenModels/EvtRareLbToLllFFGutsche.hh b/EvtGenModels/EvtRareLbToLllFFGutsche.hh
	--- a/EvtGenModels/EvtRareLbToLllFFGutsche.hh
	+++ b/EvtGenModels/EvtRareLbToLllFFGutsche.hh
	@@ -49,13 +49,13 @@
	double formFactorParametrization( const double s, const double f0,
	const double a, const double b ) const;

	- double fVconsts[3][3];
	- double fAconsts[3][3];
	- double fTVconsts[3][3];
	- double fTAconsts[3][3];
	+ double m_Vconsts[3][3];
	+ double m_Aconsts[3][3];
	+ double m_TVconsts[3][3];
	+ double m_TAconsts[3][3];

	- const EvtIdSet fParents{ "Lambda_b0", "anti-Lambda_b0" };
	- const EvtIdSet fDaughters{ "Lambda0", "anti-Lambda0" };
	+ const EvtIdSet m_Parents{ "Lambda_b0", "anti-Lambda_b0" };
	+ const EvtIdSet m_Daughters{ "Lambda0", "anti-Lambda0" };
	};

	#endif // EVTRARELBTOLLLFF_HH
	diff --git a/EvtGenModels/EvtRareLbToLllFFlQCD.hh b/EvtGenModels/EvtRareLbToLllFFlQCD.hh
	--- a/EvtGenModels/EvtRareLbToLllFFlQCD.hh
	+++ b/EvtGenModels/EvtRareLbToLllFFlQCD.hh
	@@ -54,13 +54,13 @@
	const double a1, const double pole ) const;
	double zvar( const double q2 ) const;

	- double fconsts[3][3];
	- double gconsts[3][3];
	- double hconsts[3][3];
	- double htildaconsts[3][3];
	+ double m_fconsts[3][3];
	+ double m_gconsts[3][3];
	+ double m_hconsts[3][3];
	+ double m_htildaconsts[3][3];

	- double t0;
	- double tplus;
	+ double m_t0;
	+ double m_tplus;
	};

	#endif // EVTRARELBTOLLLFF_HH
	diff --git a/EvtGenModels/EvtSLBKPole.hh b/EvtGenModels/EvtSLBKPole.hh
	--- a/EvtGenModels/EvtSLBKPole.hh
	+++ b/EvtGenModels/EvtSLBKPole.hh
	@@ -41,8 +41,8 @@
	void init() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> SLBKPoleffmodel; //modified
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_SLBKPoleffmodel; //modified
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	};

	#endif
	diff --git a/EvtGenModels/EvtSLBKPoleFF.hh b/EvtGenModels/EvtSLBKPoleFF.hh
	--- a/EvtGenModels/EvtSLBKPoleFF.hh
	+++ b/EvtGenModels/EvtSLBKPoleFF.hh
	@@ -51,8 +51,8 @@
	double, double, double, double, double* ) override;

	private:
	- int numSLBKPoleargs; //modified
	- double SLBKPoleargs[16]; //modified
	+ int m_numSLBKPoleargs; //modified
	+ double m_SLBKPoleargs[16]; //modified
	};

	#endif
	diff --git a/EvtGenModels/EvtSLDiBaryonAmp.hh b/EvtGenModels/EvtSLDiBaryonAmp.hh
	--- a/EvtGenModels/EvtSLDiBaryonAmp.hh
	+++ b/EvtGenModels/EvtSLDiBaryonAmp.hh
	@@ -53,7 +53,7 @@
	const EvtVector4R& gMtmTerms, const EvtVector4R& fMtmTerms ) const;

	private:
	- EvtBToDiBaryonlnupQCDFF ffModel_;
	+ EvtBToDiBaryonlnupQCDFF m_ffModel;
	};

	#endif
	diff --git a/EvtGenModels/EvtSLPole.hh b/EvtGenModels/EvtSLPole.hh
	--- a/EvtGenModels/EvtSLPole.hh
	+++ b/EvtGenModels/EvtSLPole.hh
	@@ -39,10 +39,10 @@
	void init() override;

	private:
	- std::unique_ptr<EvtSemiLeptonicFF> SLPoleffmodel;
	- std::unique_ptr<EvtSemiLeptonicAmp> calcamp;
	+ std::unique_ptr<EvtSemiLeptonicFF> m_SLPoleffmodel;
	+ std::unique_ptr<EvtSemiLeptonicAmp> m_calcamp;
	//special case - reset the daughter masses
	- bool _resetDaughterTree;
	+ bool m_resetDaughterTree;
	};

	#endif
	diff --git a/EvtGenModels/EvtSLPoleFF.hh b/EvtGenModels/EvtSLPoleFF.hh
	--- a/EvtGenModels/EvtSLPoleFF.hh
	+++ b/EvtGenModels/EvtSLPoleFF.hh
	@@ -47,8 +47,8 @@
	double, double, double, double, double* ) override;

	private:
	- int numSLPoleargs;
	- double SLPoleargs[16];
	+ int m_numSLPoleargs;
	+ double m_SLPoleargs[16];
	};

	#endif
	diff --git a/EvtGenModels/EvtSSDCP.hh b/EvtGenModels/EvtSSDCP.hh
	--- a/EvtGenModels/EvtSSDCP.hh
	+++ b/EvtGenModels/EvtSSDCP.hh
	@@ -44,29 +44,29 @@
	private:
	//Arguments

	- double _dm;
	+ double m_dm;

	- double _dgog;
	+ double m_dgog;

	- EvtComplex _qoverp;
	- EvtComplex _poverq;
	- EvtComplex _z; //FS CPTV parameter
	+ EvtComplex m_qoverp;
	+ EvtComplex m_poverq;
	+ EvtComplex m_z; //FS CPTV parameter

	// FS commented next line becuse not used
	- // int _cp;
	+ // int m_cp;

	- EvtComplex _A_f;
	- EvtComplex _Abar_f;
	+ EvtComplex m_A_f;
	+ EvtComplex m_Abar_f;

	- EvtComplex _A_fbar;
	- EvtComplex _Abar_fbar;
	+ EvtComplex m_A_fbar;
	+ EvtComplex m_Abar_fbar;

	//Derived quantities

	- double _gamma;
	- double _dgamma;
	+ double m_gamma;
	+ double m_dgamma;

	- bool _eigenstate;
	+ bool m_eigenstate;
	};

	#endif
	diff --git a/EvtGenModels/EvtSSD_DirectCP.hh b/EvtGenModels/EvtSSD_DirectCP.hh
	--- a/EvtGenModels/EvtSSD_DirectCP.hh
	+++ b/EvtGenModels/EvtSSD_DirectCP.hh
	@@ -47,7 +47,7 @@

	//Arguments

	- double _acp;
	+ double m_acp;
	};

	#endif
	diff --git a/EvtGenModels/EvtSSSCPT.hh b/EvtGenModels/EvtSSSCPT.hh
	--- a/EvtGenModels/EvtSSSCPT.hh
	+++ b/EvtGenModels/EvtSSSCPT.hh
	@@ -36,8 +36,8 @@

	private:
	// Amplitude coeffs
	- EvtComplex A, Abar;
	- EvtComplex P, Q, D, Im;
	+ EvtComplex m_A, m_Abar;
	+ EvtComplex m_P, m_Q, m_D, m_Im;
	// Set amplitude coeffs from decay model params
	void setAmpCoeffs();
	};
	diff --git a/EvtGenModels/EvtSVP.hh b/EvtGenModels/EvtSVP.hh
	--- a/EvtGenModels/EvtSVP.hh
	+++ b/EvtGenModels/EvtSVP.hh
	@@ -45,7 +45,7 @@
	private:
	void decay_2body( EvtParticle* p );
	void decay_3body( EvtParticle* p );
	- double delta; // form factor parameter
	+ double m_delta; // form factor parameter
	};

	#endif
	diff --git a/EvtGenModels/EvtSVSCPLH.hh b/EvtGenModels/EvtSVSCPLH.hh
	--- a/EvtGenModels/EvtSVSCPLH.hh
	+++ b/EvtGenModels/EvtSVSCPLH.hh
	@@ -41,11 +41,11 @@
	void decay( EvtParticle* p ) override;

	private:
	- EvtComplex _Af, _Abarf;
	- EvtComplex _qop, _poq;
	+ EvtComplex m_Af, m_Abarf;
	+ EvtComplex m_qop, m_poq;

	- double _dm;
	- double _dgamma;
	+ double m_dm;
	+ double m_dgamma;
	};

	#endif
	diff --git a/EvtGenModels/EvtSVSCPiso.hh b/EvtGenModels/EvtSVSCPiso.hh
	--- a/EvtGenModels/EvtSVSCPiso.hh
	+++ b/EvtGenModels/EvtSVSCPiso.hh
	@@ -43,16 +43,16 @@

	private:
	// Amplitude coefficients
	- EvtComplex Tp0, Tp0_bar, T0p, T0p_bar;
	- EvtComplex Tpm, Tpm_bar, Tmp, Tmp_bar;
	- EvtComplex P1, P1_bar, P0, P0_bar;
	+ EvtComplex m_Tp0, m_Tp0_bar, m_T0p, m_T0p_bar;
	+ EvtComplex m_Tpm, m_Tpm_bar, m_Tmp, m_Tmp_bar;
	+ EvtComplex m_P1, m_P1_bar, m_P0, m_P0_bar;

	// Amplitudes
	- EvtComplex A_f, Abar_f;
	- EvtComplex A_fbar, Abar_fbar;
	- EvtComplex Apm, Apm_bar, Amp, Amp_bar;
	+ EvtComplex m_A_f, m_Abar_f;
	+ EvtComplex m_A_fbar, m_Abar_fbar;
	+ EvtComplex m_Apm, m_Apm_bar, m_Amp, m_Amp_bar;
	// Charged mode flag
	- int charged{ 0 };
	+ int m_charged{ 0 };

	// Set amplitude coeffs from decay model pars
	void setAmpCoeffs();
	diff --git a/EvtGenModels/EvtSVSNONCPEIGEN.hh b/EvtGenModels/EvtSVSNONCPEIGEN.hh
	--- a/EvtGenModels/EvtSVSNONCPEIGEN.hh
	+++ b/EvtGenModels/EvtSVSNONCPEIGEN.hh
	@@ -36,14 +36,14 @@
	void decay( EvtParticle* p ) override;

	private:
	- EvtComplex _A_f;
	- EvtComplex _Abar_f;
	+ EvtComplex m_A_f;
	+ EvtComplex m_Abar_f;

	- EvtComplex _A_fbar;
	- EvtComplex _Abar_fbar;
	+ EvtComplex m_A_fbar;
	+ EvtComplex m_Abar_fbar;

	- double _dm;
	- double _phickm;
	+ double m_dm;
	+ double m_phickm;
	};

	#endif
	diff --git a/EvtGenModels/EvtSVVHelCPMix.hh b/EvtGenModels/EvtSVVHelCPMix.hh
	--- a/EvtGenModels/EvtSVVHelCPMix.hh
	+++ b/EvtGenModels/EvtSVVHelCPMix.hh
	@@ -54,24 +54,25 @@

	void init() override;

	- EvtComplex hp;
	- EvtComplex h0;
	- EvtComplex hm;
	- double averageM;
	- double deltaM;
	- double gamma;
	- double deltagamma;
	- EvtComplex strongphase1;
	- EvtComplex strongphase2;
	- EvtComplex weakmixingphase;
	- EvtComplex weakdirectphase;
	-
	void initProbMax() override;

	void decay( EvtParticle* p ) override;

	std::string getParamName( int i ) override;
	std::string getParamDefault( int i ) override;
	+
	+ private:
	+ EvtComplex m_hp;
	+ EvtComplex m_h0;
	+ EvtComplex m_hm;
	+ double m_averageM;
	+ double m_deltaM;
	+ double m_gamma;
	+ double m_deltagamma;
	+ EvtComplex m_strongphase1;
	+ EvtComplex m_strongphase2;
	+ EvtComplex m_weakmixingphase;
	+ EvtComplex m_weakdirectphase;
	};

	#endif
	diff --git a/EvtGenModels/EvtSVVNONCPEIGEN.hh b/EvtGenModels/EvtSVVNONCPEIGEN.hh
	--- a/EvtGenModels/EvtSVVNONCPEIGEN.hh
	+++ b/EvtGenModels/EvtSVVNONCPEIGEN.hh
	@@ -76,7 +76,7 @@
	std::string getParamDefault( int i ) override;

	private:
	- EvtComplex _A_f[12];
	+ EvtComplex m_A_f[12];
	};

	#endif
	diff --git a/EvtGenModels/EvtSingleParticle.hh b/EvtGenModels/EvtSingleParticle.hh
	--- a/EvtGenModels/EvtSingleParticle.hh
	+++ b/EvtGenModels/EvtSingleParticle.hh
	@@ -39,9 +39,9 @@
	void initProbMax() override;

	private:
	- double pmin, pmax;
	- double cthetamin, cthetamax;
	- double phimin, phimax;
	+ double m_pmin, m_pmax;
	+ double m_cthetamin, m_cthetamax;
	+ double m_phimin, m_phimax;
	};

	#endif
	diff --git a/EvtGenModels/EvtTVP.hh b/EvtGenModels/EvtTVP.hh
	--- a/EvtGenModels/EvtTVP.hh
	+++ b/EvtGenModels/EvtTVP.hh
	@@ -46,7 +46,7 @@
	private:
	void decay_2body( EvtParticle* p );
	void decay_3body( EvtParticle* p );
	- double delta; // form factor parameter
	+ double m_delta; // form factor parameter
	};

	#endif
	diff --git a/EvtGenModels/EvtTauHadnu.hh b/EvtGenModels/EvtTauHadnu.hh
	--- a/EvtGenModels/EvtTauHadnu.hh
	+++ b/EvtGenModels/EvtTauHadnu.hh
	@@ -37,13 +37,13 @@
	void decay( EvtParticle* p ) override;

	private:
	- double _beta;
	- double _mRho;
	- double _gammaRho;
	- double _mRhopr;
	- double _gammaRhopr;
	- double _mA1;
	- double _gammaA1;
	+ double m_beta;
	+ double m_mRho;
	+ double m_gammaRho;
	+ double m_mRhopr;
	+ double m_gammaRhopr;
	+ double m_mA1;
	+ double m_gammaA1;

	double gFunc( double m2, int dupD );
	EvtComplex Fpi( double s, double xm1, double xm2 );
	diff --git a/EvtGenModels/EvtVSSBMixCPT.hh b/EvtGenModels/EvtVSSBMixCPT.hh
	--- a/EvtGenModels/EvtVSSBMixCPT.hh
	+++ b/EvtGenModels/EvtVSSBMixCPT.hh
	@@ -45,19 +45,19 @@
	std::string getParamDefault( int i ) override;

	private:
	- double _freq; // mixing frequency in hbar/mm
	- double _dGamma;
	- EvtComplex _qoverp;
	- EvtComplex _poverq;
	- EvtComplex _z;
	- double _chib0_b0bar;
	- double _chib0bar_b0;
	-
	- EvtComplex _A_f;
	- EvtComplex _Abar_f;
	-
	- EvtComplex _A_fbar;
	- EvtComplex _Abar_fbar;
	+ double m_freq; // mixing frequency in hbar/mm
	+ double m_dGamma;
	+ EvtComplex m_qoverp;
	+ EvtComplex m_poverq;
	+ EvtComplex m_z;
	+ double m_chib0_b0bar;
	+ double m_chib0bar_b0;
	+
	+ EvtComplex m_A_f;
	+ EvtComplex m_Abar_f;
	+
	+ EvtComplex m_A_fbar;
	+ EvtComplex m_Abar_fbar;
	};

	#endif
	diff --git a/EvtGenModels/EvtVVP.hh b/EvtGenModels/EvtVVP.hh
	--- a/EvtGenModels/EvtVVP.hh
	+++ b/EvtGenModels/EvtVVP.hh
	@@ -46,7 +46,7 @@
	private:
	void decay_2body( EvtParticle* p );
	void decay_3body( EvtParticle* p );
	- double delta; // form factor parameter
	+ double m_delta; // form factor parameter
	};

	#endif
	diff --git a/EvtGenModels/EvtVectorIsr.hh b/EvtGenModels/EvtVectorIsr.hh
	--- a/EvtGenModels/EvtVectorIsr.hh
	+++ b/EvtGenModels/EvtVectorIsr.hh
	@@ -48,9 +48,9 @@
	double& e02, double& f );

	private:
	- double csfrmn, csbkmn;
	- double fmax;
	- bool firstorder;
	+ double m_csfrmn, m_csbkmn;
	+ double m_fmax;
	+ bool m_firstorder;
	};

	#endif
	diff --git a/EvtGenModels/EvtVub.hh b/EvtGenModels/EvtVub.hh
	--- a/EvtGenModels/EvtVub.hh
	+++ b/EvtGenModels/EvtVub.hh
	@@ -47,18 +47,18 @@
	void decay( EvtParticle* p ) override;

	private:
	- double _mb; // the b-quark pole mass in GeV (try 4.65 to 4.9)
	- double _a; // Parameter for the Fermi Motion (1.29 is good)
	- double _alphas; // Strong Coupling at m_b (around 0.24)
	- double _dGMax; // max dGamma*p2 value;
	- int _nbins;
	- int _storeQplus;
	- std::vector<double> _masses;
	- std::vector<double> _weights;
	+ double m_mb; // the b-quark pole mass in GeV (try 4.65 to 4.9)
	+ double m_a; // Parameter for the Fermi Motion (1.29 is good)
	+ double m_alphas; // Strong Coupling at m_b (around 0.24)
	+ double m_dGMax; // max dGamma*p2 value;
	+ int m_nbins;
	+ int m_storeQplus;
	+ std::vector<double> m_masses;
	+ std::vector<double> m_weights;

	- std::unique_ptr<EvtVubdGamma> _dGamma; // calculates the decay rate
	+ std::unique_ptr<EvtVubdGamma> m_dGamma; // calculates the decay rate
	double findPFermi();
	- std::vector<double> _pf;
	+ std::vector<double> m_pf;
	};

	#endif
	diff --git a/EvtGenModels/EvtVubBLNP.hh b/EvtGenModels/EvtVubBLNP.hh
	--- a/EvtGenModels/EvtVubBLNP.hh
	+++ b/EvtGenModels/EvtVubBLNP.hh
	@@ -44,61 +44,61 @@

	private:
	// Input parameters
	- double mBB;
	- double lambda2;
	+ double m_mBB;
	+ double m_lambda2;

	// Shape function parameters
	- double b;
	- double Lambda;
	- double Ecut;
	- double wzero;
	+ double m_b;
	+ double m_Lambda;
	+ double m_Ecut;
	+ double m_wzero;

	// SF and SSF modes
	- int itype;
	- double dtype;
	- int isubl;
	+ int m_itype;
	+ double m_dtype;
	+ int m_isubl;

	// flags
	- int flag1;
	- int flag2;
	- int flag3;
	+ int m_flag1;
	+ int m_flag2;
	+ int m_flag3;

	// Quark mass
	- double mb;
	+ double m_mb;

	// Matching scales
	- double muh;
	- double mui;
	- double mubar;
	+ double m_muh;
	+ double m_mui;
	+ double m_mubar;

	// Perturbative quantities
	- double CF;
	- double CA;
	+ double m_CF;
	+ double m_CA;

	- double beta0;
	- double beta1;
	- double beta2;
	+ double m_beta0;
	+ double m_beta1;
	+ double m_beta2;

	- double zeta3;
	+ double m_zeta3;

	- double Gamma0;
	- double Gamma1;
	- double Gamma2;
	+ double m_Gamma0;
	+ double m_Gamma1;
	+ double m_Gamma2;

	- double gp0;
	- double gp1;
	+ double m_gp0;
	+ double m_gp1;

	- double Lbar;
	- double mupisq;
	- double moment2;
	+ double m_Lbar;
	+ double m_mupisq;
	+ double m_moment2;

	- int flagpower;
	- int flag2loop;
	+ int m_flagpower;
	+ int m_flag2loop;

	- int maxLoop;
	- double precision;
	+ int m_maxLoop;
	+ double m_precision;

	- std::vector<double> gvars;
	+ std::vector<double> m_gvars;

	double rate3( double Pp, double Pl, double Pm );
	double F1( double Pp, double Pm, double muh, double mui, double mubar,
	@@ -144,7 +144,7 @@
	static double gamser( double a, double x, double LogGamma );
	static double gammcf( double a, double x, double LogGamma );
	double findBLNPWhat();
	- std::vector<double> _pf;
	+ std::vector<double> m_pf;
	};

	#endif
	diff --git a/EvtGenModels/EvtVubBLNPHybrid.hh b/EvtGenModels/EvtVubBLNPHybrid.hh
	--- a/EvtGenModels/EvtVubBLNPHybrid.hh
	+++ b/EvtGenModels/EvtVubBLNPHybrid.hh
	@@ -65,71 +65,71 @@
	nParameters = 10,
	nVariables = 3
	};
	- bool _noHybrid = false;
	- bool _storeWhat = true;
	- int _nbins = 0;
	- double _masscut = 0.28;
	- std::vector<double> _bins_mX;
	- std::vector<double> _bins_q2;
	- std::vector<double> _bins_El;
	- std::vector<double> _weights;
	+ bool m_noHybrid = false;
	+ bool m_storeWhat = true;
	+ int m_nbins = 0;
	+ double m_masscut = 0.28;
	+ std::vector<double> m_bins_mX;
	+ std::vector<double> m_bins_q2;
	+ std::vector<double> m_bins_El;
	+ std::vector<double> m_weights;

	// Input parameters
	- double mBB;
	- double lambda2;
	+ double m_mBB;
	+ double m_lambda2;

	// Shape function parameters
	- double b;
	- double Lambda;
	- double Ecut;
	- double wzero;
	+ double m_b;
	+ double m_Lambda;
	+ double m_Ecut;
	+ double m_wzero;

	// SF and SSF modes
	- int itype;
	- double dtype;
	- int isubl;
	+ int m_itype;
	+ double m_dtype;
	+ int m_isubl;

	// flags
	- int flag1;
	- int flag2;
	- int flag3;
	+ int m_flag1;
	+ int m_flag2;
	+ int m_flag3;

	// Quark mass
	- double mb;
	+ double m_mb;

	// Matching scales
	- double muh;
	- double mui;
	- double mubar;
	+ double m_muh;
	+ double m_mui;
	+ double m_mubar;

	// Perturbative quantities
	- double CF;
	- double CA;
	+ double m_CF;
	+ double m_CA;

	- double beta0;
	- double beta1;
	- double beta2;
	+ double m_beta0;
	+ double m_beta1;
	+ double m_beta2;

	- double zeta3;
	+ double m_zeta3;

	- double Gamma0;
	- double Gamma1;
	- double Gamma2;
	+ double m_Gamma0;
	+ double m_Gamma1;
	+ double m_Gamma2;

	- double gp0;
	- double gp1;
	+ double m_gp0;
	+ double m_gp1;

	- double Lbar;
	- double mupisq;
	- double moment2;
	+ double m_Lbar;
	+ double m_mupisq;
	+ double m_moment2;

	- int flagpower;
	- int flag2loop;
	+ int m_flagpower;
	+ int m_flag2loop;

	- int maxLoop;
	- double precision;
	+ int m_maxLoop;
	+ double m_precision;

	- std::vector<double> gvars;
	+ std::vector<double> m_gvars;

	double rate3( double Pp, double Pl, double Pm );
	double F1( double Pp, double Pm, double muh, double mui, double mubar,
	@@ -175,7 +175,7 @@
	static double gamser( double a, double x, double LogGamma );
	static double gammcf( double a, double x, double LogGamma );
	double findBLNPWhat();
	- std::vector<double> _pf;
	+ std::vector<double> m_pf;
	};

	#endif
	diff --git a/EvtGenModels/EvtVubHybrid.hh b/EvtGenModels/EvtVubHybrid.hh
	--- a/EvtGenModels/EvtVubHybrid.hh
	+++ b/EvtGenModels/EvtVubHybrid.hh
	@@ -69,23 +69,23 @@
	nVariables = 3
	};

	- bool _noHybrid =
	- false; // _noHybrid will be set TRUE if the DECAY.DEC file has no binning or weights
	- bool _storeQplus =
	- true; // _storeQplus should alwasy be TRUE: writes out Fermi motion parameter
	-
	- double _mb = 4.62; // the b-quark pole mass in GeV (try 4.65 to 4.9)
	- double _a = 2.27; // Parameter for the Fermi Motion (1.29 is good)
	- double _alphas = 0.22; // Strong Coupling at m_b (around 0.24)
	- double _dGMax = 3.; // max dGamma*p2 value;
	- int _nbins = 0;
	- double _masscut = 0.28;
	- std::vector<double> _bins_mX;
	- std::vector<double> _bins_q2;
	- std::vector<double> _bins_El;
	- std::vector<double> _weights;
	- std::unique_ptr<EvtVubdGamma> _dGamma; // calculates the decay rate
	- std::vector<double> _pf;
	+ bool m_noHybrid =
	+ false; // m_noHybrid will be set TRUE if the DECAY.DEC file has no binning or weights
	+ bool m_storeQplus =
	+ true; // m_storeQplus should alwasy be TRUE: writes out Fermi motion parameter
	+
	+ double m_mb = 4.62; // the b-quark pole mass in GeV (try 4.65 to 4.9)
	+ double m_a = 2.27; // Parameter for the Fermi Motion (1.29 is good)
	+ double m_alphas = 0.22; // Strong Coupling at m_b (around 0.24)
	+ double m_dGMax = 3.; // max dGamma*p2 value;
	+ int m_nbins = 0;
	+ double m_masscut = 0.28;
	+ std::vector<double> m_bins_mX;
	+ std::vector<double> m_bins_q2;
	+ std::vector<double> m_bins_El;
	+ std::vector<double> m_weights;
	+ std::unique_ptr<EvtVubdGamma> m_dGamma; // calculates the decay rate
	+ std::vector<double> m_pf;
	};

	#endif
	diff --git a/EvtGenModels/EvtVubNLO.hh b/EvtGenModels/EvtVubNLO.hh
	--- a/EvtGenModels/EvtVubNLO.hh
	+++ b/EvtGenModels/EvtVubNLO.hh
	@@ -51,23 +51,23 @@

	private:
	// cache
	- double _lbar;
	- double _mupi2;
	-
	- double _mb; // the b-quark pole mass in GeV
	- double _mB;
	- double _lambdaSF;
	- double _b; // Parameter for the Fermi Motion
	- double _kpar;
	- double _mui; // renormalization scale (preferred value=1.5 GeV)
	- double _SFNorm; // SF normalization
	- double _dGMax; // max dGamma*p2 value;
	- int _idSF; // which shape function?
	- std::vector<double> _masses;
	- std::vector<double> _weights;
	-
	- double _gmax;
	- int _ngood, _ntot;
	+ double m_lbar;
	+ double m_mupi2;
	+
	+ double m_mb; // the b-quark pole mass in GeV
	+ double m_mB;
	+ double m_lambdaSF;
	+ double m_b; // Parameter for the Fermi Motion
	+ double m_kpar;
	+ double m_mui; // renormalization scale (preferred value=1.5 GeV)
	+ double m_SFNorm; // SF normalization
	+ double m_dGMax; // max dGamma*p2 value;
	+ int m_idSF; // which shape function?
	+ std::vector<double> m_masses;
	+ std::vector<double> m_weights;
	+
	+ double m_gmax;
	+ int m_ngood, m_ntot;

	double tripleDiff( double pp, double pl, double pm );
	double SFNorm( const std::vector<double>& coeffs );
	@@ -90,10 +90,10 @@
	static double Gamma( double z, double tmax );

	// theory parameters
	- inline double mu_i() { return _mui; } // intermediate scale
	- inline double mu_bar() { return _mui; }
	- inline double mu_h() { return _mb / sqrt( 2.0 ); } // high scale
	- inline double lambda1() { return -_mupi2; }
	+ inline double mu_i() { return m_mui; } // intermediate scale
	+ inline double mu_bar() { return m_mui; }
	+ inline double mu_h() { return m_mb / sqrt( 2.0 ); } // high scale
	+ inline double lambda1() { return -m_mupi2; }

	// expansion coefficients for RGE
	static double beta0( int nf = 4 ) { return 11. - 2. / 3. * nf; }
	@@ -127,11 +127,11 @@

	// Shape Functions

	- inline double lambda_SF() { return _lambdaSF; }
	+ inline double lambda_SF() { return m_lambdaSF; }
	double lambda_bar( double omega0 );
	inline double lambda2() { return 0.12; }
	double mu_pi2( double omega0 );
	- inline double lambda( double ) { return _mB - _mb; }
	+ inline double lambda( double ) { return m_mB - m_mb; }

	// specail for gaussian SF
	static double cGaus( double b )
	@@ -213,14 +213,14 @@
	inline double U1( double mu1, double mu2, double epsi = 0 )
	{
	return exp( 2 * ( Sudakov( mu1, mu2, epsi ) - agammap( mu1, mu2, epsi ) -
	- aGamma( mu1, mu2, epsi ) * log( _mb / mu1 ) ) );
	+ aGamma( mu1, mu2, epsi ) * log( m_mb / mu1 ) ) );
	}
	inline double U1lo( double mu1, double mu2 ) { return U1( mu1, mu2 ); }
	inline double U1nlo( double mu1, double mu2 )
	{
	return U1( mu1, mu2 ) *
	( 1 + 2 * ( dSudakovdepsi( mu1, mu2 ) - dgpdepsi( mu1, mu2 ) -
	- log( _mb / mu1 ) * dGdepsi( mu1, mu2 ) ) );
	+ log( m_mb / mu1 ) * dGdepsi( mu1, mu2 ) ) );
	}
	inline double alo( double mu1, double mu2 )
	{
	diff --git a/EvtGenModels/EvtVubdGamma.hh b/EvtGenModels/EvtVubdGamma.hh
	--- a/EvtGenModels/EvtVubdGamma.hh
	+++ b/EvtGenModels/EvtVubdGamma.hh
	@@ -81,10 +81,10 @@

	// Data members

	- double _alphas;
	- double _epsilon1;
	- double _epsilon2;
	- double _epsilon3;
	+ double m_alphas;
	+ double m_epsilon1;
	+ double m_epsilon2;
	+ double m_epsilon3;
	};

	#endif // EVTVUBDGAMMA_HH
	diff --git a/EvtGenModels/EvtWHad.hh b/EvtGenModels/EvtWHad.hh
	--- a/EvtGenModels/EvtWHad.hh
	+++ b/EvtGenModels/EvtWHad.hh
	@@ -124,8 +124,8 @@
	const EvtVector4R& p5 ) const;

	private:
	- std::vector<double> mRho_, gamma0_, cK_, mK_, gammaK_, gKRho_, gKPi_;
	- double mPi_, mPiSq_;
	+ std::vector<double> m_mRho, m_gamma0, m_cK, m_mK, m_gammaK, m_gKRho, m_gKPi;
	+ double m_mPi, m_mPiSq;
	};

	#endif
	diff --git a/EvtGenModels/EvtWilsonCoefficients.hh b/EvtGenModels/EvtWilsonCoefficients.hh
	--- a/EvtGenModels/EvtWilsonCoefficients.hh
	+++ b/EvtGenModels/EvtWilsonCoefficients.hh
	@@ -155,7 +155,7 @@
	m_C8eff0, m_C9, m_C9tilda, m_C10, m_C10tilda, m_P0;
	double m_A, m_B, m_C, m_D, m_E, m_F, m_Y, m_Z, m_PE;

	- double k[6][8], a[8], h[8], p[8], r[2][8], s[8], q[8], g[8];
	+ double m_k[6][8], m_a[8], m_h[8], m_p[8], m_r[2][8], m_s[8], m_q[8], m_g[8];
	};

	#endif
	diff --git a/EvtGenModels/EvtbTosllAli.hh b/EvtGenModels/EvtbTosllAli.hh
	--- a/EvtGenModels/EvtbTosllAli.hh
	+++ b/EvtGenModels/EvtbTosllAli.hh
	@@ -42,9 +42,9 @@
	void initProbMax() override;

	private:
	- std::unique_ptr<EvtbTosllFF> _aliffmodel;
	- std::unique_ptr<EvtbTosllAmp> _calcamp;
	- double _poleSize;
	+ std::unique_ptr<EvtbTosllFF> m_aliffmodel;
	+ std::unique_ptr<EvtbTosllAmp> m_calcamp;
	+ double m_poleSize;
	};

	#endif
	diff --git a/EvtGenModels/EvtbTosllBall.hh b/EvtGenModels/EvtbTosllBall.hh
	--- a/EvtGenModels/EvtbTosllBall.hh
	+++ b/EvtGenModels/EvtbTosllBall.hh
	@@ -41,9 +41,9 @@
	void initProbMax() override;

	private:
	- std::unique_ptr<EvtbTosllAmp> _calcamp;
	- std::unique_ptr<EvtbTosllFF> _ballffmodel;
	- double _poleSize;
	+ std::unique_ptr<EvtbTosllAmp> m_calcamp;
	+ std::unique_ptr<EvtbTosllFF> m_ballffmodel;
	+ double m_poleSize;
	};

	#endif
	diff --git a/EvtGenModels/EvtbTosllBallFF.hh b/EvtGenModels/EvtbTosllBallFF.hh
	--- a/EvtGenModels/EvtbTosllBallFF.hh
	+++ b/EvtGenModels/EvtbTosllBallFF.hh
	@@ -39,7 +39,7 @@
	double& t2, double& t3 ) override;

	private:
	- int _theFFModel;
	+ int m_theFFModel;
	};

	#endif
	diff --git a/EvtGenModels/EvtbTosllMS.hh b/EvtGenModels/EvtbTosllMS.hh
	--- a/EvtGenModels/EvtbTosllMS.hh
	+++ b/EvtGenModels/EvtbTosllMS.hh
	@@ -48,9 +48,9 @@
	void decay( EvtParticle* p ) override;

	private:
	- EvtbTosllFFNew* _msffmodel;
	- EvtbTosllAmpNew* _calcamp;
	- EvtbTosllWilsCoeffNLO* _wilscoeff;
	+ EvtbTosllFFNew* m_msffmodel;
	+ EvtbTosllAmpNew* m_calcamp;
	+ EvtbTosllWilsCoeffNLO* m_wilscoeff;
	};

	#endif
	diff --git a/EvtGenModels/EvtbTosllMSExt.hh b/EvtGenModels/EvtbTosllMSExt.hh
	--- a/EvtGenModels/EvtbTosllMSExt.hh
	+++ b/EvtGenModels/EvtbTosllMSExt.hh
	@@ -49,9 +49,9 @@
	void decay( EvtParticle* p ) override;

	private:
	- EvtbTosllFFNew* _msffmodel;
	- EvtbTosllAmpNewExt* _calcamp;
	- EvtbTosllWilsCoeffNLO* _wilscoeff;
	+ EvtbTosllFFNew* m_msffmodel;
	+ EvtbTosllAmpNewExt* m_calcamp;
	+ EvtbTosllWilsCoeffNLO* m_wilscoeff;
	};

	#endif
	diff --git a/EvtGenModels/EvtbTosllScalarAmp.hh b/EvtGenModels/EvtbTosllScalarAmp.hh
	--- a/EvtGenModels/EvtbTosllScalarAmp.hh
	+++ b/EvtGenModels/EvtbTosllScalarAmp.hh
	@@ -22,21 +22,17 @@
	#define EVTBTOSLLSCALARAMP_HH

	#include "EvtGenModels/EvtbTosllAmp.hh"
	+
	class EvtParticle;
	class EvtAmp;
	class bTosllFF;

	class EvtbTosllScalarAmp : public EvtbTosllAmp {
	public:
	- //EvtbTosllScalarAmp(double c7, double c9, double c10):_c7(c7),_c9(c9),_c10(c10){}
	-
	//Daughters are initialized and have been added to the parent.
	//No need to carry around the daughters seperately!
	void CalcAmp( EvtParticle* parent, EvtAmp& amp,
	EvtbTosllFF* formFactors ) override;
	-
	- private:
	- //double _c7,_c9,_c10;
	};

	#endif
	diff --git a/EvtGenModels/EvtbTosllVectorAmp.hh b/EvtGenModels/EvtbTosllVectorAmp.hh
	--- a/EvtGenModels/EvtbTosllVectorAmp.hh
	+++ b/EvtGenModels/EvtbTosllVectorAmp.hh
	@@ -29,15 +29,10 @@

	class EvtbTosllVectorAmp : public EvtbTosllAmp {
	public:
	- //EvtbTosllVectorAmp(double c7, double c9, double c10):_c7(c7),_c9(c9),_c10(c10){}
	-
	//Daughters are initialized and have been added to the parent.
	//No need to carry around the daughters seperately!
	void CalcAmp( EvtParticle* parent, EvtAmp& amp,
	EvtbTosllFF* formFactors ) override;
	-
	- private:
	- //double _c7,_c9,_c10;
	};

	#endif
	diff --git a/EvtGenModels/Evtbs2llGammaISRFSR.hh b/EvtGenModels/Evtbs2llGammaISRFSR.hh
	--- a/EvtGenModels/Evtbs2llGammaISRFSR.hh
	+++ b/EvtGenModels/Evtbs2llGammaISRFSR.hh
	@@ -43,9 +43,9 @@
	void decay( EvtParticle* p ) override;

	private:
	- Evtbs2llGammaFF* _mntffmodel;
	- Evtbs2llGammaISRFSRAmp* _calcamp;
	- EvtbTosllWilsCoeffNLO* _wilscoeff;
	+ Evtbs2llGammaFF* m_mntffmodel;
	+ Evtbs2llGammaISRFSRAmp* m_calcamp;
	+ EvtbTosllWilsCoeffNLO* m_wilscoeff;
	};

	#endif
	diff --git a/EvtGenModels/Evtbs2llGammaMNT.hh b/EvtGenModels/Evtbs2llGammaMNT.hh
	--- a/EvtGenModels/Evtbs2llGammaMNT.hh
	+++ b/EvtGenModels/Evtbs2llGammaMNT.hh
	@@ -48,9 +48,9 @@
	void decay( EvtParticle* p ) override;

	private:
	- Evtbs2llGammaFF* _mntffmodel;
	- Evtbs2llGammaAmp* _calcamp;
	- EvtbTosllWilsCoeffNLO* _wilscoeff;
	+ Evtbs2llGammaFF* m_mntffmodel;
	+ Evtbs2llGammaAmp* m_calcamp;
	+ EvtbTosllWilsCoeffNLO* m_wilscoeff;
	};

	#endif
	diff --git a/cmake/Modules/EvtGenCompilerFlags.cmake b/cmake/Modules/EvtGenCompilerFlags.cmake
	--- a/cmake/Modules/EvtGenCompilerFlags.cmake
	+++ b/cmake/Modules/EvtGenCompilerFlags.cmake
	@@ -32,8 +32,7 @@
	if( ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" )
	message(STATUS "EvtGen: Customising compiler flags for each build type")

	- #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsigned-char -Wall -Wextra -Wshadow -Woverloaded-virtual")
	- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsigned-char -Wall -Wextra")
	+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsigned-char -Wall -Wextra -Wshadow -Woverloaded-virtual")

	if( ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU" )
	set(CMAKE_CXX_FLAGS_DEBUG "-Og -g3")
	diff --git a/doxygen/Doxyfile.in b/doxygen/Doxyfile.in
	--- a/doxygen/Doxyfile.in
	+++ b/doxygen/Doxyfile.in
	@@ -1073,7 +1073,7 @@
	# while generating the index headers.
	# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.

	-IGNORE_PREFIX =
	+IGNORE_PREFIX = Evt m_

	#---------------------------------------------------------------------------
	# Configuration options related to the HTML output
	@@ -2059,7 +2059,7 @@
	# recursively expanded use the := operator instead of the = operator.
	# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.

	-PREDEFINED =
	+PREDEFINED = EVTGEN_HEPMC3 EVTGEN_PYTHIA EVTGEN_PHOTOS EVTGEN_TAUOLA

	# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
	# tag can be used to specify a list of macro names that should be expanded. The
	diff --git a/src/EvtGen.cpp b/src/EvtGen.cpp
	--- a/src/EvtGen.cpp
	+++ b/src/EvtGen.cpp
	@@ -108,7 +108,7 @@
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Main decay file name :" << decayName << endl;

	- _pdl.readPDT( pdtTable );
	+ m_pdl.readPDT( pdtTable );

	if ( useXml ) {
	EvtDecayTable::getInstance()->readXMLDecayFile( decayName, false );
	@@ -116,10 +116,10 @@
	EvtDecayTable::getInstance()->readDecayFile( decayName, false );
	}

	- _mixingType = mixingType;
	+ m_mixingType = mixingType;
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "Mixing type integer set to " << _mixingType << endl;
	- EvtCPUtil::getInstance()->setMixingType( _mixingType );
	+ << "Mixing type integer set to " << m_mixingType << endl;
	+ EvtCPUtil::getInstance()->setMixingType( m_mixingType );

	// Set the radiative correction engine

	diff --git a/src/EvtGenBase/EvtAbsLineShape.cpp b/src/EvtGenBase/EvtAbsLineShape.cpp
	--- a/src/EvtGenBase/EvtAbsLineShape.cpp
	+++ b/src/EvtGenBase/EvtAbsLineShape.cpp
	@@ -38,50 +38,50 @@
	EvtAbsLineShape::EvtAbsLineShape( double mass, double width, double maxRange,
	EvtSpinType::spintype sp )
	{
	- _includeDecayFact = false;
	- _includeBirthFact = false;
	- _mass = mass;
	- _width = width;
	- _spin = sp;
	- _maxRange = maxRange;
	+ m_includeDecayFact = false;
	+ m_includeBirthFact = false;
	+ m_mass = mass;
	+ m_width = width;
	+ m_spin = sp;
	+ m_maxRange = maxRange;
	double maxdelta = 15.0 * width;
	//if ( width>0.001 ) {
	// if ( 5.0*width < 0.6 ) maxdelta = 0.6;
	//}
	if ( maxRange > 0.00001 ) {
	- _massMax = mass + maxdelta;
	- _massMin = mass - maxRange;
	+ m_massMax = mass + maxdelta;
	+ m_massMin = mass - maxRange;
	} else {
	- _massMax = mass + maxdelta;
	- _massMin = mass - 15.0 * width;
	+ m_massMax = mass + maxdelta;
	+ m_massMin = mass - 15.0 * width;
	}
	- if ( _massMin < 0. )
	- _massMin = 0.;
	- _massMax = mass + maxdelta;
	+ if ( m_massMin < 0. )
	+ m_massMin = 0.;
	+ m_massMax = mass + maxdelta;
	}

	EvtAbsLineShape::EvtAbsLineShape( const EvtAbsLineShape& x )
	{
	- _includeDecayFact = x._includeDecayFact;
	- _includeBirthFact = x._includeBirthFact;
	- _mass = x._mass;
	- _massMax = x._massMax;
	- _massMin = x._massMin;
	- _width = x._width;
	- _spin = x._spin;
	- _maxRange = x._maxRange;
	+ m_includeDecayFact = x.m_includeDecayFact;
	+ m_includeBirthFact = x.m_includeBirthFact;
	+ m_mass = x.m_mass;
	+ m_massMax = x.m_massMax;
	+ m_massMin = x.m_massMin;
	+ m_width = x.m_width;
	+ m_spin = x.m_spin;
	+ m_maxRange = x.m_maxRange;
	}

	EvtAbsLineShape& EvtAbsLineShape::operator=( const EvtAbsLineShape& x )
	{
	- _includeDecayFact = x._includeDecayFact;
	- _includeBirthFact = x._includeBirthFact;
	- _mass = x._mass;
	- _massMax = x._massMax;
	- _massMin = x._massMin;
	- _width = x._width;
	- _spin = x._spin;
	- _maxRange = x._maxRange;
	+ m_includeDecayFact = x.m_includeDecayFact;
	+ m_includeBirthFact = x.m_includeBirthFact;
	+ m_mass = x.m_mass;
	+ m_massMax = x.m_massMax;
	+ m_massMin = x.m_massMin;
	+ m_width = x.m_width;
	+ m_spin = x.m_spin;
	+ m_maxRange = x.m_maxRange;
	return *this;
	}

	@@ -95,14 +95,14 @@
	double ymin, ymax;
	double temp;

	- if ( _width < 0.0001 ) {
	- return _mass;
	+ if ( m_width < 0.0001 ) {
	+ return m_mass;
	} else {
	- ymin = atan( 2.0 * ( _massMin - _mass ) / _width );
	- ymax = atan( 2.0 * ( _massMax - _mass ) / _width );
	+ ymin = atan( 2.0 * ( m_massMin - m_mass ) / m_width );
	+ ymax = atan( 2.0 * ( m_massMax - m_mass ) / m_width );

	- temp = ( _mass +
	- ( ( _width / 2.0 ) * tan( EvtRandom::Flat( ymin, ymax ) ) ) );
	+ temp = ( m_mass +
	+ ( ( m_width / 2.0 ) * tan( EvtRandom::Flat( ymin, ymax ) ) ) );

	return temp;
	}
	@@ -111,15 +111,15 @@
	EvtId* /dauId/, EvtId* /othDaugId/,
	double maxMass, double* /dauMasses/ )
	{
	- if ( _width < 0.0001 )
	- return _mass;
	+ if ( m_width < 0.0001 )
	+ return m_mass;
	//its not flat - but generated according to a BW

	- if ( maxMass > 0 && maxMass < _massMin ) {
	+ if ( maxMass > 0 && maxMass < m_massMin ) {
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "In EvtAbsLineShape::getRandMass:" << endl;
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	- << "Cannot create a particle with a minimal mass of " << _massMin
	+ << "Cannot create a particle with a minimal mass of " << m_massMin
	<< " from a " << EvtPDL::name( *parId )
	<< " decay with available left-over mass-energy " << maxMass
	<< ". Returning 0.0 mass. The rest of this decay chain will probably fail..."
	@@ -127,15 +127,16 @@
	return 0.0;
	}

	- double mMin = _massMin;
	- double mMax = _massMax;
	+ double mMin = m_massMin;
	+ double mMax = m_massMax;
	if ( maxMass > -0.5 && maxMass < mMax )
	mMax = maxMass;
	- double ymin = atan( 2.0 * ( mMin - _mass ) / _width );
	- double ymax = atan( 2.0 * ( mMax - _mass ) / _width );
	+ double ymin = atan( 2.0 * ( mMin - m_mass ) / m_width );
	+ double ymax = atan( 2.0 * ( mMax - m_mass ) / m_width );

	- return ( _mass + ( ( _width / 2.0 ) * tan( EvtRandom::Flat( ymin, ymax ) ) ) );
	- // return EvtRandom::Flat(_massMin,_massMax);
	+ return ( m_mass +
	+ ( ( m_width / 2.0 ) * tan( EvtRandom::Flat( ymin, ymax ) ) ) );
	+ // return EvtRandom::Flat(m_massMin,m_massMax);
	}

	double EvtAbsLineShape::getMassProb( double mass, double massPar, int nDaug,
	@@ -152,7 +153,7 @@
	if ( ( mass < dTotMass ) )
	return 0.;
	}
	- if ( _width < 0.0001 )
	+ if ( m_width < 0.0001 )
	return 1.;

	// no parent - lets not panic
	@@ -163,10 +164,10 @@
	//Otherwise return the right value.
	//Fortunately we have generated events according to a non-rel BW, so
	//just return..
	- //EvtPropBreitWigner bw(_mass,_width);
	+ //EvtPropBreitWigner bw(m_mass,m_width);
	//EvtPropFactor<EvtTwoBodyVertex> f(bw);
	//EvtComplex fm=f.eval(mass);
	- //EvtComplex fm0=f.eval(_mass);
	+ //EvtComplex fm0=f.eval(m_mass);
	//return (abs(fm)abs(fm))/(abs(fm0)abs(fm0));
	return 1.0;
	}
	diff --git a/src/EvtGenBase/EvtAmp.cpp b/src/EvtGenBase/EvtAmp.cpp
	--- a/src/EvtGenBase/EvtAmp.cpp
	+++ b/src/EvtGenBase/EvtAmp.cpp
	@@ -35,33 +35,33 @@

	EvtAmp::EvtAmp()
	{
	- _ndaug = 0;
	- _pstates = 0;
	- _nontrivial = 0;
	+ m_ndaug = 0;
	+ m_pstates = 0;
	+ m_nontrivial = 0;
	}

	EvtAmp::EvtAmp( const EvtAmp& amp )
	{
	int i;

	- _ndaug = amp._ndaug;
	- _pstates = amp._pstates;
	- for ( i = 0; i < _ndaug; i++ ) {
	- dstates[i] = amp.dstates[i];
	- _dnontrivial[i] = amp._dnontrivial[i];
	+ m_ndaug = amp.m_ndaug;
	+ m_pstates = amp.m_pstates;
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ m_dstates[i] = amp.m_dstates[i];
	+ m_dnontrivial[i] = amp.m_dnontrivial[i];
	}
	- _nontrivial = amp._nontrivial;
	+ m_nontrivial = amp.m_nontrivial;

	int namp = 1;

	- for ( i = 0; i < _nontrivial; i++ ) {
	- _nstate[i] = amp._nstate[i];
	- namp *= _nstate[i];
	+ for ( i = 0; i < m_nontrivial; i++ ) {
	+ m_nstate[i] = amp.m_nstate[i];
	+ namp *= m_nstate[i];
	}

	for ( i = 0; i < namp; i++ ) {
	assert( i < 125 );
	- _amp[i] = amp._amp[i];
	+ m_amp[i] = amp.m_amp[i];
	}
	}

	@@ -82,32 +82,32 @@

	void EvtAmp::setNDaug( int n )
	{
	- _ndaug = n;
	+ m_ndaug = n;
	}

	void EvtAmp::setNState( int parent_states, int* daug_states )
	{
	- _nontrivial = 0;
	- _pstates = parent_states;
	+ m_nontrivial = 0;
	+ m_pstates = parent_states;

	- if ( _pstates > 1 ) {
	- _nstate[_nontrivial] = _pstates;
	- _nontrivial++;
	+ if ( m_pstates > 1 ) {
	+ m_nstate[m_nontrivial] = m_pstates;
	+ m_nontrivial++;
	}

	int i;

	- for ( i = 0; i < _ndaug; i++ ) {
	- dstates[i] = daug_states[i];
	- _dnontrivial[i] = -1;
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ m_dstates[i] = daug_states[i];
	+ m_dnontrivial[i] = -1;
	if ( daug_states[i] > 1 ) {
	- _nstate[_nontrivial] = daug_states[i];
	- _dnontrivial[i] = _nontrivial;
	- _nontrivial++;
	+ m_nstate[m_nontrivial] = daug_states[i];
	+ m_dnontrivial[i] = m_nontrivial;
	+ m_nontrivial++;
	}
	}

	- if ( _nontrivial > 5 ) {
	+ if ( m_nontrivial > 5 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Too many nontrivial states in EvtAmp!" << endl;
	}
	@@ -118,12 +118,12 @@
	int nstatepad = 1;
	int position = ind[0];

	- for ( int i = 1; i < _nontrivial; i++ ) {
	- nstatepad *= _nstate[i - 1];
	+ for ( int i = 1; i < m_nontrivial; i++ ) {
	+ nstatepad *= m_nstate[i - 1];
	position += nstatepad * ind[i];
	}
	assert( position < 125 );
	- _amp[position] = a;
	+ m_amp[position] = a;
	}

	const EvtComplex& EvtAmp::getAmp( int* ind ) const
	@@ -131,26 +131,26 @@
	int nstatepad = 1;
	int position = ind[0];

	- for ( int i = 1; i < _nontrivial; i++ ) {
	- nstatepad *= _nstate[i - 1];
	+ for ( int i = 1; i < m_nontrivial; i++ ) {
	+ nstatepad *= m_nstate[i - 1];
	position += nstatepad * ind[i];
	}

	- return _amp[position];
	+ return m_amp[position];
	}

	EvtSpinDensity EvtAmp::getSpinDensity()
	{
	EvtSpinDensity rho;
	- rho.setDim( _pstates );
	+ rho.setDim( m_pstates );

	EvtComplex temp;

	int i, j, n;

	- if ( _pstates == 1 ) {
	- if ( _nontrivial == 0 ) {
	- rho.set( 0, 0, _amp[0] * conj( _amp[0] ) );
	+ if ( m_pstates == 1 ) {
	+ if ( m_nontrivial == 0 ) {
	+ rho.set( 0, 0, m_amp[0] * conj( m_amp[0] ) );
	return rho;
	}

	@@ -158,12 +158,12 @@

	temp = EvtComplex( 0.0 );

	- for ( i = 0; i < _nontrivial; i++ ) {
	- n *= _nstate[i];
	+ for ( i = 0; i < m_nontrivial; i++ ) {
	+ n *= m_nstate[i];
	}

	for ( i = 0; i < n; i++ ) {
	- temp += _amp[i] * conj( _amp[i] );
	+ temp += m_amp[i] * conj( m_amp[i] );
	}

	rho.set( 0, 0, temp );
	@@ -174,23 +174,23 @@
	}

	else {
	- for ( i = 0; i < _pstates; i++ ) {
	- for ( j = 0; j < _pstates; j++ ) {
	+ for ( i = 0; i < m_pstates; i++ ) {
	+ for ( j = 0; j < m_pstates; j++ ) {
	temp = EvtComplex( 0.0 );

	int kk;

	int allloop = 1;
	- for ( kk = 0; kk < _ndaug; kk++ ) {
	- allloop *= dstates[kk];
	+ for ( kk = 0; kk < m_ndaug; kk++ ) {
	+ allloop *= m_dstates[kk];
	}

	for ( kk = 0; kk < allloop; kk++ ) {
	- temp += _amp[_pstates * kk + i] *
	- conj( _amp[_pstates * kk + j] );
	+ temp += m_amp[m_pstates * kk + i] *
	+ conj( m_amp[m_pstates * kk + j] );
	}

	- // if (_nontrivial>3){
	+ // if (m_nontrivial>3){
	//EvtGenReport(EVTGEN_ERROR,"EvtGen") << "Can't handle so many states in EvtAmp!"<<endl;
	//}

	@@ -205,9 +205,9 @@
	{
	EvtSpinDensity rho;

	- rho.setDim( _pstates );
	+ rho.setDim( m_pstates );

	- if ( _pstates == 1 ) {
	+ if ( m_pstates == 1 ) {
	rho.set( 0, 0, EvtComplex( 1.0, 0.0 ) );
	return rho;
	}
	@@ -218,9 +218,9 @@

	ampprime = ( *this );

	- for ( k = 0; k < _ndaug; k++ ) {
	- if ( dstates[k] != 1 ) {
	- ampprime = ampprime.contract( _dnontrivial[k], rho_list[k + 1] );
	+ for ( k = 0; k < m_ndaug; k++ ) {
	+ if ( m_dstates[k] != 1 ) {
	+ ampprime = ampprime.contract( m_dnontrivial[k], rho_list[k + 1] );
	}
	}

	@@ -231,11 +231,11 @@
	{
	EvtSpinDensity rho;

	- rho.setDim( dstates[i] );
	+ rho.setDim( m_dstates[i] );

	int k;

	- if ( dstates[i] == 1 ) {
	+ if ( m_dstates[i] == 1 ) {
	rho.set( 0, 0, EvtComplex( 1.0, 0.0 ) );

	return rho;
	@@ -245,17 +245,17 @@

	ampprime = ( *this );

	- if ( _pstates != 1 ) {
	+ if ( m_pstates != 1 ) {
	ampprime = ampprime.contract( 0, rho_list[0] );
	}

	for ( k = 0; k < i; k++ ) {
	- if ( dstates[k] != 1 ) {
	- ampprime = ampprime.contract( _dnontrivial[k], rho_list[k + 1] );
	+ if ( m_dstates[k] != 1 ) {
	+ ampprime = ampprime.contract( m_dnontrivial[k], rho_list[k + 1] );
	}
	}

	- return ampprime.contract( _dnontrivial[i], ( *this ) );
	+ return ampprime.contract( m_dnontrivial[i], ( *this ) );
	}

	EvtAmp EvtAmp::contract( int k, const EvtSpinDensity& rho )
	@@ -263,22 +263,22 @@
	EvtAmp temp;

	int i, j;
	- temp._ndaug = _ndaug;
	- temp._pstates = _pstates;
	- temp._nontrivial = _nontrivial;
	+ temp.m_ndaug = m_ndaug;
	+ temp.m_pstates = m_pstates;
	+ temp.m_nontrivial = m_nontrivial;

	- for ( i = 0; i < _ndaug; i++ ) {
	- temp.dstates[i] = dstates[i];
	- temp._dnontrivial[i] = _dnontrivial[i];
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ temp.m_dstates[i] = m_dstates[i];
	+ temp.m_dnontrivial[i] = m_dnontrivial[i];
	}

	- if ( _nontrivial == 0 ) {
	+ if ( m_nontrivial == 0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Should not be here EvtAmp!" << endl;
	}

	- for ( i = 0; i < _nontrivial; i++ ) {
	- temp._nstate[i] = _nstate[i];
	+ for ( i = 0; i < m_nontrivial; i++ ) {
	+ temp.m_nstate[i] = m_nstate[i];
	}

	EvtComplex c;
	@@ -290,14 +290,14 @@

	int allloop = 1;
	int indflag, ii;
	- for ( i = 0; i < _nontrivial; i++ ) {
	- allloop *= _nstate[i];
	+ for ( i = 0; i < m_nontrivial; i++ ) {
	+ allloop *= m_nstate[i];
	}

	for ( i = 0; i < allloop; i++ ) {
	c = EvtComplex( 0.0 );
	int tempint = index[k];
	- for ( j = 0; j < _nstate[k]; j++ ) {
	+ for ( j = 0; j < m_nstate[k]; j++ ) {
	index[k] = j;
	c += rho.get( j, tempint ) * getAmp( index );
	}
	@@ -306,9 +306,9 @@
	temp.setAmp( index, c );

	indflag = 0;
	- for ( ii = 0; ii < _nontrivial; ii++ ) {
	+ for ( ii = 0; ii < m_nontrivial; ii++ ) {
	if ( indflag == 0 ) {
	- if ( index[ii] == ( _nstate[ii] - 1 ) ) {
	+ if ( index[ii] == ( m_nstate[ii] - 1 ) ) {
	index[ii] = 0;
	} else {
	indflag = 1;
	@@ -327,20 +327,20 @@
	EvtComplex temp;
	EvtSpinDensity rho;

	- rho.setDim( _nstate[k] );
	+ rho.setDim( m_nstate[k] );

	int allloop = 1;
	int indflag, ii;
	- for ( i = 0; i < _nontrivial; i++ ) {
	- allloop *= _nstate[i];
	+ for ( i = 0; i < m_nontrivial; i++ ) {
	+ allloop *= m_nstate[i];
	}

	int index[10];
	int index1[10];
	// int l;
	- for ( i = 0; i < _nstate[k]; i++ ) {
	- for ( j = 0; j < _nstate[k]; j++ ) {
	- if ( _nontrivial == 0 ) {
	+ for ( i = 0; i < m_nstate[k]; i++ ) {
	+ for ( j = 0; j < m_nstate[k]; j++ ) {
	+ if ( m_nontrivial == 0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Should not be here1 EvtAmp!" << endl;
	rho.set( 0, 0, EvtComplex( 1.0, 0.0 ) );
	@@ -356,13 +356,13 @@

	temp = EvtComplex( 0.0 );

	- for ( l = 0; l < int( allloop / _nstate[k] ); l++ ) {
	+ for ( l = 0; l < int( allloop / m_nstate[k] ); l++ ) {
	temp += getAmp( index ) * conj( amp2.getAmp( index1 ) );
	indflag = 0;
	- for ( ii = 0; ii < _nontrivial; ii++ ) {
	+ for ( ii = 0; ii < m_nontrivial; ii++ ) {
	if ( ii != k ) {
	if ( indflag == 0 ) {
	- if ( index[ii] == ( _nstate[ii] - 1 ) ) {
	+ if ( index[ii] == ( m_nstate[ii] - 1 ) ) {
	index[ii] = 0;
	index1[ii] = 0;
	} else {
	@@ -398,29 +398,29 @@
	}

	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	- << "Number of daugthers:" << _ndaug << endl;
	+ << "Number of daugthers:" << m_ndaug << endl;
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	- << "Number of states of the parent:" << _pstates << endl;
	+ << "Number of states of the parent:" << m_pstates << endl;
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << "Number of states on daughters:";
	- for ( i = 0; i < _ndaug; i++ ) {
	- EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << dstates[i] << " ";
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << m_dstates[i] << " ";
	}
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << endl;
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << "Nontrivial index of daughters:";
	- for ( i = 0; i < _ndaug; i++ ) {
	- EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << _dnontrivial[i] << " ";
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << m_dnontrivial[i] << " ";
	}
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << endl;
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	- << "number of nontrivial states:" << _nontrivial << endl;
	+ << "number of nontrivial states:" << m_nontrivial << endl;
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "Nontrivial particles number of states:";
	- for ( i = 0; i < _nontrivial; i++ ) {
	- EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << _nstate[i] << " ";
	+ for ( i = 0; i < m_nontrivial; i++ ) {
	+ EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << m_nstate[i] << " ";
	}
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << endl;
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << "Amplitudes:" << endl;
	- if ( _nontrivial == 0 ) {
	+ if ( m_nontrivial == 0 ) {
	list[0] = 0;
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << getAmp( list ) << endl;
	}
	@@ -431,15 +431,15 @@
	}

	allloop[0] = 1;
	- for ( i = 0; i < _nontrivial; i++ ) {
	+ for ( i = 0; i < m_nontrivial; i++ ) {
	if ( i == 0 ) {
	- allloop[i] *= _nstate[i];
	+ allloop[i] *= m_nstate[i];
	} else {
	- allloop[i] = allloop[i - 1] * _nstate[i];
	+ allloop[i] = allloop[i - 1] * m_nstate[i];
	}
	}
	int index = 0;
	- for ( i = 0; i < allloop[_nontrivial - 1]; i++ ) {
	+ for ( i = 0; i < allloop[m_nontrivial - 1]; i++ ) {
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << getAmp( list ) << " ";
	if ( i == allloop[index] - 1 ) {
	index++;
	@@ -491,24 +491,24 @@
	{
	int i;

	- _ndaug = amp._ndaug;
	- _pstates = amp._pstates;
	- for ( i = 0; i < _ndaug; i++ ) {
	- dstates[i] = amp.dstates[i];
	- _dnontrivial[i] = amp._dnontrivial[i];
	+ m_ndaug = amp.m_ndaug;
	+ m_pstates = amp.m_pstates;
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ m_dstates[i] = amp.m_dstates[i];
	+ m_dnontrivial[i] = amp.m_dnontrivial[i];
	}
	- _nontrivial = amp._nontrivial;
	+ m_nontrivial = amp.m_nontrivial;

	int namp = 1;

	- for ( i = 0; i < _nontrivial; i++ ) {
	- _nstate[i] = amp._nstate[i];
	- namp *= _nstate[i];
	+ for ( i = 0; i < m_nontrivial; i++ ) {
	+ m_nstate[i] = amp.m_nstate[i];
	+ namp *= m_nstate[i];
	}

	for ( i = 0; i < namp; i++ ) {
	assert( i < 125 );
	- _amp[i] = amp._amp[i];
	+ m_amp[i] = amp.m_amp[i];
	}

	return *this;
	diff --git a/src/EvtGenBase/EvtBlattWeisskopf.cpp b/src/EvtGenBase/EvtBlattWeisskopf.cpp
	--- a/src/EvtGenBase/EvtBlattWeisskopf.cpp
	+++ b/src/EvtGenBase/EvtBlattWeisskopf.cpp
	@@ -29,7 +29,7 @@
	using std::endl;

	EvtBlattWeisskopf::EvtBlattWeisskopf( int LL, double R, double p0 ) :
	- _LL( LL ), _radial( R ), _p0( p0 )
	+ m_LL( LL ), m_radial( R ), m_p0( p0 )
	{
	if ( R < 0 ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -37,27 +37,30 @@
	assert( 0 );
	}

	- _radial = R;
	+ m_radial = R;

	// compute formula for nominal momentum

	- _F0 = compute( _p0 );
	- if ( _F0 <= 0 ) {
	+ m_F0 = compute( m_p0 );
	+ if ( m_F0 <= 0 ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "Invalid nominal form factor computed " << _F0 << endl;
	+ << "Invalid nominal form factor computed " << m_F0 << endl;
	assert( 0 );
	}
	}

	EvtBlattWeisskopf::EvtBlattWeisskopf( const EvtBlattWeisskopf& other ) :
	- _LL( other._LL ), _radial( other._radial ), _p0( other._p0 ), _F0( other._F0 )
	+ m_LL( other.m_LL ),
	+ m_radial( other.m_radial ),
	+ m_p0( other.m_p0 ),
	+ m_F0( other.m_F0 )
	{
	}

	double EvtBlattWeisskopf::operator()( double p ) const
	{
	- double ret = compute( p ) / _F0;
	- // EvtGenReport(EVTGEN_INFO,"EvtGen") << p << " " << _p0 << " " << _F0 << " " << _LL << " " << _radial << " " << ret << endl;
	+ double ret = compute( p ) / m_F0;
	+ // EvtGenReport(EVTGEN_INFO,"EvtGen") << p << " " << m_p0 << " " << m_F0 << " " << m_LL << " " << m_radial << " " << ret << endl;
	return ret;
	}

	@@ -77,23 +80,23 @@
	{
	double value( 1.0 );

	- double z = p * _radial;
	+ double z = p * m_radial;
	double zSq = z * z;

	- if ( _LL == 0 ) {
	+ if ( m_LL == 0 ) {
	value = 1.0;
	- } else if ( _LL == 1 ) {
	+ } else if ( m_LL == 1 ) {
	value = sqrt( 1.0 / ( 1.0 + zSq ) );
	- } else if ( _LL == 2 ) {
	+ } else if ( m_LL == 2 ) {
	value = sqrt( 1.0 / ( zSq * ( zSq + 3.0 ) + 9.0 ) );
	- } else if ( _LL == 3 ) {
	+ } else if ( m_LL == 3 ) {
	double denom = zSq * ( zSq * ( zSq + 6.0 ) + 45.0 ) + 225.0;
	value = sqrt( 1.0 / denom );
	- } else if ( _LL == 4 ) {
	+ } else if ( m_LL == 4 ) {
	double denom = zSq * ( zSq * ( zSq * ( zSq + 10.0 ) + 135.0 ) + 1575.0 ) +
	11025.0;
	value = sqrt( 1.0 / denom );
	- } else if ( _LL == 5 ) {
	+ } else if ( m_LL == 5 ) {
	double denom =
	zSq * ( zSq * ( zSq * ( zSq * ( zSq + 15.0 ) + 315.0 ) + 6300.0 ) +
	99225.0 ) +
	diff --git a/src/EvtGenBase/EvtCGCoefSingle.cpp b/src/EvtGenBase/EvtCGCoefSingle.cpp
	--- a/src/EvtGenBase/EvtCGCoefSingle.cpp
	+++ b/src/EvtGenBase/EvtCGCoefSingle.cpp
	@@ -30,13 +30,13 @@

	void EvtCGCoefSingle::init( int j1, int j2 )
	{
	- _j1 = j1;
	- _j2 = j2;
	+ m_j1 = j1;
	+ m_j2 = j2;

	- _Jmax = abs( j1 + j2 );
	- _Jmin = abs( j1 - j2 );
	+ m_Jmax = abs( j1 + j2 );
	+ m_Jmin = abs( j1 - j2 );

	- _table.resize( ( _Jmax - _Jmin ) / 2 + 1 );
	+ m_table.resize( ( m_Jmax - m_Jmin ) / 2 + 1 );

	int J, M;

	@@ -45,31 +45,31 @@
	lenmax = j2 + 1;

	//set vector sizes
	- for ( J = _Jmax; J >= _Jmin; J -= 2 ) {
	- _table[( J - _Jmin ) / 2].resize( J + 1 );
	+ for ( J = m_Jmax; J >= m_Jmin; J -= 2 ) {
	+ m_table[( J - m_Jmin ) / 2].resize( J + 1 );
	for ( M = J; J >= -M; M -= 2 ) {
	- int len = ( ( _j1 + _j2 ) - abs( M ) ) / 2 + 1;
	+ int len = ( ( m_j1 + m_j2 ) - abs( M ) ) / 2 + 1;
	if ( len > lenmax )
	len = lenmax;
	- _table[( J - _Jmin ) / 2][( M + J ) / 2].resize( len );
	+ m_table[( J - m_Jmin ) / 2][( M + J ) / 2].resize( len );
	}
	}

	//now fill the vectors
	- for ( J = _Jmax; J >= _Jmin; J -= 2 ) {
	+ for ( J = m_Jmax; J >= m_Jmin; J -= 2 ) {
	//bootstrap with highest M(=J) as a special case
	- if ( J == _Jmax ) {
	- cg( J, J, _j1, _j2 ) = 1.0;
	+ if ( J == m_Jmax ) {
	+ cg( J, J, m_j1, m_j2 ) = 1.0;
	} else {
	- int n = ( _Jmax - J ) / 2 + 1;
	+ int n = ( m_Jmax - J ) / 2 + 1;
	std::vector<double>* vectors = new std::vector<double>[n - 1];
	int i, k;
	for ( i = 0; i < n - 1; i++ ) {
	// i corresponds to J=Jmax-2*i
	vectors[i].resize( n );
	for ( k = 0; k < n; k++ ) {
	- double tmp = _table[( _Jmax - _Jmin ) / 2 - i]
	- [( J + _Jmax - 2 * i ) / 2][k];
	+ double tmp = m_table[( m_Jmax - m_Jmin ) / 2 - i]
	+ [( J + m_Jmax - 2 * i ) / 2][k];
	vectors[i][k] = tmp;
	}
	}
	@@ -79,12 +79,12 @@
	if ( orth[n - 1] < 0.0 )
	sign = -1;
	for ( k = 0; k < n; k++ ) {
	- _table[( J - _Jmin ) / 2][J][k] = sign * orth[k];
	+ m_table[( J - m_Jmin ) / 2][J][k] = sign * orth[k];
	}
	delete[] vectors;
	}
	for ( M = J - 2; M >= -J; M -= 2 ) {
	- int len = ( ( _j1 + _j2 ) - abs( M ) ) / 2 + 1;
	+ int len = ( ( m_j1 + m_j2 ) - abs( M ) ) / 2 + 1;
	if ( len > lenmax )
	len = lenmax;
	int mmin = M - j2;
	@@ -94,15 +94,15 @@
	for ( m1 = mmin; m1 < mmin + len * 2; m1 += 2 ) {
	int m2 = M - m1;
	double sum = 0.0;
	- float fkwTmp = _j1 * ( _j1 + 2 ) - ( m1 + 2 ) * m1;
	+ float fkwTmp = m_j1 * ( m_j1 + 2 ) - ( m1 + 2 ) * m1;
	//fkw 2/2/2001: changes needed to satisfy KCC
	- //fkw if (m1+2<=_j1) sum+=0.5sqrt(_j1(_j1+2)-(m1+2)m1)cg(J,M+2,m1+2,m2);
	- //fkw if (m2+2<=_j2) sum+=0.5sqrt(_j2(_j2+2)-(m2+2)m2)cg(J,M+2,m1,m2+2);
	+ //fkw if (m1+2<=m_j1) sum+=0.5sqrt(m_j1(m_j1+2)-(m1+2)m1)cg(J,M+2,m1+2,m2);
	+ //fkw if (m2+2<=m_j2) sum+=0.5sqrt(m_j2(m_j2+2)-(m2+2)m2)cg(J,M+2,m1,m2+2);
	//fkw sum/=(0.5sqrt(J(J+2)-(M+2)*M));
	- if ( m1 + 2 <= _j1 )
	+ if ( m1 + 2 <= m_j1 )
	sum += 0.5 * sqrt( fkwTmp ) * cg( J, M + 2, m1 + 2, m2 );
	- fkwTmp = _j2 * ( _j2 + 2 ) - ( m2 + 2 ) * m2;
	- if ( m2 + 2 <= _j2 )
	+ fkwTmp = m_j2 * ( m_j2 + 2 ) - ( m2 + 2 ) * m2;
	+ if ( m2 + 2 <= m_j2 )
	sum += 0.5 * sqrt( fkwTmp ) * cg( J, M + 2, m1, m2 + 2 );
	fkwTmp = J * ( J + 2 ) - ( M + 2 ) * M;
	sum /= ( 0.5 * sqrt( fkwTmp ) );
	@@ -114,10 +114,10 @@

	double EvtCGCoefSingle::coef( int J, int M, int j1, int j2, int m1, int m2 )
	{
	- assert( j1 == _j1 );
	- _unused( j1 );
	- assert( j2 == _j2 );
	- _unused( j2 );
	+ assert( j1 == m_j1 );
	+ UNUSED( j1 );
	+ assert( j2 == m_j2 );
	+ UNUSED( j2 );

	return cg( J, M, m1, m2 );
	}
	@@ -125,21 +125,21 @@
	double& EvtCGCoefSingle::cg( int J, int M, int m1, int m2 )
	{
	assert( M == m1 + m2 );
	- _unused( m2 );
	+ UNUSED( m2 );
	assert( abs( M ) <= J );
	- assert( J <= _Jmax );
	- assert( J >= _Jmin );
	- assert( abs( m1 ) <= _j1 );
	- assert( abs( m2 ) <= _j2 );
	+ assert( J <= m_Jmax );
	+ assert( J >= m_Jmin );
	+ assert( abs( m1 ) <= m_j1 );
	+ assert( abs( m2 ) <= m_j2 );

	//find lowest m1 allowed for the given M

	- int mmin = M - _j2;
	+ int mmin = M - m_j2;

	- if ( mmin < -_j1 )
	- mmin = -_j1;
	+ if ( mmin < -m_j1 )
	+ mmin = -m_j1;

	int n = m1 - mmin;

	- return _table[( J - _Jmin ) / 2][( M + J ) / 2][n / 2];
	+ return m_table[( J - m_Jmin ) / 2][( M + J ) / 2][n / 2];
	}
	diff --git a/src/EvtGenBase/EvtCPUtil.cpp b/src/EvtGenBase/EvtCPUtil.cpp
	--- a/src/EvtGenBase/EvtCPUtil.cpp
	+++ b/src/EvtGenBase/EvtCPUtil.cpp
	@@ -36,8 +36,8 @@

	EvtCPUtil::EvtCPUtil( int mixingType )
	{
	- _enableFlip = false;
	- _mixingType = mixingType;
	+ m_enableFlip = false;
	+ m_mixingType = mixingType;
	}

	EvtCPUtil* EvtCPUtil::getInstance()
	@@ -142,10 +142,10 @@

	void EvtCPUtil::OtherB( EvtParticle* p, double& t, EvtId& otherb, double probB0 )
	{
	- if ( _mixingType == EvtCPUtil::Coherent ) {
	+ if ( m_mixingType == EvtCPUtil::Coherent ) {
	OtherCoherentB( p, t, otherb, probB0 );

	- } else if ( _mixingType == EvtCPUtil::Incoherent ) {
	+ } else if ( m_mixingType == EvtCPUtil::Incoherent ) {
	OtherIncoherentB( p, t, otherb, probB0 );
	}
	}
	@@ -565,13 +565,13 @@

	bool EvtCPUtil::flipIsEnabled()
	{
	- return _enableFlip;
	+ return m_enableFlip;
	}
	void EvtCPUtil::enableFlip()
	{
	- _enableFlip = true;
	+ m_enableFlip = true;
	}
	void EvtCPUtil::disableFlip()
	{
	- _enableFlip = false;
	+ m_enableFlip = false;
	}
	diff --git a/src/EvtGenBase/EvtComplex.cpp b/src/EvtGenBase/EvtComplex.cpp
	--- a/src/EvtGenBase/EvtComplex.cpp
	+++ b/src/EvtGenBase/EvtComplex.cpp
	@@ -28,30 +28,30 @@

	ostream& operator<<( ostream& s, const EvtComplex& c )
	{
	- s << "(" << c._rpart << "," << c._ipart << ")";
	+ s << "(" << c.m_rpart << "," << c.m_ipart << ")";
	return s;
	}

	EvtComplex& EvtComplex::operator*=( EvtComplex c )
	{
	- double r = _rpart * c._rpart - _ipart * c._ipart;
	- double i = _rpart * c._ipart + _ipart * c._rpart;
	+ double r = m_rpart * c.m_rpart - m_ipart * c.m_ipart;
	+ double i = m_rpart * c.m_ipart + m_ipart * c.m_rpart;

	- _rpart = r;
	- _ipart = i;
	+ m_rpart = r;
	+ m_ipart = i;

	return *this;
	}

	EvtComplex& EvtComplex::operator/=( EvtComplex c )
	{
	- double inv = 1.0 / ( c._rpart * c._rpart + c._ipart * c._ipart );
	+ double inv = 1.0 / ( c.m_rpart * c.m_rpart + c.m_ipart * c.m_ipart );

	- double r = inv * ( _rpart * c._rpart + _ipart * c._ipart );
	- double i = inv * ( _ipart * c._rpart - _rpart * c._ipart );
	+ double r = inv * ( m_rpart * c.m_rpart + m_ipart * c.m_ipart );
	+ double i = inv * ( m_ipart * c.m_rpart - m_rpart * c.m_ipart );

	- _rpart = r;
	- _ipart = i;
	+ m_rpart = r;
	+ m_ipart = i;

	return *this;
	}
	diff --git a/src/EvtGenBase/EvtCyclic3.cpp b/src/EvtGenBase/EvtCyclic3.cpp
	--- a/src/EvtGenBase/EvtCyclic3.cpp
	+++ b/src/EvtGenBase/EvtCyclic3.cpp
	@@ -83,7 +83,7 @@
	Perm EvtCyclic3::permutation( Index i1, Index i2, Index i3 )
	{
	assert( i1 != i2 && i2 != i3 && i3 != i1 );
	- _unused( i3 );
	+ UNUSED( i3 );
	if ( i1 == A )
	return ( i2 == B ) ? ABC : ACB;
	if ( i1 == B )
	diff --git a/src/EvtGenBase/EvtDalitzCoord.cpp b/src/EvtGenBase/EvtDalitzCoord.cpp
	--- a/src/EvtGenBase/EvtDalitzCoord.cpp
	+++ b/src/EvtGenBase/EvtDalitzCoord.cpp
	@@ -32,30 +32,30 @@
	// default ctor. Initialize to something invalid.

	EvtDalitzCoord::EvtDalitzCoord() :
	- _i1( EvtCyclic3::AB ), _i2( EvtCyclic3::BC ), _q1( -1. ), _q2( -1. )
	+ m_i1( EvtCyclic3::AB ), m_i2( EvtCyclic3::BC ), m_q1( -1. ), m_q2( -1. )
	{
	}

	EvtDalitzCoord::EvtDalitzCoord( const EvtDalitzCoord& other ) :
	- _i1( other._i1 ), _i2( other._i2 ), _q1( other._q1 ), _q2( other._q2 )
	+ m_i1( other.m_i1 ), m_i2( other.m_i2 ), m_q1( other.m_q1 ), m_q2( other.m_q2 )
	{
	}

	EvtDalitzCoord::EvtDalitzCoord( Pair i1, double q1, Pair i2, double q2 ) :
	- _i1( i1 ), _i2( i2 ), _q1( q1 ), _q2( q2 )
	+ m_i1( i1 ), m_i2( i2 ), m_q1( q1 ), m_q2( q2 )
	{
	}

	bool EvtDalitzCoord::operator==( const EvtDalitzCoord& other ) const
	{
	- return ( _i1 == other._i1 && _i2 == other._i2 && _q1 == other._q1 &&
	- _q2 == other._q2 );
	+ return ( m_i1 == other.m_i1 && m_i2 == other.m_i2 && m_q1 == other.m_q1 &&
	+ m_q2 == other.m_q2 );
	}

	void EvtDalitzCoord::print( ostream& os ) const
	{
	- os << _i1 << " " << _q1 << endl;
	- os << _i2 << " " << _q2 << endl;
	+ os << m_i1 << " " << m_q1 << endl;
	+ os << m_i2 << " " << m_q2 << endl;
	}

	ostream& operator<<( ostream& os, const EvtDalitzCoord& p )
	diff --git a/src/EvtGenBase/EvtDalitzFlatPdf.cpp b/src/EvtGenBase/EvtDalitzFlatPdf.cpp
	--- a/src/EvtGenBase/EvtDalitzFlatPdf.cpp
	+++ b/src/EvtGenBase/EvtDalitzFlatPdf.cpp
	@@ -23,12 +23,12 @@
	#include "EvtGenBase/EvtPatches.hh"

	EvtDalitzFlatPdf::EvtDalitzFlatPdf( const EvtDalitzPlot& dp ) :
	- EvtPdf<EvtDalitzPoint>(), _dp( dp )
	+ EvtPdf<EvtDalitzPoint>(), m_dp( dp )
	{
	}

	EvtDalitzFlatPdf::EvtDalitzFlatPdf( const EvtDalitzFlatPdf& other ) :
	- EvtPdf<EvtDalitzPoint>( other ), _dp( other._dp )
	+ EvtPdf<EvtDalitzPoint>( other ), m_dp( other.m_dp )
	{
	}

	@@ -44,7 +44,7 @@

	EvtValError EvtDalitzFlatPdf::compute_integral( int N ) const
	{
	- return EvtValError( _dp.getArea( N ), 0. );
	+ return EvtValError( m_dp.getArea( N ), 0. );
	}

	EvtDalitzPoint EvtDalitzFlatPdf::randomPoint()
	@@ -62,11 +62,13 @@
	int n = 0;
	int maxTries = 1000;
	while ( n++ < maxTries ) {
	- double q1 = EvtRandom::Flat( _dp.qAbsMin( pair1 ), _dp.qAbsMax( pair2 ) );
	- double q2 = EvtRandom::Flat( _dp.qAbsMin( pair2 ), _dp.qAbsMax( pair2 ) );
	+ double q1 = EvtRandom::Flat( m_dp.qAbsMin( pair1 ),
	+ m_dp.qAbsMax( pair2 ) );
	+ double q2 = EvtRandom::Flat( m_dp.qAbsMin( pair2 ),
	+ m_dp.qAbsMax( pair2 ) );

	EvtDalitzCoord point( pair1, q1, pair2, q2 );
	- EvtDalitzPoint x( _dp, point );
	+ EvtDalitzPoint x( m_dp, point );

	if ( x.isValid() )
	return x;
	diff --git a/src/EvtGenBase/EvtDalitzPlot.cpp b/src/EvtGenBase/EvtDalitzPlot.cpp
	--- a/src/EvtGenBase/EvtDalitzPlot.cpp
	+++ b/src/EvtGenBase/EvtDalitzPlot.cpp
	@@ -32,26 +32,26 @@
	using namespace EvtCyclic3;

	EvtDalitzPlot::EvtDalitzPlot() :
	- _mA( 0. ), _mB( 0. ), _mC( 0. ), _bigM( 0. ), _ldel( 0. ), _rdel( 0. )
	+ m_mA( 0. ), m_mB( 0. ), m_mC( 0. ), m_bigM( 0. ), m_ldel( 0. ), m_rdel( 0. )
	{
	}

	EvtDalitzPlot::EvtDalitzPlot( double mA, double mB, double mC, double bigM,
	double ldel, double rdel ) :
	- _mA( mA ), _mB( mB ), _mC( mC ), _bigM( bigM ), _ldel( ldel ), _rdel( rdel )
	+ m_mA( mA ), m_mB( mB ), m_mC( mC ), m_bigM( bigM ), m_ldel( ldel ), m_rdel( rdel )
	{
	sanityCheck();
	}

	EvtDalitzPlot::EvtDalitzPlot( const EvtDecayMode& mode, double ldel, double rdel )
	{
	- _mA = EvtPDL::getMeanMass( EvtPDL::getId( mode.dau( A ) ) );
	- _mB = EvtPDL::getMeanMass( EvtPDL::getId( mode.dau( B ) ) );
	- _mC = EvtPDL::getMeanMass( EvtPDL::getId( mode.dau( C ) ) );
	- _bigM = EvtPDL::getMeanMass( EvtPDL::getId( mode.mother() ) );
	+ m_mA = EvtPDL::getMeanMass( EvtPDL::getId( mode.dau( A ) ) );
	+ m_mB = EvtPDL::getMeanMass( EvtPDL::getId( mode.dau( B ) ) );
	+ m_mC = EvtPDL::getMeanMass( EvtPDL::getId( mode.dau( C ) ) );
	+ m_bigM = EvtPDL::getMeanMass( EvtPDL::getId( mode.mother() ) );

	- _ldel = ldel;
	- _rdel = rdel;
	+ m_ldel = ldel;
	+ m_rdel = rdel;

	sanityCheck();
	}
	@@ -59,8 +59,8 @@
	bool EvtDalitzPlot::operator==( const EvtDalitzPlot& other ) const
	{
	bool ret = false;
	- if ( _mA == other._mA && _mB == other._mB && _mC == other._mC &&
	- _bigM == other._bigM )
	+ if ( m_mA == other.m_mA && m_mB == other.m_mB && m_mC == other.m_mC &&
	+ m_bigM == other.m_bigM )
	ret = true;

	return ret;
	@@ -73,29 +73,29 @@

	void EvtDalitzPlot::sanityCheck() const
	{
	- if ( _mA < 0 \|\| _mB < 0 \|\| _mC < 0 \|\| _bigM <= 0 \|\|
	- _bigM - _mA - _mB - _mC < 0. ) {
	- printf( "Invalid Dalitz plot %f %f %f %f\n", _mA, _mB, _mC, _bigM );
	+ if ( m_mA < 0 \|\| m_mB < 0 \|\| m_mC < 0 \|\| m_bigM <= 0 \|\|
	+ m_bigM - m_mA - m_mB - m_mC < 0. ) {
	+ printf( "Invalid Dalitz plot %f %f %f %f\n", m_mA, m_mB, m_mC, m_bigM );
	assert( 0 );
	}
	- assert( _ldel <= 0. );
	- assert( _rdel >= 0. );
	+ assert( m_ldel <= 0. );
	+ assert( m_rdel >= 0. );
	}

	double EvtDalitzPlot::m( Index i ) const
	{
	- double m = _mA;
	+ double m = m_mA;
	if ( i == B )
	- m = _mB;
	+ m = m_mB;
	else if ( i == C )
	- m = _mC;
	+ m = m_mC;

	return m;
	}

	double EvtDalitzPlot::sum() const
	{
	- return _mA * _mA + _mB * _mB + _mC * _mC + _bigM * _bigM;
	+ return m_mA * m_mA + m_mB * m_mB + m_mC * m_mC + m_bigM * m_bigM;
	}

	double EvtDalitzPlot::qAbsMin( Pair i ) const
	@@ -109,7 +109,7 @@
	double EvtDalitzPlot::qAbsMax( Pair i ) const
	{
	Index j = other( i );
	- return ( _bigM - m( j ) ) * ( _bigM - m( j ) );
	+ return ( m_bigM - m( j ) ) * ( m_bigM - m( j ) );
	}

	double EvtDalitzPlot::qResAbsMin( EvtCyclic3::Pair i ) const
	@@ -307,9 +307,9 @@
	{
	// masses
	printf( "Mass M %f\n", bigM() );
	- printf( "Mass mA %f\n", _mA );
	- printf( "Mass mB %f\n", _mB );
	- printf( "Mass mC %f\n", _mC );
	+ printf( "Mass mA %f\n", m_mA );
	+ printf( "Mass mB %f\n", m_mB );
	+ printf( "Mass mC %f\n", m_mC );
	// limits
	printf( "Limits qAB %f : %f\n", qAbsMin( AB ), qAbsMax( AB ) );
	printf( "Limits qBC %f : %f\n", qAbsMin( BC ), qAbsMax( BC ) );
	diff --git a/src/EvtGenBase/EvtDalitzPoint.cpp b/src/EvtGenBase/EvtDalitzPoint.cpp
	--- a/src/EvtGenBase/EvtDalitzPoint.cpp
	+++ b/src/EvtGenBase/EvtDalitzPoint.cpp
	@@ -28,13 +28,13 @@
	using namespace EvtCyclic3;

	EvtDalitzPoint::EvtDalitzPoint() :
	- _mA( -1. ), _mB( -1. ), _mC( -1. ), _qAB( -1. ), _qBC( -1. ), _qCA( -1. )
	+ m_mA( -1. ), m_mB( -1. ), m_mC( -1. ), m_qAB( -1. ), m_qBC( -1. ), m_qCA( -1. )
	{
	}

	EvtDalitzPoint::EvtDalitzPoint( double mA, double mB, double mC, double qAB,
	double qBC, double qCA ) :
	- _mA( mA ), _mB( mB ), _mC( mC ), _qAB( qAB ), _qBC( qBC ), _qCA( qCA )
	+ m_mA( mA ), m_mB( mB ), m_mC( mC ), m_qAB( qAB ), m_qBC( qBC ), m_qCA( qCA )
	{
	}

	@@ -43,71 +43,71 @@
	EvtDalitzPoint::EvtDalitzPoint( double mA, double mB, double mC,
	EvtCyclic3::Pair i, double qres, double qhel,
	double qsum ) :
	- _mA( mA ), _mB( mB ), _mC( mC )
	+ m_mA( mA ), m_mB( mB ), m_mC( mC )
	{
	double qi = qres + qsum / 3.;
	double qj = -qres / 2. + qhel + qsum / 3.;
	double qk = -qres / 2. - qhel + qsum / 3.;

	if ( i == AB ) {
	- _qAB = qi;
	- _qBC = qj;
	- _qCA = qk;
	+ m_qAB = qi;
	+ m_qBC = qj;
	+ m_qCA = qk;
	} else if ( i == BC ) {
	- _qAB = qk;
	- _qBC = qi;
	- _qCA = qj;
	+ m_qAB = qk;
	+ m_qBC = qi;
	+ m_qCA = qj;
	} else if ( i == CA ) {
	- _qAB = qj;
	- _qBC = qk;
	- _qCA = qi;
	+ m_qAB = qj;
	+ m_qBC = qk;
	+ m_qCA = qi;
	}
	}

	EvtDalitzPoint::EvtDalitzPoint( const EvtDalitzPlot& dp,
	const EvtDalitzCoord& x ) :
	- _mA( dp.m( A ) ), _mB( dp.m( B ) ), _mC( dp.m( C ) )
	+ m_mA( dp.m( A ) ), m_mB( dp.m( B ) ), m_mC( dp.m( C ) )
	{
	if ( x.pair1() == AB )
	- _qAB = x.q1();
	+ m_qAB = x.q1();
	else if ( x.pair2() == AB )
	- _qAB = x.q2();
	+ m_qAB = x.q2();
	else
	- _qAB = dp.sum() - x.q1() - x.q2();
	+ m_qAB = dp.sum() - x.q1() - x.q2();

	if ( x.pair1() == BC )
	- _qBC = x.q1();
	+ m_qBC = x.q1();
	else if ( x.pair2() == BC )
	- _qBC = x.q2();
	+ m_qBC = x.q2();
	else
	- _qBC = dp.sum() - x.q1() - x.q2();
	+ m_qBC = dp.sum() - x.q1() - x.q2();

	if ( x.pair1() == CA )
	- _qCA = x.q1();
	+ m_qCA = x.q1();
	else if ( x.pair2() == CA )
	- _qCA = x.q2();
	+ m_qCA = x.q2();
	else
	- _qCA = dp.sum() - x.q1() - x.q2();
	+ m_qCA = dp.sum() - x.q1() - x.q2();
	}

	double EvtDalitzPoint::q( EvtCyclic3::Pair i ) const
	{
	- double ret = _qAB;
	+ double ret = m_qAB;
	if ( BC == i )
	- ret = _qBC;
	+ ret = m_qBC;
	else if ( CA == i )
	- ret = _qCA;
	+ ret = m_qCA;

	return ret;
	}

	double EvtDalitzPoint::m( EvtCyclic3::Index i ) const
	{
	- double ret = _mA;
	+ double ret = m_mA;
	if ( B == i )
	- ret = _mB;
	+ ret = m_mB;
	else if ( C == i )
	- ret = _mC;
	+ ret = m_mC;

	return ret;
	}
	@@ -128,7 +128,7 @@
	}
	double EvtDalitzPoint::qsum() const
	{
	- return _qAB + _qBC + _qCA;
	+ return m_qAB + m_qBC + m_qCA;
	}

	double EvtDalitzPoint::qMin( EvtCyclic3::Pair i, EvtCyclic3::Pair j ) const
	@@ -178,7 +178,7 @@

	EvtDalitzPlot EvtDalitzPoint::getDalitzPlot() const
	{
	- return EvtDalitzPlot( _mA, _mB, _mC, bigM() );
	+ return EvtDalitzPlot( m_mA, m_mB, m_mC, bigM() );
	}

	bool EvtDalitzPoint::isValid() const
	@@ -186,9 +186,9 @@
	// Check masses

	double M = bigM();
	- if ( _mA < 0 \|\| _mB < 0 \|\| _mC < 0 \|\| M <= 0 )
	+ if ( m_mA < 0 \|\| m_mB < 0 \|\| m_mC < 0 \|\| M <= 0 )
	return false;
	- if ( M < _mA + _mB + _mC )
	+ if ( M < m_mA + m_mB + m_mC )
	return false;

	// Check that first coordinate is within absolute limits
	@@ -196,8 +196,8 @@
	bool inside = false;
	EvtDalitzPlot dp = getDalitzPlot();

	- if ( dp.qAbsMin( AB ) <= _qAB && _qAB <= dp.qAbsMax( AB ) )
	- if ( qMin( BC, AB ) <= _qBC && _qBC <= qMax( BC, AB ) )
	+ if ( dp.qAbsMin( AB ) <= m_qAB && m_qAB <= dp.qAbsMax( AB ) )
	+ if ( qMin( BC, AB ) <= m_qBC && m_qBC <= qMax( BC, AB ) )
	inside = true;

	return inside;
	@@ -205,11 +205,11 @@

	double EvtDalitzPoint::bigM() const
	{
	- return sqrt( _qAB + _qBC + _qCA - _mA * _mA - _mB * _mB - _mC * _mC );
	+ return sqrt( m_qAB + m_qBC + m_qCA - m_mA * m_mA - m_mB * m_mB - m_mC * m_mC );
	}

	void EvtDalitzPoint::print() const
	{
	getDalitzPlot().print();
	- printf( "%f %f %f\n", _qAB, _qBC, _qCA );
	+ printf( "%f %f %f\n", m_qAB, m_qBC, m_qCA );
	}
	diff --git a/src/EvtGenBase/EvtDalitzResPdf.cpp b/src/EvtGenBase/EvtDalitzResPdf.cpp
	--- a/src/EvtGenBase/EvtDalitzResPdf.cpp
	+++ b/src/EvtGenBase/EvtDalitzResPdf.cpp
	@@ -29,9 +29,9 @@
	#include <stdio.h>
	using namespace EvtCyclic3;

	-EvtDalitzResPdf::EvtDalitzResPdf( const EvtDalitzPlot& dp, double _m0,
	- double _g0, EvtCyclic3::Pair pair ) :
	- EvtPdf<EvtDalitzPoint>(), _dp( dp ), _m0( _m0 ), _g0( _g0 ), _pair( pair )
	+EvtDalitzResPdf::EvtDalitzResPdf( const EvtDalitzPlot& dp, double m0, double g0,
	+ EvtCyclic3::Pair pair ) :
	+ EvtPdf<EvtDalitzPoint>(), m_dp( dp ), m_m0( m0 ), m_g0( g0 ), m_pair( pair )
	{
	}

	@@ -39,19 +39,19 @@
	{
	assert( N != 0 );

	- EvtCyclic3::Pair i = _pair;
	+ EvtCyclic3::Pair i = m_pair;
	EvtCyclic3::Pair j = EvtCyclic3::next( i );

	// Trapezoidal integral

	- double dh = ( _dp.qAbsMax( j ) - _dp.qAbsMin( j ) ) / ( (double)N );
	+ double dh = ( m_dp.qAbsMax( j ) - m_dp.qAbsMin( j ) ) / ( (double)N );
	double sum = 0;

	int ii;
	for ( ii = 1; ii < N; ii++ ) {
	- double x = _dp.qAbsMin( j ) + ii * dh;
	- double min = ( _dp.qMin( i, j, x ) - _m0 * _m0 ) / _m0 / _g0;
	- double max = ( _dp.qMax( i, j, x ) - _m0 * _m0 ) / _m0 / _g0;
	+ double x = m_dp.qAbsMin( j ) + ii * dh;
	+ double min = ( m_dp.qMin( i, j, x ) - m_m0 * m_m0 ) / m_m0 / m_g0;
	+ double max = ( m_dp.qMax( i, j, x ) - m_m0 * m_m0 ) / m_m0 / m_g0;
	double itg = 1 / EvtConst::pi * ( atan( max ) - atan( min ) );
	sum += itg;
	}
	@@ -65,20 +65,20 @@
	// Random point generation must be done in a box encompassing the
	// Dalitz plot

	- EvtCyclic3::Pair i = _pair;
	+ EvtCyclic3::Pair i = m_pair;
	EvtCyclic3::Pair j = EvtCyclic3::next( i );
	double min = 1 / EvtConst::pi *
	- atan( ( _dp.qAbsMin( i ) - _m0 * _m0 ) / _m0 / _g0 );
	+ atan( ( m_dp.qAbsMin( i ) - m_m0 * m_m0 ) / m_m0 / m_g0 );
	double max = 1 / EvtConst::pi *
	- atan( ( _dp.qAbsMax( i ) - _m0 * _m0 ) / _m0 / _g0 );
	+ atan( ( m_dp.qAbsMax( i ) - m_m0 * m_m0 ) / m_m0 / m_g0 );

	int n = 0;
	while ( n++ < 1000 ) {
	- double qj = EvtRandom::Flat( _dp.qAbsMin( j ), _dp.qAbsMax( j ) );
	+ double qj = EvtRandom::Flat( m_dp.qAbsMin( j ), m_dp.qAbsMax( j ) );
	double r = EvtRandom::Flat( min, max );
	- double qi = tan( EvtConst::pi * r ) * _g0 * _m0 + _m0 * _m0;
	+ double qi = tan( EvtConst::pi * r ) * m_g0 * m_m0 + m_m0 * m_m0;
	EvtDalitzCoord x( i, qi, j, qj );
	- EvtDalitzPoint ret( _dp, x );
	+ EvtDalitzPoint ret( m_dp, x );
	if ( ret.isValid() )
	return ret;
	}
	@@ -92,12 +92,13 @@

	double EvtDalitzResPdf::pdf( const EvtDalitzPoint& x ) const
	{
	- EvtCyclic3::Pair i = _pair;
	- double dq = x.q( i ) - _m0 * _m0;
	- return 1 / EvtConst::pi * _g0 * _m0 / ( dq * dq + _g0 * _g0 * _m0 * _m0 );
	+ EvtCyclic3::Pair i = m_pair;
	+ double dq = x.q( i ) - m_m0 * m_m0;
	+ return 1 / EvtConst::pi * m_g0 * m_m0 /
	+ ( dq * dq + m_g0 * m_g0 * m_m0 * m_m0 );
	}

	double EvtDalitzResPdf::pdfMaxValue() const
	{
	- return 1 / ( EvtConst::pi * _g0 * _m0 );
	+ return 1 / ( EvtConst::pi * m_g0 * m_m0 );
	}
	diff --git a/src/EvtGenBase/EvtDalitzReso.cpp b/src/EvtGenBase/EvtDalitzReso.cpp
	--- a/src/EvtGenBase/EvtDalitzReso.cpp
	+++ b/src/EvtGenBase/EvtDalitzReso.cpp
	@@ -43,47 +43,48 @@
	EvtDalitzReso::EvtDalitzReso( const EvtDalitzPlot& dp, Pair pairAng, Pair pairRes,
	EvtSpinType::spintype spin, double m0, double g0,
	NumType typeN, double f_b, double f_d ) :
	- _dp( dp ),
	- _pairAng( pairAng ),
	- _pairRes( pairRes ),
	- _spin( spin ),
	- _typeN( typeN ),
	- _m0( m0 ),
	- _g0( g0 ),
	- _massFirst( dp.m( first( pairRes ) ) ),
	- _massSecond( dp.m( second( pairRes ) ) ),
	- _m0_mix( -1. ),
	- _g0_mix( 0. ),
	- _delta_mix( 0. ),
	- _amp_mix( 0., 0. ),
	- _g1( -1. ),
	- _g2( -1. ),
	- _coupling2( Undefined ),
	- _f_b( f_b ),
	- _f_d( f_d ),
	- _kmatrix_index( -1 ),
	- _fr12prod( 0., 0. ),
	- _fr13prod( 0., 0. ),
	- _fr14prod( 0., 0. ),
	- _fr15prod( 0., 0. ),
	- _s0prod( 0. ),
	- _a( 0. ),
	- _r( 0. ),
	- _Blass( 0. ),
	- _phiB( 0. ),
	- _R( 0. ),
	- _phiR( 0. ),
	- _cutoff( -1. ),
	- _scaleByMOverQ( false ),
	- _alpha( 0. )
	+ m_dp( dp ),
	+ m_pairAng( pairAng ),
	+ m_pairRes( pairRes ),
	+ m_spin( spin ),
	+ m_typeN( typeN ),
	+ m_m0( m0 ),
	+ m_g0( g0 ),
	+ m_massFirst( dp.m( first( pairRes ) ) ),
	+ m_massSecond( dp.m( second( pairRes ) ) ),
	+ m_m0_mix( -1. ),
	+ m_g0_mix( 0. ),
	+ m_delta_mix( 0. ),
	+ m_amp_mix( 0., 0. ),
	+ m_g1( -1. ),
	+ m_g2( -1. ),
	+ m_coupling2( Undefined ),
	+ m_f_b( f_b ),
	+ m_f_d( f_d ),
	+ m_kmatrix_index( -1 ),
	+ m_fr12prod( 0., 0. ),
	+ m_fr13prod( 0., 0. ),
	+ m_fr14prod( 0., 0. ),
	+ m_fr15prod( 0., 0. ),
	+ m_s0prod( 0. ),
	+ m_a( 0. ),
	+ m_r( 0. ),
	+ m_Blass( 0. ),
	+ m_phiB( 0. ),
	+ m_R( 0. ),
	+ m_phiR( 0. ),
	+ m_cutoff( -1. ),
	+ m_scaleByMOverQ( false ),
	+ m_alpha( 0. )
	{
	- _vb = EvtTwoBodyVertex( _m0, _dp.m( EvtCyclic3::other( _pairRes ) ),
	- _dp.bigM(), _spin );
	- _vd = EvtTwoBodyVertex( _massFirst, _massSecond, _m0, _spin );
	- _vb.set_f( _f_b ); // Default values for Blatt-Weisskopf factors are 0.0 and 1.5.
	- _vd.set_f( _f_d );
	- assert( _typeN != K_MATRIX && _typeN != K_MATRIX_I &&
	- _typeN != K_MATRIX_II ); // single BW cannot be K-matrix
	+ m_vb = EvtTwoBodyVertex( m_m0, m_dp.m( EvtCyclic3::other( m_pairRes ) ),
	+ m_dp.bigM(), m_spin );
	+ m_vd = EvtTwoBodyVertex( m_massFirst, m_massSecond, m_m0, m_spin );
	+ m_vb.set_f(
	+ m_f_b ); // Default values for Blatt-Weisskopf factors are 0.0 and 1.5.
	+ m_vd.set_f( m_f_d );
	+ assert( m_typeN != K_MATRIX && m_typeN != K_MATRIX_I &&
	+ m_typeN != K_MATRIX_II ); // single BW cannot be K-matrix
	}

	// Breit-Wigner with electromagnetic mass mixing
	@@ -91,47 +92,48 @@
	EvtSpinType::spintype spin, double m0, double g0,
	NumType typeN, double m0_mix, double g0_mix,
	double delta_mix, EvtComplex amp_mix ) :
	- _dp( dp ),
	- _pairAng( pairAng ),
	- _pairRes( pairRes ),
	- _spin( spin ),
	- _typeN( typeN ),
	- _m0( m0 ),
	- _g0( g0 ),
	- _massFirst( dp.m( first( pairRes ) ) ),
	- _massSecond( dp.m( second( pairRes ) ) ),
	- _m0_mix( m0_mix ),
	- _g0_mix( g0_mix ),
	- _delta_mix( delta_mix ),
	- _amp_mix( amp_mix ),
	- _g1( -1. ),
	- _g2( -1. ),
	- _coupling2( Undefined ),
	- _f_b( 0.0 ),
	- _f_d( 1.5 ),
	- _kmatrix_index( -1 ),
	- _fr12prod( 0., 0. ),
	- _fr13prod( 0., 0. ),
	- _fr14prod( 0., 0. ),
	- _fr15prod( 0., 0. ),
	- _s0prod( 0. ),
	- _a( 0. ),
	- _r( 0. ),
	- _Blass( 0. ),
	- _phiB( 0. ),
	- _R( 0. ),
	- _phiR( 0. ),
	- _cutoff( -1. ),
	- _scaleByMOverQ( false ),
	- _alpha( 0. )
	+ m_dp( dp ),
	+ m_pairAng( pairAng ),
	+ m_pairRes( pairRes ),
	+ m_spin( spin ),
	+ m_typeN( typeN ),
	+ m_m0( m0 ),
	+ m_g0( g0 ),
	+ m_massFirst( dp.m( first( pairRes ) ) ),
	+ m_massSecond( dp.m( second( pairRes ) ) ),
	+ m_m0_mix( m0_mix ),
	+ m_g0_mix( g0_mix ),
	+ m_delta_mix( delta_mix ),
	+ m_amp_mix( amp_mix ),
	+ m_g1( -1. ),
	+ m_g2( -1. ),
	+ m_coupling2( Undefined ),
	+ m_f_b( 0.0 ),
	+ m_f_d( 1.5 ),
	+ m_kmatrix_index( -1 ),
	+ m_fr12prod( 0., 0. ),
	+ m_fr13prod( 0., 0. ),
	+ m_fr14prod( 0., 0. ),
	+ m_fr15prod( 0., 0. ),
	+ m_s0prod( 0. ),
	+ m_a( 0. ),
	+ m_r( 0. ),
	+ m_Blass( 0. ),
	+ m_phiB( 0. ),
	+ m_R( 0. ),
	+ m_phiR( 0. ),
	+ m_cutoff( -1. ),
	+ m_scaleByMOverQ( false ),
	+ m_alpha( 0. )
	{
	- _vb = EvtTwoBodyVertex( _m0, _dp.m( EvtCyclic3::other( _pairRes ) ),
	- _dp.bigM(), _spin );
	- _vd = EvtTwoBodyVertex( _massFirst, _massSecond, _m0, _spin );
	- _vb.set_f( 0.0 ); // Default values for Blatt-Weisskopf factors.
	- _vd.set_f( 1.5 );
	+ m_vb = EvtTwoBodyVertex( m_m0, m_dp.m( EvtCyclic3::other( m_pairRes ) ),
	+ m_dp.bigM(), m_spin );
	+ m_vd = EvtTwoBodyVertex( m_massFirst, m_massSecond, m_m0, m_spin );
	+ m_vb.set_f( 0.0 ); // Default values for Blatt-Weisskopf factors.
	+ m_vd.set_f( 1.5 );
	// single BW (with electromagnetic mixing) cannot be K-matrix
	- assert( _typeN != K_MATRIX && _typeN != K_MATRIX_I && _typeN != K_MATRIX_II );
	+ assert( m_typeN != K_MATRIX && m_typeN != K_MATRIX_I &&
	+ m_typeN != K_MATRIX_II );
	}

	// coupled Breit-Wigner
	@@ -139,50 +141,50 @@
	Pair pairRes, EvtSpinType::spintype spin,
	double m0, NumType typeN, double g1, double g2,
	CouplingType coupling2 ) :
	- _dp( dp ),
	- _pairAng( pairAng ),
	- _pairRes( pairRes ),
	- _spin( spin ),
	- _typeN( typeN ),
	- _m0( m0 ),
	- _g0( -1. ),
	- _massFirst( dp.m( first( pairRes ) ) ),
	- _massSecond( dp.m( second( pairRes ) ) ),
	- _m0_mix( -1. ),
	- _g0_mix( 0. ),
	- _delta_mix( 0. ),
	- _amp_mix( 0., 0. ),
	- _g1( g1 ),
	- _g2( g2 ),
	- _coupling2( coupling2 ),
	- _f_b( 0.0 ),
	- _f_d( 1.5 ),
	- _kmatrix_index( -1 ),
	- _fr12prod( 0., 0. ),
	- _fr13prod( 0., 0. ),
	- _fr14prod( 0., 0. ),
	- _fr15prod( 0., 0. ),
	- _s0prod( 0. ),
	- _a( 0. ),
	- _r( 0. ),
	- _Blass( 0. ),
	- _phiB( 0. ),
	- _R( 0. ),
	- _phiR( 0. ),
	- _cutoff( -1. ),
	- _scaleByMOverQ( false ),
	- _alpha( 0. )
	+ m_dp( dp ),
	+ m_pairAng( pairAng ),
	+ m_pairRes( pairRes ),
	+ m_spin( spin ),
	+ m_typeN( typeN ),
	+ m_m0( m0 ),
	+ m_g0( -1. ),
	+ m_massFirst( dp.m( first( pairRes ) ) ),
	+ m_massSecond( dp.m( second( pairRes ) ) ),
	+ m_m0_mix( -1. ),
	+ m_g0_mix( 0. ),
	+ m_delta_mix( 0. ),
	+ m_amp_mix( 0., 0. ),
	+ m_g1( g1 ),
	+ m_g2( g2 ),
	+ m_coupling2( coupling2 ),
	+ m_f_b( 0.0 ),
	+ m_f_d( 1.5 ),
	+ m_kmatrix_index( -1 ),
	+ m_fr12prod( 0., 0. ),
	+ m_fr13prod( 0., 0. ),
	+ m_fr14prod( 0., 0. ),
	+ m_fr15prod( 0., 0. ),
	+ m_s0prod( 0. ),
	+ m_a( 0. ),
	+ m_r( 0. ),
	+ m_Blass( 0. ),
	+ m_phiB( 0. ),
	+ m_R( 0. ),
	+ m_phiR( 0. ),
	+ m_cutoff( -1. ),
	+ m_scaleByMOverQ( false ),
	+ m_alpha( 0. )
	{
	- _vb = EvtTwoBodyVertex( _m0, _dp.m( EvtCyclic3::other( _pairRes ) ),
	- _dp.bigM(), _spin );
	- _vd = EvtTwoBodyVertex( _massFirst, _massSecond, _m0, _spin );
	- _vb.set_f( 0.0 ); // Default values for Blatt-Weisskopf factors.
	- _vd.set_f( 1.5 );
	- assert( _coupling2 != Undefined );
	- assert( _typeN != K_MATRIX && _typeN != K_MATRIX_I &&
	- _typeN != K_MATRIX_II ); // coupled BW cannot be K-matrix
	- assert( _typeN != LASS ); // coupled BW cannot be LASS
	- assert( _typeN != NBW ); // for coupled BW, only relativistic BW
	+ m_vb = EvtTwoBodyVertex( m_m0, m_dp.m( EvtCyclic3::other( m_pairRes ) ),
	+ m_dp.bigM(), m_spin );
	+ m_vd = EvtTwoBodyVertex( m_massFirst, m_massSecond, m_m0, m_spin );
	+ m_vb.set_f( 0.0 ); // Default values for Blatt-Weisskopf factors.
	+ m_vd.set_f( 1.5 );
	+ assert( m_coupling2 != Undefined );
	+ assert( m_typeN != K_MATRIX && m_typeN != K_MATRIX_I &&
	+ m_typeN != K_MATRIX_II ); // coupled BW cannot be K-matrix
	+ assert( m_typeN != LASS ); // coupled BW cannot be LASS
	+ assert( m_typeN != NBW ); // for coupled BW, only relativistic BW
	}

	// K-Matrix (A&S)
	@@ -191,52 +193,53 @@
	EvtComplex fr12prod, EvtComplex fr13prod,
	EvtComplex fr14prod, EvtComplex fr15prod,
	double s0prod ) :
	- _dp( dp ),
	- _pairRes( pairRes ),
	- _typeN( typeN ),
	- _m0( 0. ),
	- _g0( 0. ),
	- _massFirst( dp.m( first( pairRes ) ) ),
	- _massSecond( dp.m( second( pairRes ) ) ),
	- _m0_mix( -1. ),
	- _g0_mix( 0. ),
	- _delta_mix( 0. ),
	- _amp_mix( 0., 0. ),
	- _g1( -1. ),
	- _g2( -1. ),
	- _coupling2( Undefined ),
	- _f_b( 0. ),
	- _f_d( 0. ),
	- _kmatrix_index( -1 ),
	- _fr12prod( fr12prod ),
	- _fr13prod( fr13prod ),
	- _fr14prod( fr14prod ),
	- _fr15prod( fr15prod ),
	- _s0prod( s0prod ),
	- _a( 0. ),
	- _r( 0. ),
	- _Blass( 0. ),
	- _phiB( 0. ),
	- _R( 0. ),
	- _phiR( 0. ),
	- _cutoff( -1. ),
	- _scaleByMOverQ( false ),
	- _alpha( 0. )
	+ m_dp( dp ),
	+ m_pairRes( pairRes ),
	+ m_typeN( typeN ),
	+ m_m0( 0. ),
	+ m_g0( 0. ),
	+ m_massFirst( dp.m( first( pairRes ) ) ),
	+ m_massSecond( dp.m( second( pairRes ) ) ),
	+ m_m0_mix( -1. ),
	+ m_g0_mix( 0. ),
	+ m_delta_mix( 0. ),
	+ m_amp_mix( 0., 0. ),
	+ m_g1( -1. ),
	+ m_g2( -1. ),
	+ m_coupling2( Undefined ),
	+ m_f_b( 0. ),
	+ m_f_d( 0. ),
	+ m_kmatrix_index( -1 ),
	+ m_fr12prod( fr12prod ),
	+ m_fr13prod( fr13prod ),
	+ m_fr14prod( fr14prod ),
	+ m_fr15prod( fr15prod ),
	+ m_s0prod( s0prod ),
	+ m_a( 0. ),
	+ m_r( 0. ),
	+ m_Blass( 0. ),
	+ m_phiB( 0. ),
	+ m_R( 0. ),
	+ m_phiR( 0. ),
	+ m_cutoff( -1. ),
	+ m_scaleByMOverQ( false ),
	+ m_alpha( 0. )
	{
	- assert( _typeN == K_MATRIX \|\| _typeN == K_MATRIX_I \|\| _typeN == K_MATRIX_II );
	- _spin = EvtSpinType::SCALAR;
	+ assert( m_typeN == K_MATRIX \|\| m_typeN == K_MATRIX_I \|\|
	+ m_typeN == K_MATRIX_II );
	+ m_spin = EvtSpinType::SCALAR;
	if ( nameIndex == "Pole1" )
	- _kmatrix_index = 1;
	+ m_kmatrix_index = 1;
	else if ( nameIndex == "Pole2" )
	- _kmatrix_index = 2;
	+ m_kmatrix_index = 2;
	else if ( nameIndex == "Pole3" )
	- _kmatrix_index = 3;
	+ m_kmatrix_index = 3;
	else if ( nameIndex == "Pole4" )
	- _kmatrix_index = 4;
	+ m_kmatrix_index = 4;
	else if ( nameIndex == "Pole5" )
	- _kmatrix_index = 5;
	+ m_kmatrix_index = 5;
	else if ( nameIndex == "f11prod" )
	- _kmatrix_index = 6;
	+ m_kmatrix_index = 6;
	else
	assert( 0 );
	}
	@@ -246,197 +249,195 @@
	double g0, double a, double r, double B,
	double phiB, double R, double phiR, double cutoff,
	bool scaleByMOverQ ) :
	- _dp( dp ),
	- _pairRes( pairRes ),
	- _typeN( LASS ),
	- _m0( m0 ),
	- _g0( g0 ),
	- _massFirst( dp.m( first( pairRes ) ) ),
	- _massSecond( dp.m( second( pairRes ) ) ),
	- _m0_mix( -1. ),
	- _g0_mix( 0. ),
	- _delta_mix( 0. ),
	- _amp_mix( 0., 0. ),
	- _g1( -1. ),
	- _g2( -1. ),
	- _coupling2( Undefined ),
	- _f_b( 0.0 ),
	- _f_d( 1.5 ),
	- _kmatrix_index( -1 ),
	- _fr12prod( 0., 0. ),
	- _fr13prod( 0., 0. ),
	- _fr14prod( 0., 0. ),
	- _fr15prod( 0., 0. ),
	- _s0prod( 0. ),
	- _a( a ),
	- _r( r ),
	- _Blass( B ),
	- _phiB( phiB ),
	- _R( R ),
	- _phiR( phiR ),
	- _cutoff( cutoff ),
	- _scaleByMOverQ( scaleByMOverQ ),
	- _alpha( 0. )
	+ m_dp( dp ),
	+ m_pairRes( pairRes ),
	+ m_typeN( LASS ),
	+ m_m0( m0 ),
	+ m_g0( g0 ),
	+ m_massFirst( dp.m( first( pairRes ) ) ),
	+ m_massSecond( dp.m( second( pairRes ) ) ),
	+ m_m0_mix( -1. ),
	+ m_g0_mix( 0. ),
	+ m_delta_mix( 0. ),
	+ m_amp_mix( 0., 0. ),
	+ m_g1( -1. ),
	+ m_g2( -1. ),
	+ m_coupling2( Undefined ),
	+ m_f_b( 0.0 ),
	+ m_f_d( 1.5 ),
	+ m_kmatrix_index( -1 ),
	+ m_fr12prod( 0., 0. ),
	+ m_fr13prod( 0., 0. ),
	+ m_fr14prod( 0., 0. ),
	+ m_fr15prod( 0., 0. ),
	+ m_s0prod( 0. ),
	+ m_a( a ),
	+ m_r( r ),
	+ m_Blass( B ),
	+ m_phiB( phiB ),
	+ m_R( R ),
	+ m_phiR( phiR ),
	+ m_cutoff( cutoff ),
	+ m_scaleByMOverQ( scaleByMOverQ ),
	+ m_alpha( 0. )
	{
	- _spin = EvtSpinType::SCALAR;
	- _vd = EvtTwoBodyVertex( _massFirst, _massSecond, _m0, _spin );
	- _vd.set_f( 1.5 ); // Default values for Blatt-Weisskopf factors.
	+ m_spin = EvtSpinType::SCALAR;
	+ m_vd = EvtTwoBodyVertex( m_massFirst, m_massSecond, m_m0, m_spin );
	+ m_vd.set_f( 1.5 ); // Default values for Blatt-Weisskopf factors.
	}

	//Flatte
	EvtDalitzReso::EvtDalitzReso( const EvtDalitzPlot& dp, EvtCyclic3::Pair pairRes,
	double m0 ) :
	- _dp( dp ),
	- _pairRes( pairRes ),
	- _typeN( FLATTE ),
	- _m0( m0 ),
	- _g0( 0. ),
	- _massFirst( dp.m( first( pairRes ) ) ),
	- _massSecond( dp.m( second( pairRes ) ) ),
	- _m0_mix( -1. ),
	- _g0_mix( 0. ),
	- _delta_mix( 0. ),
	- _amp_mix( 0., 0. ),
	- _g1( -1. ),
	- _g2( -1. ),
	- _coupling2( Undefined ),
	- _f_b( 0. ),
	- _f_d( 0. ),
	- _kmatrix_index( -1 ),
	- _fr12prod( 0., 0. ),
	- _fr13prod( 0., 0. ),
	- _fr14prod( 0., 0. ),
	- _fr15prod( 0., 0. ),
	- _s0prod( 0. ),
	- _a( 0. ),
	- _r( 0. ),
	- _Blass( 0. ),
	- _phiB( 0. ),
	- _R( 0. ),
	- _phiR( 0. ),
	- _cutoff( -1. ),
	- _scaleByMOverQ( false ),
	- _alpha( 0. )
	+ m_dp( dp ),
	+ m_pairRes( pairRes ),
	+ m_typeN( FLATTE ),
	+ m_m0( m0 ),
	+ m_g0( 0. ),
	+ m_massFirst( dp.m( first( pairRes ) ) ),
	+ m_massSecond( dp.m( second( pairRes ) ) ),
	+ m_m0_mix( -1. ),
	+ m_g0_mix( 0. ),
	+ m_delta_mix( 0. ),
	+ m_amp_mix( 0., 0. ),
	+ m_g1( -1. ),
	+ m_g2( -1. ),
	+ m_coupling2( Undefined ),
	+ m_f_b( 0. ),
	+ m_f_d( 0. ),
	+ m_kmatrix_index( -1 ),
	+ m_fr12prod( 0., 0. ),
	+ m_fr13prod( 0., 0. ),
	+ m_fr14prod( 0., 0. ),
	+ m_fr15prod( 0., 0. ),
	+ m_s0prod( 0. ),
	+ m_a( 0. ),
	+ m_r( 0. ),
	+ m_Blass( 0. ),
	+ m_phiB( 0. ),
	+ m_R( 0. ),
	+ m_phiR( 0. ),
	+ m_cutoff( -1. ),
	+ m_scaleByMOverQ( false ),
	+ m_alpha( 0. )
	{
	- _spin = EvtSpinType::SCALAR;
	+ m_spin = EvtSpinType::SCALAR;
	}

	EvtComplex EvtDalitzReso::evaluate( const EvtDalitzPoint& x )
	{
	- double m = sqrt( x.q( _pairRes ) );
	+ double m = sqrt( x.q( m_pairRes ) );

	- if ( _typeN == NON_RES )
	+ if ( m_typeN == NON_RES )
	return EvtComplex( 1.0, 0.0 );

	- if ( _typeN == NON_RES_LIN )
	+ if ( m_typeN == NON_RES_LIN )
	return m * m;

	- if ( _typeN == NON_RES_EXP )
	- return exp( -_alpha * m * m );
	+ if ( m_typeN == NON_RES_EXP )
	+ return exp( -m_alpha * m * m );

	// do use always hash table (speed up fitting)
	- if ( _typeN == K_MATRIX \|\| _typeN == K_MATRIX_I \|\| _typeN == K_MATRIX_II )
	- return Fvector( m * m, _kmatrix_index );
	+ if ( m_typeN == K_MATRIX \|\| m_typeN == K_MATRIX_I \|\| m_typeN == K_MATRIX_II )
	+ return Fvector( m * m, m_kmatrix_index );

	- if ( _typeN == LASS )
	+ if ( m_typeN == LASS )
	return lass( m * m );

	- if ( _typeN == FLATTE )
	+ if ( m_typeN == FLATTE )
	return flatte( m );

	EvtComplex amp( 1.0, 0.0 );

	- if ( fabs( _dp.bigM() - x.bigM() ) > 0.000001 ) {
	- _vb = EvtTwoBodyVertex( _m0, _dp.m( EvtCyclic3::other( _pairRes ) ),
	- x.bigM(), _spin );
	- _vb.set_f( _f_b );
	+ if ( fabs( m_dp.bigM() - x.bigM() ) > 0.000001 ) {
	+ m_vb = EvtTwoBodyVertex( m_m0, m_dp.m( EvtCyclic3::other( m_pairRes ) ),
	+ x.bigM(), m_spin );
	+ m_vb.set_f( m_f_b );
	}
	- EvtTwoBodyKine vb( m, x.m( EvtCyclic3::other( _pairRes ) ), x.bigM() );
	- EvtTwoBodyKine vd( _massFirst, _massSecond, m );
	+ EvtTwoBodyKine vb( m, x.m( EvtCyclic3::other( m_pairRes ) ), x.bigM() );
	+ EvtTwoBodyKine vd( m_massFirst, m_massSecond, m );

	EvtComplex prop( 0, 0 );
	- if ( _typeN == NBW ) {
	- prop = propBreitWigner( _m0, _g0, m );
	- } else if ( _typeN == GAUSS_CLEO \|\| _typeN == GAUSS_CLEO_ZEMACH ) {
	- prop = propGauss( _m0, _g0, m );
	+ if ( m_typeN == NBW ) {
	+ prop = propBreitWigner( m_m0, m_g0, m );
	+ } else if ( m_typeN == GAUSS_CLEO \|\| m_typeN == GAUSS_CLEO_ZEMACH ) {
	+ prop = propGauss( m_m0, m_g0, m );
	} else {
	- if ( _coupling2 == Undefined ) {
	+ if ( m_coupling2 == Undefined ) {
	// single BW
	- double g = ( _g0 <= 0. \|\| _vd.pD() <= 0. )
	- ? -_g0
	- : _g0 * _vd.widthFactor( vd ); // running width
	- if ( _typeN == GS_CLEO \|\| _typeN == GS_CLEO_ZEMACH ) {
	+ double g = ( m_g0 <= 0. \|\| m_vd.pD() <= 0. )
	+ ? -m_g0
	+ : m_g0 * m_vd.widthFactor( vd ); // running width
	+ if ( m_typeN == GS_CLEO \|\| m_typeN == GS_CLEO_ZEMACH ) {
	// Gounaris-Sakurai (GS)
	- prop = propGounarisSakurai( _m0, fabs( _g0 ), _vd.pD(), m, g,
	+ prop = propGounarisSakurai( m_m0, fabs( m_g0 ), m_vd.pD(), m, g,
	vd.p() );
	} else {
	// standard relativistic BW
	- prop = propBreitWignerRel( _m0, g, m );
	+ prop = propBreitWignerRel( m_m0, g, m );
	}
	} else {
	// coupled width BW
	EvtComplex G1, G2;
	- switch ( _coupling2 ) {
	+ switch ( m_coupling2 ) {
	case PicPic: {
	- G1 = _g1 * _g1 * psFactor( _massFirst, _massSecond, m );
	+ G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
	static double mPic = EvtPDL::getMass( EvtPDL::getId( "pi+" ) );
	- G2 = _g2 * _g2 * psFactor( mPic, mPic, m );
	+ G2 = m_g2 * m_g2 * psFactor( mPic, mPic, m );
	break;
	}
	case PizPiz: {
	- G1 = _g1 * _g1 * psFactor( _massFirst, _massSecond, m );
	+ G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
	static double mPiz = EvtPDL::getMass( EvtPDL::getId( "pi0" ) );
	- G2 = _g2 * _g2 * psFactor( mPiz, mPiz, m );
	+ G2 = m_g2 * m_g2 * psFactor( mPiz, mPiz, m );
	break;
	}
	case PiPi: {
	- G1 = _g1 * _g1 * psFactor( _massFirst, _massSecond, m );
	+ G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
	static double mPic = EvtPDL::getMass( EvtPDL::getId( "pi+" ) );
	static double mPiz = EvtPDL::getMass( EvtPDL::getId( "pi0" ) );
	- G2 = _g2 * _g2 * psFactor( mPic, mPic, mPiz, mPiz, m );
	+ G2 = m_g2 * m_g2 * psFactor( mPic, mPic, mPiz, mPiz, m );
	break;
	}
	case KcKc: {
	- G1 = _g1 * _g1 * psFactor( _massFirst, _massSecond, m );
	+ G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
	static double mKc = EvtPDL::getMass( EvtPDL::getId( "K+" ) );
	- G2 = _g2 * _g2 * psFactor( mKc, mKc, m );
	+ G2 = m_g2 * m_g2 * psFactor( mKc, mKc, m );
	break;
	}
	case KzKz: {
	- G1 = _g1 * _g1 * psFactor( _massFirst, _massSecond, m );
	+ G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
	static double mKz = EvtPDL::getMass( EvtPDL::getId( "K0" ) );
	- G2 = _g2 * _g2 * psFactor( mKz, mKz, m );
	+ G2 = m_g2 * m_g2 * psFactor( mKz, mKz, m );
	break;
	}
	case KK: {
	- G1 = _g1 * _g1 * psFactor( _massFirst, _massSecond, m );
	+ G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
	static double mKc = EvtPDL::getMass( EvtPDL::getId( "K+" ) );
	static double mKz = EvtPDL::getMass( EvtPDL::getId( "K0" ) );
	- G2 = _g2 * _g2 * psFactor( mKc, mKc, mKz, mKz, m );
	+ G2 = m_g2 * m_g2 * psFactor( mKc, mKc, mKz, mKz, m );
	break;
	}
	case EtaPic: {
	- G1 = _g1 * _g1 * psFactor( _massFirst, _massSecond, m );
	+ G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
	static double mEta = EvtPDL::getMass( EvtPDL::getId( "eta" ) );
	static double mPic = EvtPDL::getMass( EvtPDL::getId( "pi+" ) );
	- G2 = _g2 * _g2 * psFactor( mEta, mPic, m );
	+ G2 = m_g2 * m_g2 * psFactor( mEta, mPic, m );
	break;
	}
	case EtaPiz: {
	- G1 = _g1 * _g1 * psFactor( _massFirst, _massSecond, m );
	+ G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
	static double mEta = EvtPDL::getMass( EvtPDL::getId( "eta" ) );
	static double mPiz = EvtPDL::getMass( EvtPDL::getId( "pi0" ) );
	- G2 = _g2 * _g2 * psFactor( mEta, mPiz, m );
	+ G2 = m_g2 * m_g2 * psFactor( mEta, mPiz, m );
	break;
	}
	case PicPicKK: {
	static double mPic = EvtPDL::getMass( EvtPDL::getId( "pi+" ) );
	- //G1 = _g1_g1psFactor(mPic,mPic,m);
	- G1 = _g1 * psFactor( mPic, mPic, m );
	+ G1 = m_g1 * psFactor( mPic, mPic, m );
	static double mKc = EvtPDL::getMass( EvtPDL::getId( "K+" ) );
	static double mKz = EvtPDL::getMass( EvtPDL::getId( "K0" ) );
	- //G2 = _g2_g2psFactor(mKc,mKc,mKz,mKz,m);
	- G2 = _g2 * psFactor( mKc, mKc, mKz, mKz, m );
	+ G2 = m_g2 * psFactor( mKc, mKc, mKz, mKz, m );
	break;
	}
	default:
	@@ -447,28 +448,28 @@
	break;
	}
	// calculate standard couple BW propagator
	- if ( _coupling2 != WA76 )
	- prop = _g1 * propBreitWignerRelCoupled( _m0, G1, G2, m );
	+ if ( m_coupling2 != WA76 )
	+ prop = m_g1 * propBreitWignerRelCoupled( m_m0, G1, G2, m );
	}
	}
	amp *= prop;

	// Compute form-factors (Blatt-Weisskopf penetration factor)
	- amp *= _vb.formFactor( vb );
	- amp *= _vd.formFactor( vd );
	+ amp *= m_vb.formFactor( vb );
	+ amp *= m_vd.formFactor( vd );

	// Compute numerator (angular distribution)
	amp *= numerator( x, vb, vd );

	// Compute electromagnetic mass mixing factor
	- if ( _m0_mix > 0. ) {
	+ if ( m_m0_mix > 0. ) {
	EvtComplex prop_mix;
	- if ( _typeN == NBW ) {
	- prop_mix = propBreitWigner( _m0_mix, _g0_mix, m );
	+ if ( m_typeN == NBW ) {
	+ prop_mix = propBreitWigner( m_m0_mix, m_g0_mix, m );
	} else {
	- assert( _g1 < 0. ); // running width only
	- double g_mix = _g0_mix * _vd.widthFactor( vd );
	- prop_mix = propBreitWignerRel( _m0_mix, g_mix, m );
	+ assert( m_g1 < 0. ); // running width only
	+ double g_mix = m_g0_mix * m_vd.widthFactor( vd );
	+ prop_mix = propBreitWignerRel( m_m0_mix, g_mix, m );
	}
	amp *= mixFactor( prop, prop_mix );
	}
	@@ -563,7 +564,7 @@
	inline double EvtDalitzReso::GS_h( const double& m, const double& k )
	{
	return 2. / EvtConst::pi * k / m *
	- log( ( m + 2. * k ) / ( 2. * _massFirst ) );
	+ log( ( m + 2. * k ) / ( 2. * m_massFirst ) );
	}

	inline double EvtDalitzReso::GS_dhods( const double& m0, const double& k0 )
	@@ -574,10 +575,10 @@

	inline double EvtDalitzReso::GS_d( const double& m0, const double& k0 )
	{
	- return 3. / EvtConst::pi * _massFirst * _massFirst / ( k0 * k0 ) *
	- log( ( m0 + 2. * k0 ) / ( 2. * _massFirst ) ) +
	+ return 3. / EvtConst::pi * m_massFirst * m_massFirst / ( k0 * k0 ) *
	+ log( ( m0 + 2. * k0 ) / ( 2. * m_massFirst ) ) +
	m0 / ( 2. * EvtConst::pi * k0 ) -
	- _massFirst * _massFirst * m0 / ( EvtConst::pi * k0 * k0 * k0 );
	+ m_massFirst * m_massFirst * m0 / ( EvtConst::pi * k0 * k0 * k0 );
	}

	EvtComplex EvtDalitzReso::numerator( const EvtDalitzPoint& x,
	@@ -587,39 +588,39 @@
	EvtComplex ret( 0., 0. );

	// Non-relativistic Breit-Wigner
	- if ( NBW == _typeN ) {
	+ if ( NBW == m_typeN ) {
	ret = angDep( x );
	}

	// Standard relativistic Zemach propagator
	- else if ( RBW_ZEMACH == _typeN ) {
	- ret = _vd.phaseSpaceFactor( vd, EvtTwoBodyKine::AB ) * angDep( x );
	+ else if ( RBW_ZEMACH == m_typeN ) {
	+ ret = m_vd.phaseSpaceFactor( vd, EvtTwoBodyKine::AB ) * angDep( x );
	}

	// Standard relativistic Zemach propagator
	- else if ( RBW_ZEMACH2 == _typeN ) {
	- ret = _vd.phaseSpaceFactor( vd, EvtTwoBodyKine::AB ) *
	- _vb.phaseSpaceFactor( vb, EvtTwoBodyKine::AB ) * angDep( x );
	- if ( _spin == EvtSpinType::VECTOR ) {
	+ else if ( RBW_ZEMACH2 == m_typeN ) {
	+ ret = m_vd.phaseSpaceFactor( vd, EvtTwoBodyKine::AB ) *
	+ m_vb.phaseSpaceFactor( vb, EvtTwoBodyKine::AB ) * angDep( x );
	+ if ( m_spin == EvtSpinType::VECTOR ) {
	ret *= -4.;
	- } else if ( _spin == EvtSpinType::TENSOR ) {
	+ } else if ( m_spin == EvtSpinType::TENSOR ) {
	ret *= 16. / 3.;
	- } else if ( _spin != EvtSpinType::SCALAR )
	+ } else if ( m_spin != EvtSpinType::SCALAR )
	assert( 0 );
	}

	// Kuehn-Santamaria normalization:
	- else if ( RBW_KUEHN == _typeN ) {
	- ret = _m0 * _m0 * angDep( x );
	+ else if ( RBW_KUEHN == m_typeN ) {
	+ ret = m_m0 * m_m0 * angDep( x );
	}

	// CLEO amplitude
	- else if ( ( RBW_CLEO == _typeN ) \|\| ( GS_CLEO == _typeN ) \|\|
	- ( RBW_CLEO_ZEMACH == _typeN ) \|\| ( GS_CLEO_ZEMACH == _typeN ) \|\|
	- ( GAUSS_CLEO == _typeN ) \|\| ( GAUSS_CLEO_ZEMACH == _typeN ) ) {
	- Index iA = other( _pairAng ); // A = other(BC)
	- Index iB = common( _pairRes, _pairAng ); // B = common(AB,BC)
	- Index iC = other( _pairRes ); // C = other(AB)
	+ else if ( ( RBW_CLEO == m_typeN ) \|\| ( GS_CLEO == m_typeN ) \|\|
	+ ( RBW_CLEO_ZEMACH == m_typeN ) \|\| ( GS_CLEO_ZEMACH == m_typeN ) \|\|
	+ ( GAUSS_CLEO == m_typeN ) \|\| ( GAUSS_CLEO_ZEMACH == m_typeN ) ) {
	+ Index iA = other( m_pairAng ); // A = other(BC)
	+ Index iB = common( m_pairRes, m_pairAng ); // B = common(AB,BC)
	+ Index iC = other( m_pairRes ); // C = other(AB)

	double M = x.bigM();
	double mA = x.m( iA );
	@@ -630,20 +631,20 @@
	double qCA = x.q( combine( iC, iA ) );

	double M2 = M * M;
	- double m02 = ( ( RBW_CLEO_ZEMACH == _typeN ) \|\|
	- ( GS_CLEO_ZEMACH == _typeN ) \|\|
	- ( GAUSS_CLEO_ZEMACH == _typeN ) )
	+ double m02 = ( ( RBW_CLEO_ZEMACH == m_typeN ) \|\|
	+ ( GS_CLEO_ZEMACH == m_typeN ) \|\|
	+ ( GAUSS_CLEO_ZEMACH == m_typeN ) )
	? qAB
	- : _m0 * _m0;
	+ : m_m0 * m_m0;
	double mA2 = mA * mA;
	double mB2 = mB * mB;
	double mC2 = mC * mC;

	- if ( _spin == EvtSpinType::SCALAR )
	+ if ( m_spin == EvtSpinType::SCALAR )
	ret = EvtComplex( 1., 0. );
	- else if ( _spin == EvtSpinType::VECTOR ) {
	+ else if ( m_spin == EvtSpinType::VECTOR ) {
	ret = qCA - qBC + ( M2 - mC2 ) * ( mB2 - mA2 ) / m02;
	- } else if ( _spin == EvtSpinType::TENSOR ) {
	+ } else if ( m_spin == EvtSpinType::TENSOR ) {
	double x1 = qBC - qCA + ( M2 - mC2 ) * ( mA2 - mB2 ) / m02;
	double x2 = M2 - mC2;
	double x3 = qAB - 2 * M2 - 2 * mC2 + x2 * x2 / m02;
	@@ -662,22 +663,22 @@
	// Angular dependece for factorizable amplitudes
	// unphysical cosines indicate we are in big trouble
	double cosTh = x.cosTh(
	- _pairAng, _pairRes ); // angle between common(reso,ang) and other(reso)
	+ m_pairAng, m_pairRes ); // angle between common(reso,ang) and other(reso)
	if ( fabs( cosTh ) > 1. ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "cosTh " << cosTh << std::endl;
	assert( 0 );
	}

	// in units of half-spin
	- return EvtdFunction::d( EvtSpinType::getSpin2( _spin ), 2 * 0, 2 * 0,
	+ return EvtdFunction::d( EvtSpinType::getSpin2( m_spin ), 2 * 0, 2 * 0,
	acos( cosTh ) );
	}

	EvtComplex EvtDalitzReso::mixFactor( EvtComplex prop, EvtComplex prop_mix )
	{
	- double Delta = _delta_mix * ( _m0 + _m0_mix );
	+ double Delta = m_delta_mix * ( m_m0 + m_m0_mix );
	return 1 / ( 1 - Delta * Delta * prop * prop_mix ) *
	- ( 1 + _amp_mix * Delta * prop_mix );
	+ ( 1 + m_amp_mix * Delta * prop_mix );
	}

	EvtComplex EvtDalitzReso::Fvector( double s, int index )
	@@ -696,11 +697,11 @@
	double g[5][5]; // Coupling constants. The first index is the pole index. The second index is the decay channel
	double ma[5]; // Pole masses. The unit is in GeV

	- int solution = ( _typeN == K_MATRIX )
	+ int solution = ( m_typeN == K_MATRIX )
	? 3
	- : ( ( _typeN == K_MATRIX_I )
	+ : ( ( m_typeN == K_MATRIX_I )
	? 1
	- : ( ( _typeN == K_MATRIX_II ) ? 2 : 0 ) );
	+ : ( ( m_typeN == K_MATRIX_II ) ? 2 : 0 ) );
	if ( solution == 0 ) {
	std::cout << "EvtDalitzReso::Fvector() error. Kmatrix solution incorrectly chosen ! "
	<< std::endl;
	@@ -998,12 +999,12 @@
	} else {
	//this calculates fprod Factors
	value += U1j[0];
	- value += U1j[1] * _fr12prod;
	- value += U1j[2] * _fr13prod;
	- value += U1j[3] * _fr14prod;
	- value += U1j[4] * _fr15prod;
	+ value += U1j[1] * m_fr12prod;
	+ value += U1j[2] * m_fr13prod;
	+ value += U1j[3] * m_fr14prod;
	+ value += U1j[4] * m_fr15prod;

	- value = ( 1 - _s0prod ) / ( s - _s0prod ) smallTerm;
	+ value = ( 1 - m_s0prod ) / ( s - m_s0prod ) smallTerm;
	}

	return value;
	@@ -1012,34 +1013,34 @@
	//replace Breit-Wigner with LASS
	EvtComplex EvtDalitzReso::lass( double s )
	{
	- EvtTwoBodyKine vd( _massFirst, _massSecond, sqrt( s ) );
	+ EvtTwoBodyKine vd( m_massFirst, m_massSecond, sqrt( s ) );
	double q = vd.p();
	- double GammaM = _g0 * _vd.widthFactor( vd ); // running width;
	+ double GammaM = m_g0 * m_vd.widthFactor( vd ); // running width;

	//calculate the background phase motion
	- double cot_deltaB = 1.0 / ( _a * q ) + 0.5 * _r * q;
	+ double cot_deltaB = 1.0 / ( m_a * q ) + 0.5 * m_r * q;
	double deltaB = atan( 1.0 / cot_deltaB );
	- double totalB = deltaB + _phiB;
	+ double totalB = deltaB + m_phiB;

	//calculate the resonant phase motion
	- double deltaR = atan( ( _m0 * GammaM / ( _m0 * _m0 - s ) ) );
	- double totalR = deltaR + _phiR;
	+ double deltaR = atan( ( m_m0 * GammaM / ( m_m0 * m_m0 - s ) ) );
	+ double totalR = deltaR + m_phiR;

	//sum them up
	EvtComplex bkgB, resT;
	- bkgB = EvtComplex( _Blass * sin( totalB ), 0 ) *
	+ bkgB = EvtComplex( m_Blass * sin( totalB ), 0 ) *
	EvtComplex( cos( totalB ), sin( totalB ) );
	- resT = EvtComplex( _R * sin( deltaR ), 0 ) *
	+ resT = EvtComplex( m_R * sin( deltaR ), 0 ) *
	EvtComplex( cos( totalR ), sin( totalR ) ) *
	EvtComplex( cos( 2 * totalB ), sin( 2 * totalB ) );

	EvtComplex T;
	- if ( _cutoff > 0 && sqrt( s ) > _cutoff )
	+ if ( m_cutoff > 0 && sqrt( s ) > m_cutoff )
	T = resT;
	else
	T = bkgB + resT;

	- if ( _scaleByMOverQ )
	+ if ( m_scaleByMOverQ )
	T *= ( sqrt( s ) / q );

	return T;
	@@ -1049,8 +1050,8 @@
	{
	EvtComplex w;

	- for ( vector<EvtFlatteParam>::const_iterator param = _flatteParams.begin();
	- param != _flatteParams.end(); ++param ) {
	+ for ( vector<EvtFlatteParam>::const_iterator param = m_flatteParams.begin();
	+ param != m_flatteParams.end(); ++param ) {
	double m1 = ( *param ).m1();
	double m2 = ( *param ).m2();
	double g = ( *param ).g();
	@@ -1059,7 +1060,7 @@
	( 1 - ( ( m1 + m2 ) * ( m1 + m2 ) ) / ( m * m ) ) ) );
	}

	- EvtComplex denom = _m0 * _m0 - m * m - EvtComplex( 0, 1 ) * w;
	+ EvtComplex denom = m_m0 * m_m0 - m * m - EvtComplex( 0, 1 ) * w;

	return EvtComplex( 1.0, 0.0 ) / denom;
	}
	diff --git a/src/EvtGenBase/EvtDecayAmp.cpp b/src/EvtGenBase/EvtDecayAmp.cpp
	--- a/src/EvtGenBase/EvtDecayAmp.cpp
	+++ b/src/EvtGenBase/EvtDecayAmp.cpp
	@@ -40,14 +40,14 @@
	EvtSpinDensity rho;
	double prob, prob_max;

	- _amp2.init( p->getId(), getNDaug(), getDaugs() );
	+ m_amp2.init( p->getId(), getNDaug(), getDaugs() );

	do {
	- _daugsDecayedByParentModel = false;
	- _weight = 1.0;
	+ m_daugsDecayedByParentModel = false;
	+ m_weight = 1.0;
	decay( p );

	- rho = _amp2.getSpinDensity();
	+ rho = m_amp2.getSpinDensity();

	prob = p->getSpinDensityForward().normalizedProb( rho );

	@@ -87,9 +87,8 @@
	<< "parent channel :" << p->getParent()->getChannel()
	<< endl;

	- size_t i;
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << "parent daughters :";
	- for ( i = 0; i < p->getParent()->getNDaug(); i++ ) {
	+ for ( size_t i = 0; i < p->getParent()->getNDaug(); i++ ) {
	EvtGenReport( EVTGEN_DEBUG, "" )
	<< EvtPDL::name( p->getParent()->getDaug( i )->getId() )
	.c_str()
	@@ -117,7 +116,7 @@
	}
	}

	- prob /= _weight;
	+ prob /= m_weight;

	prob_max = getProbMax( prob );
	p->setDecayProb( prob / prob_max );
	@@ -156,10 +155,10 @@

	EvtAmp ampcont;

	- if ( _amp2._pstates != 1 ) {
	- ampcont = _amp2.contract( 0, p->getSpinDensityForward() );
	+ if ( m_amp2.m_pstates != 1 ) {
	+ ampcont = m_amp2.contract( 0, p->getSpinDensityForward() );
	} else {
	- ampcont = _amp2;
	+ ampcont = m_amp2;
	}

	// it may be that the parent decay model has already
	@@ -169,12 +168,12 @@
	if ( !daugsDecayedByParentModel() ) {
	if ( recursive ) {
	for ( size_t i = 0; i < p->getNDaug(); i++ ) {
	- rho.setDim( _amp2.dstates[i] );
	+ rho.setDim( m_amp2.m_dstates[i] );

	- if ( _amp2.dstates[i] == 1 ) {
	+ if ( m_amp2.m_dstates[i] == 1 ) {
	rho.set( 0, 0, EvtComplex( 1.0, 0.0 ) );
	} else {
	- rho = ampcont.contract( _amp2._dnontrivial[i], _amp2 );
	+ rho = ampcont.contract( m_amp2.m_dnontrivial[i], m_amp2 );
	}

	if ( !rho.check() ) {
	@@ -213,7 +212,7 @@
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< " EvtSpinDensity rho: " << rho;

	- _amp2.dump();
	+ m_amp2.dump();

	for ( size_t ii = 0; ii < i + 1; ii++ ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -229,13 +228,13 @@

	rho_list[i + 1] = p->getDaug( i )->getSpinDensityBackward();

	- if ( _amp2.dstates[i] != 1 ) {
	- ampcont = ampcont.contract( _amp2._dnontrivial[i],
	+ if ( m_amp2.m_dstates[i] != 1 ) {
	+ ampcont = ampcont.contract( m_amp2.m_dnontrivial[i],
	rho_list[i + 1] );
	}
	}

	- p->setSpinDensityBackward( _amp2.getBackwardSpinDensity( rho_list ) );
	+ p->setSpinDensityBackward( m_amp2.getBackwardSpinDensity( rho_list ) );

	if ( !p->getSpinDensityBackward().check() ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	diff --git a/src/EvtGenBase/EvtDecayBase.cpp b/src/EvtGenBase/EvtDecayBase.cpp
	--- a/src/EvtGenBase/EvtDecayBase.cpp
	+++ b/src/EvtGenBase/EvtDecayBase.cpp
	@@ -44,25 +44,25 @@
	//want to do this test. Why? Because sometimes the parent
	//will have a nonzero charge.

	- if ( _ndaug != 0 ) {
	- for ( i = 0; i < _ndaug; i++ ) {
	- q += EvtPDL::chg3( _daug[i] );
	+ if ( m_ndaug != 0 ) {
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ q += EvtPDL::chg3( m_daug[i] );
	}
	- qpar = EvtPDL::chg3( _parent );
	+ qpar = EvtPDL::chg3( m_parent );

	if ( q != qpar ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << _modelname.c_str() << " generator expected "
	+ << m_modelname.c_str() << " generator expected "
	<< " charge to be conserved, found:" << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Parent charge of " << ( qpar / 3 ) << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Sum of daughter charge of " << ( q / 3 ) << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "The parent is " << EvtPDL::name( _parent ).c_str() << endl;
	- for ( i = 0; i < _ndaug; i++ ) {
	+ << "The parent is " << EvtPDL::name( m_parent ).c_str() << endl;
	+ for ( i = 0; i < m_ndaug; i++ ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "Daughter " << EvtPDL::name( _daug[i] ).c_str() << endl;
	+ << "Daughter " << EvtPDL::name( m_daug[i] ).c_str() << endl;
	}
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Will terminate execution!" << endl;
	@@ -77,41 +77,41 @@
	int i;

	//diagnostics
	- sum_prob += prob;
	- if ( prob > max_prob )
	- max_prob = prob;
	-
	- if ( defaultprobmax && ntimes_prob <= 500 ) {
	- //We are building up probmax with this iteration
	- ntimes_prob += 1;
	- if ( prob > probmax ) {
	- probmax = prob;
	+ m_sum_prob += prob;
	+ if ( prob > m_max_prob )
	+ m_max_prob = prob;
	+
	+ if ( m_defaultprobmax && m_ntimes_prob <= 500 ) {
	+ //We are building up m_probmax with this iteration
	+ m_ntimes_prob += 1;
	+ if ( prob > m_probmax ) {
	+ m_probmax = prob;
	}
	- if ( ntimes_prob == 500 ) {
	- probmax *= 1.2;
	+ if ( m_ntimes_prob == 500 ) {
	+ m_probmax *= 1.2;
	}
	return 1000000.0 * prob;
	}

	- if ( prob > probmax * 1.0001 ) {
	+ if ( prob > m_probmax * 1.0001 ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "prob > probmax:(" << prob << ">" << probmax << ")";
	- EvtGenReport( EVTGEN_INFO, "" ) << "(" << _modelname.c_str() << ") ";
	+ << "prob > probmax:(" << prob << ">" << m_probmax << ")";
	+ EvtGenReport( EVTGEN_INFO, "" ) << "(" << m_modelname.c_str() << ") ";
	EvtGenReport( EVTGEN_INFO, "" )
	- << EvtPDL::name( _parent ).c_str() << " -> ";
	- for ( i = 0; i < _ndaug; i++ ) {
	+ << EvtPDL::name( m_parent ).c_str() << " -> ";
	+ for ( i = 0; i < m_ndaug; i++ ) {
	EvtGenReport( EVTGEN_INFO, "" )
	- << EvtPDL::name( _daug[i] ).c_str() << " ";
	+ << EvtPDL::name( m_daug[i] ).c_str() << " ";
	}
	EvtGenReport( EVTGEN_INFO, "" ) << endl;

	- if ( defaultprobmax )
	- probmax = prob;
	+ if ( m_defaultprobmax )
	+ m_probmax = prob;
	}

	- ntimes_prob += 1;
	+ m_ntimes_prob += 1;

	- return probmax;
	+ return m_probmax;

	} //getProbMax

	@@ -119,18 +119,18 @@
	{
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Reseting prob max\n";
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "prob > probmax:(" << prob << ">" << probmax << ")";
	- EvtGenReport( EVTGEN_INFO, "" ) << "(" << _modelname.c_str() << ")";
	- EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::getStdHep( _parent ) << "->";
	+ << "prob > probmax:(" << prob << ">" << m_probmax << ")";
	+ EvtGenReport( EVTGEN_INFO, "" ) << "(" << m_modelname.c_str() << ")";
	+ EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::getStdHep( m_parent ) << "->";

	- for ( int i = 0; i < _ndaug; i++ ) {
	- EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::getStdHep( _daug[i] ) << " ";
	+ for ( int i = 0; i < m_ndaug; i++ ) {
	+ EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::getStdHep( m_daug[i] ) << " ";
	}
	EvtGenReport( EVTGEN_INFO, "" ) << endl;

	- probmax = 0.0;
	- defaultprobmax = false;
	- ntimes_prob = 0;
	+ m_probmax = 0.0;
	+ m_defaultprobmax = false;
	+ m_ntimes_prob = 0;

	return prob;
	}
	@@ -195,14 +195,14 @@
	//specialized initialization.
	//The default is to set the maximum
	//probability to 0 and the number of times called to 0
	- //and defaultprobmax to 'true' such that the decay will be
	+ //and m_defaultprobmax to 'true' such that the decay will be
	//generated many many times
	//in order to generate a reasonable maximum probability
	//for the decay.

	- defaultprobmax = true;
	- ntimes_prob = 0;
	- probmax = 0.0;
	+ m_defaultprobmax = true;
	+ m_ntimes_prob = 0;
	+ m_probmax = 0.0;

	} //initProbMax

	@@ -212,49 +212,49 @@
	{
	int i;

	- _brfr = brfr;
	- _ndaug = ndaug;
	- _narg = narg;
	- _parent = ipar;
	+ m_brfr = brfr;
	+ m_ndaug = ndaug;
	+ m_narg = narg;
	+ m_parent = ipar;

	- _dsum = 0;
	+ m_dsum = 0;

	- if ( _ndaug > 0 ) {
	- _daug.resize( _ndaug );
	- for ( i = 0; i < _ndaug; i++ ) {
	- _daug[i] = daug[i];
	- _dsum += daug[i].getAlias();
	+ if ( m_ndaug > 0 ) {
	+ m_daug.resize( m_ndaug );
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ m_daug[i] = daug[i];
	+ m_dsum += daug[i].getAlias();
	}
	} else {
	- _daug.clear();
	+ m_daug.clear();
	}

	- if ( _narg > 0 ) {
	- _args.resize( _narg + 1 );
	- for ( i = 0; i < _narg; i++ ) {
	- _args[i] = args[i];
	+ if ( m_narg > 0 ) {
	+ m_args.resize( m_narg + 1 );
	+ for ( i = 0; i < m_narg; i++ ) {
	+ m_args[i] = args[i];
	}
	} else {
	- _args.clear();
	+ m_args.clear();
	}

	- _modelname = name;
	+ m_modelname = name;

	this->init();
	this->initProbMax();

	- if ( _chkCharge ) {
	+ if ( m_chkCharge ) {
	this->checkQ();
	}

	- if ( defaultprobmax ) {
	+ if ( m_defaultprobmax ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "No default probmax for ";
	- EvtGenReport( EVTGEN_INFO, "" ) << "(" << _modelname.c_str() << ") ";
	+ EvtGenReport( EVTGEN_INFO, "" ) << "(" << m_modelname.c_str() << ") ";
	EvtGenReport( EVTGEN_INFO, "" )
	- << EvtPDL::name( _parent ).c_str() << " -> ";
	- for ( i = 0; i < _ndaug; i++ ) {
	+ << EvtPDL::name( m_parent ).c_str() << " -> ";
	+ for ( i = 0; i < m_ndaug; i++ ) {
	EvtGenReport( EVTGEN_INFO, "" )
	- << EvtPDL::name( _daug[i] ).c_str() << " ";
	+ << EvtPDL::name( m_daug[i] ).c_str() << " ";
	}
	EvtGenReport( EVTGEN_INFO, "" ) << endl;
	EvtGenReport( EVTGEN_INFO, "" )
	@@ -271,13 +271,13 @@

	void EvtDecayBase::printSummary() const
	{
	- if ( ntimes_prob > 0 ) {
	+ if ( m_ntimes_prob > 0 ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "Calls = " << ntimes_prob
	- << " eff: " << sum_prob / ( probmax * ntimes_prob )
	- << " frac. max:" << max_prob / probmax;
	+ << "Calls = " << m_ntimes_prob
	+ << " eff: " << m_sum_prob / ( m_probmax * m_ntimes_prob )
	+ << " frac. max:" << m_max_prob / m_probmax;
	EvtGenReport( EVTGEN_INFO, "" )
	- << " probmax:" << probmax << " max:" << max_prob << " : ";
	+ << " probmax:" << m_probmax << " max:" << m_max_prob << " : ";
	}

	printInfo();
	@@ -285,23 +285,23 @@

	void EvtDecayBase::printInfo() const
	{
	- EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::name( _parent ).c_str() << " -> ";
	- for ( int i = 0; i < _ndaug; i++ ) {
	+ EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::name( m_parent ).c_str() << " -> ";
	+ for ( int i = 0; i < m_ndaug; i++ ) {
	EvtGenReport( EVTGEN_INFO, "" )
	- << EvtPDL::name( _daug[i] ).c_str() << " ";
	+ << EvtPDL::name( m_daug[i] ).c_str() << " ";
	}
	- EvtGenReport( EVTGEN_INFO, "" ) << " (" << _modelname.c_str() << ")" << endl;
	+ EvtGenReport( EVTGEN_INFO, "" ) << " (" << m_modelname.c_str() << ")" << endl;
	}

	void EvtDecayBase::setProbMax( double prbmx )
	{
	- defaultprobmax = false;
	- probmax = prbmx;
	+ m_defaultprobmax = false;
	+ m_probmax = prbmx;
	}

	void EvtDecayBase::noProbMax()
	{
	- defaultprobmax = false;
	+ m_defaultprobmax = false;
	}

	double EvtDecayBase::findMaxMass( EvtParticle* p )
	@@ -442,7 +442,7 @@
	return;
	}

	- //until we get a combo whose masses are less than _parent mass.
	+ //until we get a combo whose masses are less than the parent mass.
	do {
	mass_sum = 0.0;

	@@ -492,9 +492,9 @@

	void EvtDecayBase::checkNArg( int a1, int a2, int a3, int a4 )
	{
	- if ( _narg != a1 && _narg != a2 && _narg != a3 && _narg != a4 ) {
	+ if ( m_narg != a1 && m_narg != a2 && m_narg != a3 && m_narg != a4 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << _modelname.c_str() << " generator expected " << endl;
	+ << m_modelname.c_str() << " generator expected " << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << a1 << endl;
	;
	if ( a2 > -1 ) {
	@@ -507,7 +507,7 @@
	EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " or " << a4 << endl;
	}
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << " arguments but found:" << _narg << endl;
	+ << " arguments but found:" << m_narg << endl;
	printSummary();
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Will terminate execution!" << endl;
	@@ -516,15 +516,15 @@
	}
	void EvtDecayBase::checkNDaug( int d1, int d2 )
	{
	- if ( _ndaug != d1 && _ndaug != d2 ) {
	+ if ( m_ndaug != d1 && m_ndaug != d2 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << _modelname.c_str() << " generator expected ";
	+ << m_modelname.c_str() << " generator expected ";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << d1;
	if ( d2 > -1 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " or " << d2;
	}
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << " daughters but found:" << _ndaug << endl;
	+ << " daughters but found:" << m_ndaug << endl;
	printSummary();
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Will terminate execution!" << endl;
	@@ -537,7 +537,7 @@
	EvtSpinType::spintype parenttype = EvtPDL::getSpinType( getParentId() );
	if ( parenttype != sp ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << _modelname.c_str() << " did not get the correct parent spin\n";
	+ << m_modelname.c_str() << " did not get the correct parent spin\n";
	printSummary();
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Will terminate execution!" << endl;
	@@ -550,7 +550,7 @@
	EvtSpinType::spintype parenttype = EvtPDL::getSpinType( getDaug( d1 ) );
	if ( parenttype != sp ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << _modelname.c_str()
	+ << m_modelname.c_str()
	<< " did not get the correct daughter spin d=" << d1 << endl;
	printSummary();
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -561,19 +561,19 @@

	double* EvtDecayBase::getArgs()
	{
	- if ( !_argsD.empty() )
	- return _argsD.data();
	+ if ( !m_argsD.empty() )
	+ return m_argsD.data();
	//The user has asked for a list of doubles - the arguments
	//better all be doubles...
	- if ( _narg == 0 )
	- return _argsD.data();
	+ if ( m_narg == 0 )
	+ return m_argsD.data();

	- _argsD.resize( _narg );
	- for ( int i = 0; i < _narg; i++ ) {
	+ m_argsD.resize( m_narg );
	+ for ( int i = 0; i < m_narg; i++ ) {
	char* tc;
	- _argsD[i] = strtod( _args[i].c_str(), &tc );
	+ m_argsD[i] = strtod( m_args[i].c_str(), &tc );
	}
	- return _argsD.data();
	+ return m_argsD.data();
	}

	double EvtDecayBase::getArg( unsigned int j )
	@@ -585,7 +585,7 @@
	++i;
	}

	- const char* str = _args[j].c_str();
	+ const char* str = m_args[j].c_str();
	int i = 0;
	while ( str[i] != 0 ) {
	if ( isalpha( str[i] ) && str[i] != 'e' ) {
	@@ -597,10 +597,10 @@
	}

	char** tc = nullptr;
	- double result = strtod( _args[j].c_str(), tc );
	+ double result = strtod( m_args[j].c_str(), tc );

	- if ( _storedArgs.size() < j + 1 ) { // then store the argument's value
	- _storedArgs.push_back( result );
	+ if ( m_storedArgs.size() < j + 1 ) { // then store the argument's value
	+ m_storedArgs.push_back( result );
	}

	return result;
	@@ -608,22 +608,22 @@

	bool EvtDecayBase::matchingDecay( const EvtDecayBase& other ) const
	{
	- if ( _ndaug != other._ndaug )
	+ if ( m_ndaug != other.m_ndaug )
	return false;
	- if ( _parent != other._parent )
	+ if ( m_parent != other.m_parent )
	return false;

	std::vector<int> useDs;
	- for ( int i = 0; i < _ndaug; i++ )
	+ for ( int i = 0; i < m_ndaug; i++ )
	useDs.push_back( 0 );

	- for ( int i = 0; i < _ndaug; i++ ) {
	+ for ( int i = 0; i < m_ndaug; i++ ) {
	bool foundIt = false;
	- for ( int j = 0; j < _ndaug; j++ ) {
	+ for ( int j = 0; j < m_ndaug; j++ ) {
	if ( useDs[j] == 1 )
	continue;
	- if ( _daug[i] == other._daug[j] &&
	- _daug[i].getAlias() == other._daug[j].getAlias() ) {
	+ if ( m_daug[i] == other.m_daug[j] &&
	+ m_daug[i].getAlias() == other.m_daug[j].getAlias() ) {
	foundIt = true;
	useDs[j] = 1;
	break;
	@@ -632,7 +632,7 @@
	if ( foundIt == false )
	return false;
	}
	- for ( int i = 0; i < _ndaug; i++ )
	+ for ( int i = 0; i < m_ndaug; i++ )
	if ( useDs[i] == 0 )
	return false;

	diff --git a/src/EvtGenBase/EvtDecayIncoherent.cpp b/src/EvtGenBase/EvtDecayIncoherent.cpp
	--- a/src/EvtGenBase/EvtDecayIncoherent.cpp
	+++ b/src/EvtGenBase/EvtDecayIncoherent.cpp
	@@ -32,10 +32,10 @@
	//initialize this the hard way..
	//Lange June 26, 2000
	for ( size_t i = 0; i < static_cast<unsigned int>( MAX_DAUG ); i++ ) {
	- spinDensitySet[i] = 0;
	+ m_spinDensitySet[i] = 0;
	}

	- _daugsDecayedByParentModel = false;
	+ m_daugsDecayedByParentModel = false;

	decay( p );
	p->setDecayProb( 1.0 );
	diff --git a/src/EvtGenBase/EvtDecayMode.cpp b/src/EvtGenBase/EvtDecayMode.cpp
	--- a/src/EvtGenBase/EvtDecayMode.cpp
	+++ b/src/EvtGenBase/EvtDecayMode.cpp
	@@ -32,12 +32,12 @@
	using std::vector;

	EvtDecayMode::EvtDecayMode( std::string mother, vector<string> dau ) :
	- _mother( mother ), _dau( dau )
	+ m_mother( mother ), m_dau( dau )
	{
	}

	EvtDecayMode::EvtDecayMode( const EvtDecayMode& other ) :
	- _mother( other._mother ), _dau( other._dau )
	+ m_mother( other.m_mother ), m_dau( other.m_dau )
	{
	}

	@@ -65,7 +65,7 @@
	assert( 0 );
	}

	- _mother = string( s, i, j - i );
	+ m_mother = string( s, i, j - i );

	i = s.find_first_not_of( " ", j );
	j = s.find_first_of( "->", j );
	@@ -83,46 +83,46 @@
	if ( i == string::npos )
	break;
	if ( j == string::npos ) {
	- _dau.push_back( string( s, i, s.size() - i + 1 ) );
	+ m_dau.push_back( string( s, i, s.size() - i + 1 ) );
	break;
	} else {
	- _dau.push_back( string( s, i, j - i ) );
	+ m_dau.push_back( string( s, i, j - i ) );
	}
	}
	}

	const char* EvtDecayMode::mother() const
	{
	- return _mother.c_str();
	+ return m_mother.c_str();
	}

	int EvtDecayMode::nD() const
	{
	- return _dau.size();
	+ return m_dau.size();
	}

	const char* EvtDecayMode::dau( int i ) const
	{
	- assert( 0 <= i && i < (int)_dau.size() );
	- return _dau[i].c_str();
	+ assert( 0 <= i && i < (int)m_dau.size() );
	+ return m_dau[i].c_str();
	}

	std::string EvtDecayMode::mode() const
	{
	- string ret = _mother + string( " -> " );
	+ string ret = m_mother + string( " -> " );

	- for ( size_t i = 0; i < _dau.size() - 1; i++ ) {
	- ret += string( _dau[i] ) + string( " " );
	+ for ( size_t i = 0; i < m_dau.size() - 1; i++ ) {
	+ ret += string( m_dau[i] ) + string( " " );
	}
	- ret += _dau[_dau.size() - 1];
	+ ret += m_dau[m_dau.size() - 1];
	return ret;
	}

	ostream& EvtDecayMode::print( ostream& os ) const
	{
	- os << _mother.c_str() << " ->";
	- for ( size_t i = 0; i < _dau.size(); i++ ) {
	- os << " " << _dau[i].c_str();
	+ os << m_mother.c_str() << " ->";
	+ for ( size_t i = 0; i < m_dau.size(); i++ ) {
	+ os << " " << m_dau[i].c_str();
	}
	return os;
	}
	diff --git a/src/EvtGenBase/EvtDecayProb.cpp b/src/EvtGenBase/EvtDecayProb.cpp
	--- a/src/EvtGenBase/EvtDecayProb.cpp
	+++ b/src/EvtGenBase/EvtDecayProb.cpp
	@@ -36,19 +36,19 @@
	double dummy;

	do {
	- _weight = 1.0;
	- _daugsDecayedByParentModel = false;
	+ m_weight = 1.0;
	+ m_daugsDecayedByParentModel = false;

	decay( p );

	ntimes--;

	- _prob = _prob / _weight;
	+ m_prob = m_prob / m_weight;

	- dummy = getProbMax( _prob ) * EvtRandom::Flat();
	- p->setDecayProb( _prob / getProbMax( _prob ) );
	+ dummy = getProbMax( m_prob ) * EvtRandom::Flat();
	+ p->setDecayProb( m_prob / getProbMax( m_prob ) );

	- } while ( ntimes && ( _prob < dummy ) );
	+ } while ( ntimes && ( m_prob < dummy ) );

	if ( ntimes == 0 ) {
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	diff --git a/src/EvtGenBase/EvtDecayTable.cpp b/src/EvtGenBase/EvtDecayTable.cpp
	--- a/src/EvtGenBase/EvtDecayTable.cpp
	+++ b/src/EvtGenBase/EvtDecayTable.cpp
	@@ -48,12 +48,12 @@

	EvtDecayTable::EvtDecayTable()
	{
	- _decaytable.clear();
	+ m_decaytable.clear();
	}

	EvtDecayTable::~EvtDecayTable()
	{
	- _decaytable.clear();
	+ m_decaytable.clear();
	}

	EvtDecayTable* EvtDecayTable::getInstance()
	@@ -69,18 +69,18 @@

	int EvtDecayTable::getNMode( int ipar )
	{
	- return _decaytable[ipar].getNMode();
	+ return m_decaytable[ipar].getNMode();
	}

	EvtDecayBase* EvtDecayTable::getDecay( int ipar, int imode )
	{
	- return _decaytable[ipar].getDecayModel( imode );
	+ return m_decaytable[ipar].getDecayModel( imode );
	}

	void EvtDecayTable::printSummary()
	{
	for ( size_t i = 0; i < EvtPDL::entries(); i++ ) {
	- _decaytable[i].printSummary();
	+ m_decaytable[i].printSummary();
	}
	}

	@@ -90,15 +90,15 @@

	partnum = p->getId().getAlias();

	- if ( _decaytable[partnum].getNMode() == 0 )
	+ if ( m_decaytable[partnum].getNMode() == 0 )
	return nullptr;
	- return _decaytable[partnum].getDecayModel( p );
	+ return m_decaytable[partnum].getDecayModel( p );
	}

	void EvtDecayTable::readDecayFile( const std::string dec_name, bool verbose )
	{
	- if ( _decaytable.size() < EvtPDL::entries() )
	- _decaytable.resize( EvtPDL::entries() );
	+ if ( m_decaytable.size() < EvtPDL::entries() )
	+ m_decaytable.resize( EvtPDL::entries() );
	EvtModel& modelist = EvtModel::instance();
	EvtExtGeneratorCommandsTable* extGenCommands =
	EvtExtGeneratorCommandsTable::getInstance();
	@@ -232,8 +232,8 @@
	}

	EvtPDL::alias( id, newname );
	- if ( _decaytable.size() < EvtPDL::entries() )
	- _decaytable.resize( EvtPDL::entries() );
	+ if ( m_decaytable.size() < EvtPDL::entries() )
	+ m_decaytable.resize( EvtPDL::entries() );

	} else if ( token == "ModelAlias" ) {
	std::vector<std::string> modelArgList;
	@@ -379,18 +379,18 @@

	EvtId cipar = EvtPDL::chargeConj( ipar );

	- if ( _decaytable[ipar.getAlias()].getNMode() != 0 ) {
	+ if ( m_decaytable[ipar.getAlias()].getNMode() != 0 ) {
	if ( verbose )
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "Redefined decay of " << name.c_str() << " in CDecay"
	<< endl;

	- _decaytable[ipar.getAlias()].removeDecay();
	+ m_decaytable[ipar.getAlias()].removeDecay();
	}

	//take contents of cipar and conjugate and store in ipar
	- _decaytable[ipar.getAlias()].makeChargeConj(
	- &_decaytable[cipar.getAlias()] );
	+ m_decaytable[ipar.getAlias()].makeChargeConj(
	+ &m_decaytable[cipar.getAlias()] );

	} else if ( token == "Define" ) {
	std::string name;
	@@ -576,10 +576,10 @@
	::abort();
	}

	- if ( _decaytable[ipar.getAlias()].getNMode() != 0 ) {
	+ if ( m_decaytable[ipar.getAlias()].getNMode() != 0 ) {
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "Redefined decay of " << parent.c_str() << endl;
	- _decaytable[ipar.getAlias()].removeDecay();
	+ m_decaytable[ipar.getAlias()].removeDecay();
	}

	do {
	@@ -661,7 +661,7 @@
	model = parser.getToken( itoken++ );

	bool fsr = false;
	- bool verbose = false;
	+ bool verboseModel = false;
	bool summary = false;

	do {
	@@ -675,7 +675,7 @@
	model = parser.getToken( itoken++ );
	}
	if ( model == "VERBOSE" ) {
	- verbose = true;
	+ verboseModel = true;
	model = parser.getToken( itoken++ );
	}
	if ( model == "SUMMARY" ) {
	@@ -715,8 +715,7 @@
	if ( fsr ) {
	temp_fcn_new->setFSR();
	}
	-
	- if ( verbose ) {
	+ if ( verboseModel ) {
	temp_fcn_new->setVerbose();
	}
	if ( summary ) {
	@@ -746,7 +745,7 @@
	}
	}
	//int isname=EvtPDL::getId(name).getId()>=0;
	- int ismodel = modelist.isModel( name );
	+ ismodel = modelist.isModel( name );
	if ( ismodel ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Expected ';' but found:" << name.c_str()
	@@ -787,12 +786,12 @@
	}
	}

	- _decaytable[ipar.getAlias()].addMode( temp_fcn_new, brfrsum,
	- massmin );
	+ m_decaytable[ipar.getAlias()].addMode( temp_fcn_new,
	+ brfrsum, massmin );
	}
	} while ( token != "Enddecay" );

	- _decaytable[ipar.getAlias()].finalize();
	+ m_decaytable[ipar.getAlias()].finalize();

	}
	// Allow copying of decays from one particle to another; useful
	@@ -823,12 +822,12 @@
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- if ( _decaytable[newipar.getAlias()].getNMode() != 0 ) {
	+ if ( m_decaytable[newipar.getAlias()].getNMode() != 0 ) {
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "Redefining decay of " << newname << endl;
	- _decaytable[newipar.getAlias()].removeDecay();
	+ m_decaytable[newipar.getAlias()].removeDecay();
	}
	- _decaytable[newipar.getAlias()] = _decaytable[oldipar.getAlias()];
	+ m_decaytable[newipar.getAlias()] = m_decaytable[oldipar.getAlias()];
	}
	// Enable decay deletion; intended primarily for aliases
	// Peter Onyisi, March 2008
	@@ -845,7 +844,7 @@
	::abort();
	}

	- if ( _decaytable[ipar.getAlias()].getNMode() == 0 ) {
	+ if ( m_decaytable[ipar.getAlias()].getNMode() == 0 ) {
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "No decays to delete for " << parent.c_str() << endl;
	} else {
	@@ -890,7 +889,7 @@
	temp_fcn_new->saveDecayInfo( ipar, n_daugh, daught, 0,
	temp_fcn_new_args,
	temp_fcn_new_model, 0. );
	- _decaytable[ipar.getAlias()].removeMode( temp_fcn_new );
	+ m_decaytable[ipar.getAlias()].removeMode( temp_fcn_new );
	}
	} while ( token != "Enddecay" );
	itoken++;
	@@ -919,7 +918,7 @@
	int jj;
	double minMass = EvtPDL::getMaxMass( temp );
	for ( jj = 0; jj < nModTot; jj++ ) {
	- double tmass = _decaytable[ii].getDecay( jj ).getMassMin();
	+ double tmass = m_decaytable[ii].getDecay( jj ).getMassMin();
	if ( tmass < minMass )
	minMass = tmass;
	}
	@@ -936,8 +935,8 @@

	void EvtDecayTable::readXMLDecayFile( const std::string dec_name, bool verbose )
	{
	- if ( _decaytable.size() < EvtPDL::entries() )
	- _decaytable.resize( EvtPDL::entries() );
	+ if ( m_decaytable.size() < EvtPDL::entries() )
	+ m_decaytable.resize( EvtPDL::entries() );
	EvtModel& modelist = EvtModel::instance();
	EvtExtGeneratorCommandsTable* extGenCommands =
	EvtExtGeneratorCommandsTable::getInstance();
	@@ -990,8 +989,8 @@
	EvtId id = EvtPDL::getId( particle );

	EvtPDL::alias( id, alias );
	- if ( _decaytable.size() < EvtPDL::entries() )
	- _decaytable.resize( EvtPDL::entries() );
	+ if ( m_decaytable.size() < EvtPDL::entries() )
	+ m_decaytable.resize( EvtPDL::entries() );

	} else if ( parser.getTagTitle() == "modelAlias" ) {
	std::vector<std::string> modelArgList;
	@@ -1045,18 +1044,18 @@
	checkParticle( particle );
	checkParticle( abar.getName() );

	- if ( _decaytable[a.getAlias()].getNMode() != 0 ) {
	+ if ( m_decaytable[a.getAlias()].getNMode() != 0 ) {
	if ( verbose )
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "Redefined decay of " << particle.c_str()
	<< " in ConjDecay" << endl;

	- _decaytable[a.getAlias()].removeDecay();
	+ m_decaytable[a.getAlias()].removeDecay();
	}

	//take contents of abar and conjugate and store in a
	- _decaytable[a.getAlias()].makeChargeConj(
	- &_decaytable[abar.getAlias()] );
	+ m_decaytable[a.getAlias()].makeChargeConj(
	+ &m_decaytable[abar.getAlias()] );

	} else if ( parser.getTagTitle() == "define" ) {
	std::string name = parser.readAttribute( "name" );
	@@ -1192,10 +1191,10 @@
	checkParticle( decayParent );
	ipar = EvtPDL::getId( decayParent );

	- if ( _decaytable[ipar.getAlias()].getNMode() != 0 ) {
	+ if ( m_decaytable[ipar.getAlias()].getNMode() != 0 ) {
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "Redefined decay of " << decayParent.c_str() << endl;
	- _decaytable[ipar.getAlias()].removeDecay();
	+ m_decaytable[ipar.getAlias()].removeDecay();
	}

	} else if ( parser.getTagTitle() == "copyDecay" ) {
	@@ -1208,19 +1207,20 @@
	checkParticle( particle );
	checkParticle( copy );

	- if ( _decaytable[newipar.getAlias()].getNMode() != 0 ) {
	+ if ( m_decaytable[newipar.getAlias()].getNMode() != 0 ) {
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "Redefining decay of " << particle << endl;
	- _decaytable[newipar.getAlias()].removeDecay();
	+ m_decaytable[newipar.getAlias()].removeDecay();
	}
	- _decaytable[newipar.getAlias()] = _decaytable[oldipar.getAlias()];
	+ m_decaytable[newipar.getAlias()] =
	+ m_decaytable[oldipar.getAlias()];

	} else if ( parser.getTagTitle() == "removeDecay" ) {
	decayParent = parser.readAttribute( "particle" );
	checkParticle( decayParent );
	ipar = EvtPDL::getId( decayParent );

	- if ( _decaytable[ipar.getAlias()].getNMode() == 0 ) {
	+ if ( m_decaytable[ipar.getAlias()].getNMode() == 0 ) {
	EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
	<< "No decays to delete for " << decayParent.c_str()
	<< endl;
	@@ -1399,11 +1399,11 @@
	}
	}

	- _decaytable[ipar.getAlias()].addMode( temp_fcn_new, brfrSum,
	- massMin );
	+ m_decaytable[ipar.getAlias()].addMode( temp_fcn_new, brfrSum,
	+ massMin );

	} else if ( parser.getTagTitle() == "/decay" ) { //end of a particle
	- _decaytable[ipar.getAlias()].finalize();
	+ m_decaytable[ipar.getAlias()].finalize();
	} else
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Unexpected tag " << parser.getTagTitle()
	@@ -1431,7 +1431,7 @@
	temp_fcn_new->saveDecayInfo( ipar, nDaughters, daughter, 0,
	temp_fcn_new_args,
	temp_fcn_new_model, 0. );
	- _decaytable[ipar.getAlias()].removeMode( temp_fcn_new );
	+ m_decaytable[ipar.getAlias()].removeMode( temp_fcn_new );
	} else if ( parser.getTagTitle() != "/removeDecay" ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Unexpected tag " << parser.getTagTitle()
	@@ -1462,7 +1462,7 @@
	int jj;
	double minMass = EvtPDL::getMaxMass( temp );
	for ( jj = 0; jj < nModTot; jj++ ) {
	- double tmass = _decaytable[ii].getDecay( jj ).getMassMin();
	+ double tmass = m_decaytable[ii].getDecay( jj ).getMassMin();
	if ( tmass < minMass )
	minMass = tmass;
	}
	@@ -1508,7 +1508,7 @@
	EvtDecayBase* theModel( nullptr );

	if ( aliasInt >= 0 && aliasInt < (int)EvtPDL::entries() ) {
	- theModel = _decaytable[aliasInt].getDecayModel( modeInt );
	+ theModel = m_decaytable[aliasInt].getDecayModel( modeInt );
	}

	return theModel;
	@@ -1524,7 +1524,7 @@
	{
	bool hasPythia( false );
	if ( aliasInt >= 0 && aliasInt < (int)EvtPDL::entries() ) {
	- hasPythia = _decaytable[aliasInt].isJetSet();
	+ hasPythia = m_decaytable[aliasInt].isJetSet();
	}

	return hasPythia;
	@@ -1541,7 +1541,7 @@
	int nModes( 0 );

	if ( aliasInt >= 0 && aliasInt < (int)EvtPDL::entries() ) {
	- nModes = _decaytable[aliasInt].getNMode();
	+ nModes = m_decaytable[aliasInt].getNMode();
	}

	return nModes;
	@@ -1554,18 +1554,18 @@
	EvtId daugs_scratch[50];
	int nmatch, k;

	- for ( i = 0; i < _decaytable[parent.getAlias()].getNMode(); i++ ) {
	+ for ( i = 0; i < m_decaytable[parent.getAlias()].getNMode(); i++ ) {
	right = 1;

	- right = right && model == _decaytable[parent.getAlias()]
	+ right = right && model == m_decaytable[parent.getAlias()]
	.getDecay( i )
	.getDecayModel()
	->getModelName();
	- right = right && ( ndaug == _decaytable[parent.getAlias()]
	+ right = right && ( ndaug == m_decaytable[parent.getAlias()]
	.getDecay( i )
	.getDecayModel()
	->getNDaug() );
	- right = right && ( narg == _decaytable[parent.getAlias()]
	+ right = right && ( narg == m_decaytable[parent.getAlias()]
	.getDecay( i )
	.getDecayModel()
	->getNArg() );
	@@ -1577,13 +1577,13 @@

	nmatch = 0;

	- for ( j = 0; j < _decaytable[parent.getAlias()]
	+ for ( j = 0; j < m_decaytable[parent.getAlias()]
	.getDecay( i )
	.getDecayModel()
	->getNDaug();
	j++ ) {
	for ( k = 0; k < ndaug; k++ ) {
	- if ( daugs_scratch[k] == _decaytable[parent.getAlias()]
	+ if ( daugs_scratch[k] == m_decaytable[parent.getAlias()]
	.getDecay( i )
	.getDecayModel()
	->getDaug( j ) ) {
	@@ -1596,12 +1596,12 @@

	right = right && ( nmatch == ndaug );

	- for ( j = 0; j < _decaytable[parent.getAlias()]
	+ for ( j = 0; j < m_decaytable[parent.getAlias()]
	.getDecay( i )
	.getDecayModel()
	->getNArg();
	j++ ) {
	- right = right && ( args[j] == _decaytable[parent.getAlias()]
	+ right = right && ( args[j] == m_decaytable[parent.getAlias()]
	.getDecay( i )
	.getDecayModel()
	->getArgStr( j ) );
	@@ -1627,11 +1627,11 @@

	int ipar = parent.getAlias();

	- int nmode = _decaytable[ipar].getNMode();
	+ int nmode = m_decaytable[ipar].getNMode();

	for ( i = 0; i < nmode; i++ ) {
	EvtDecayBase* thedecaymodel =
	- _decaytable[ipar].getDecay( i ).getDecayModel();
	+ m_decaytable[ipar].getDecay( i ).getDecayModel();

	if ( thedecaymodel->getDSum() == dsum ) {
	int nd = thedecaymodel->getNDaug();
	diff --git a/src/EvtGenBase/EvtDiracParticle.cpp b/src/EvtGenBase/EvtDiracParticle.cpp
	--- a/src/EvtGenBase/EvtDiracParticle.cpp
	+++ b/src/EvtGenBase/EvtDiracParticle.cpp
	@@ -35,7 +35,7 @@

	void EvtDiracParticle::init( EvtId part_n, const EvtVector4R& p4 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( part_n );

	@@ -47,26 +47,26 @@
	}

	if ( EvtPDL::getStdHep( part_n ) > 0 ) {
	- _spinorRest[0].set( EvtComplex( sqrt( 2.0 * mass() ), 0.0 ),
	- EvtComplex( 0.0, 0.0 ), EvtComplex( 0.0, 0.0 ),
	- EvtComplex( 0.0, 0.0 ) );
	- _spinorRest[1].set( EvtComplex( 0.0, 0.0 ),
	- EvtComplex( sqrt( 2.0 * mass() ), 0.0 ),
	- EvtComplex( 0.0, 0.0 ), EvtComplex( 0.0, 0.0 ) );
	+ m_spinorRest[0].set( EvtComplex( sqrt( 2.0 * mass() ), 0.0 ),
	+ EvtComplex( 0.0, 0.0 ), EvtComplex( 0.0, 0.0 ),
	+ EvtComplex( 0.0, 0.0 ) );
	+ m_spinorRest[1].set( EvtComplex( 0.0, 0.0 ),
	+ EvtComplex( sqrt( 2.0 * mass() ), 0.0 ),
	+ EvtComplex( 0.0, 0.0 ), EvtComplex( 0.0, 0.0 ) );

	- _spinorParent[0] = boostTo( _spinorRest[0], p4 );
	- _spinorParent[1] = boostTo( _spinorRest[1], p4 );
	+ m_spinorParent[0] = boostTo( m_spinorRest[0], p4 );
	+ m_spinorParent[1] = boostTo( m_spinorRest[1], p4 );

	} else {
	- _spinorRest[0].set( EvtComplex( 0.0, 0.0 ), EvtComplex( 0.0, 0.0 ),
	- EvtComplex( sqrt( 2.0 * mass() ), 0.0 ),
	- EvtComplex( 0.0, 0.0 ) );
	- _spinorRest[1].set( EvtComplex( 0.0, 0.0 ), EvtComplex( 0.0, 0.0 ),
	- EvtComplex( 0.0, 0.0 ),
	- EvtComplex( sqrt( 2.0 * mass() ), 0.0 ) );
	-
	- _spinorParent[0] = boostTo( _spinorRest[0], p4 );
	- _spinorParent[1] = boostTo( _spinorRest[1], p4 );
	+ m_spinorRest[0].set( EvtComplex( 0.0, 0.0 ), EvtComplex( 0.0, 0.0 ),
	+ EvtComplex( sqrt( 2.0 * mass() ), 0.0 ),
	+ EvtComplex( 0.0, 0.0 ) );
	+ m_spinorRest[1].set( EvtComplex( 0.0, 0.0 ), EvtComplex( 0.0, 0.0 ),
	+ EvtComplex( 0.0, 0.0 ),
	+ EvtComplex( sqrt( 2.0 * mass() ), 0.0 ) );
	+
	+ m_spinorParent[0] = boostTo( m_spinorRest[0], p4 );
	+ m_spinorParent[1] = boostTo( m_spinorRest[1], p4 );
	}

	setLifetime();
	@@ -78,7 +78,7 @@
	const EvtDiracSpinor& rest1,
	const EvtDiracSpinor& rest2 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( part_n );

	@@ -88,10 +88,10 @@
	<< std::endl;
	::abort();
	}
	- _spinorRest[0] = rest1;
	- _spinorRest[1] = rest2;
	- _spinorParent[0] = prod1;
	- _spinorParent[1] = prod2;
	+ m_spinorRest[0] = rest1;
	+ m_spinorRest[1] = rest2;
	+ m_spinorParent[0] = prod1;
	+ m_spinorParent[1] = prod2;

	setLifetime();
	}
	@@ -115,8 +115,8 @@
	R.setDim( 2 );

	for ( int i = 0; i < 2; i++ ) {
	- R.set( 0, i, ( spplus * _spinorRest[i] ) / sqmt2 );
	- R.set( 1, i, ( spminus * _spinorRest[i] ) / sqmt2 );
	+ R.set( 0, i, ( spplus * m_spinorRest[i] ) / sqmt2 );
	+ R.set( 1, i, ( spminus * m_spinorRest[i] ) / sqmt2 );
	}

	return R;
	@@ -145,8 +145,8 @@
	R.setDim( 2 );

	for ( int i = 0; i < 2; i++ ) {
	- R.set( 0, i, ( spplus * _spinorRest[i] ) / sqmt2 );
	- R.set( 1, i, ( spminus * _spinorRest[i] ) / sqmt2 );
	+ R.set( 0, i, ( spplus * m_spinorRest[i] ) / sqmt2 );
	+ R.set( 1, i, ( spminus * m_spinorRest[i] ) / sqmt2 );
	}

	return R;
	diff --git a/src/EvtGenBase/EvtDiracSpinor.cpp b/src/EvtGenBase/EvtDiracSpinor.cpp
	--- a/src/EvtGenBase/EvtDiracSpinor.cpp
	+++ b/src/EvtGenBase/EvtDiracSpinor.cpp
	@@ -40,27 +40,27 @@
	void EvtDiracSpinor::set( const EvtComplex& sp0, const EvtComplex& sp1,
	const EvtComplex& sp2, const EvtComplex& sp3 )
	{
	- spinor[0] = sp0;
	- spinor[1] = sp1;
	- spinor[2] = sp2;
	- spinor[3] = sp3;
	+ m_spinor[0] = sp0;
	+ m_spinor[1] = sp1;
	+ m_spinor[2] = sp2;
	+ m_spinor[3] = sp3;
	}

	void EvtDiracSpinor::set_spinor( int i, const EvtComplex& sp )
	{
	- spinor[i] = sp;
	+ m_spinor[i] = sp;
	}

	ostream& operator<<( ostream& s, const EvtDiracSpinor& sp )
	{
	- s << "[" << sp.spinor[0] << "," << sp.spinor[1] << "," << sp.spinor[2]
	- << "," << sp.spinor[3] << "]";
	+ s << "[" << sp.m_spinor[0] << "," << sp.m_spinor[1] << "," << sp.m_spinor[2]
	+ << "," << sp.m_spinor[3] << "]";
	return s;
	}

	const EvtComplex& EvtDiracSpinor::get_spinor( int i ) const
	{
	- return spinor[i];
	+ return m_spinor[i];
	}

	EvtDiracSpinor rotateEuler( const EvtDiracSpinor& sp, double alpha, double beta,
	@@ -120,19 +120,19 @@
	f1 = sqrt( ( gamma + 1.0 ) / 2.0 );
	f2 = f1 * gamma / ( gamma + 1.0 );

	- spinorp[0] = f1 * spinor[0] + f2 * bz * spinor[2] +
	- f2 * EvtComplex( bx, -by ) * spinor[3];
	- spinorp[1] = f1 * spinor[1] + f2 * EvtComplex( bx, by ) * spinor[2] -
	- f2 * bz * spinor[3];
	- spinorp[2] = f2 * bz * spinor[0] + f2 * EvtComplex( bx, -by ) * spinor[1] +
	- f1 * spinor[2];
	- spinorp[3] = f2 * EvtComplex( bx, by ) * spinor[0] - f2 * bz * spinor[1] +
	- f1 * spinor[3];
	+ spinorp[0] = f1 * m_spinor[0] + f2 * bz * m_spinor[2] +
	+ f2 * EvtComplex( bx, -by ) * m_spinor[3];
	+ spinorp[1] = f1 * m_spinor[1] + f2 * EvtComplex( bx, by ) * m_spinor[2] -
	+ f2 * bz * m_spinor[3];
	+ spinorp[2] = f2 * bz * m_spinor[0] +
	+ f2 * EvtComplex( bx, -by ) * m_spinor[1] + f1 * m_spinor[2];
	+ spinorp[3] = f2 * EvtComplex( bx, by ) * m_spinor[0] -
	+ f2 * bz * m_spinor[1] + f1 * m_spinor[3];

	- spinor[0] = spinorp[0];
	- spinor[1] = spinorp[1];
	- spinor[2] = spinorp[2];
	- spinor[3] = spinorp[3];
	+ m_spinor[0] = spinorp[0];
	+ m_spinor[1] = spinorp[1];
	+ m_spinor[2] = spinorp[2];
	+ m_spinor[3] = spinorp[3];

	return;
	}
	@@ -153,15 +153,15 @@
	EvtComplex m21( sb2 * camg2, sb2 * samg2 );
	EvtComplex m22( cb2 * capg2, cb2 * sapg2 );

	- retVal[0] = m11 * spinor[0] + m12 * spinor[1];
	- retVal[1] = m21 * spinor[0] + m22 * spinor[1];
	- retVal[2] = m11 * spinor[2] + m12 * spinor[3];
	- retVal[3] = m21 * spinor[2] + m22 * spinor[3];
	+ retVal[0] = m11 * m_spinor[0] + m12 * m_spinor[1];
	+ retVal[1] = m21 * m_spinor[0] + m22 * m_spinor[1];
	+ retVal[2] = m11 * m_spinor[2] + m12 * m_spinor[3];
	+ retVal[3] = m21 * m_spinor[2] + m22 * m_spinor[3];

	- spinor[0] = retVal[0];
	- spinor[1] = retVal[1];
	- spinor[2] = retVal[2];
	- spinor[3] = retVal[3];
	+ m_spinor[0] = retVal[0];
	+ m_spinor[1] = retVal[1];
	+ m_spinor[2] = retVal[2];
	+ m_spinor[3] = retVal[3];

	return;
	}
	@@ -171,7 +171,7 @@
	EvtDiracSpinor sp;

	for ( int i = 0; i < 4; i++ )
	- sp.set_spinor( i, ::conj( spinor[i] ) );
	+ sp.set_spinor( i, ::conj( m_spinor[i] ) );

	return sp;
	}
	@@ -191,11 +191,11 @@
	//temp.set(3,d(matdp));
	//return temp;

	- EvtComplex u02 = ::conj( d.spinor[0] - d.spinor[2] );
	- EvtComplex u13 = ::conj( d.spinor[1] - d.spinor[3] );
	+ EvtComplex u02 = ::conj( d.m_spinor[0] - d.m_spinor[2] );
	+ EvtComplex u13 = ::conj( d.m_spinor[1] - d.m_spinor[3] );

	- EvtComplex v02 = dp.spinor[0] - dp.spinor[2];
	- EvtComplex v13 = dp.spinor[1] - dp.spinor[3];
	+ EvtComplex v02 = dp.m_spinor[0] - dp.m_spinor[2];
	+ EvtComplex v13 = dp.m_spinor[1] - dp.m_spinor[3];

	EvtComplex a = u02 * v02;
	EvtComplex b = u13 * v13;
	@@ -318,10 +318,10 @@
	EvtDiracSpinor operator*( const EvtComplex& c, const EvtDiracSpinor& d )
	{
	EvtDiracSpinor result;
	- result.spinor[0] = c * d.spinor[0];
	- result.spinor[1] = c * d.spinor[1];
	- result.spinor[2] = c * d.spinor[2];
	- result.spinor[3] = c * d.spinor[3];
	+ result.m_spinor[0] = c * d.m_spinor[0];
	+ result.m_spinor[1] = c * d.m_spinor[1];
	+ result.m_spinor[2] = c * d.m_spinor[2];
	+ result.m_spinor[3] = c * d.m_spinor[3];
	return result;
	}

	@@ -333,7 +333,7 @@

	for ( int i = 0; i < 4; ++i )
	for ( int j = 0; j < 4; ++j )
	- result.spinor[i] += d.spinor[j] * g0._gamma[i][j];
	+ result.m_spinor[i] += d.m_spinor[j] * g0.m_gamma[i][j];

	return result;
	}
	diff --git a/src/EvtGenBase/EvtEvalHelAmp.cpp b/src/EvtGenBase/EvtEvalHelAmp.cpp
	--- a/src/EvtGenBase/EvtEvalHelAmp.cpp
	+++ b/src/EvtGenBase/EvtEvalHelAmp.cpp
	@@ -36,46 +36,46 @@
	EvtEvalHelAmp::~EvtEvalHelAmp()
	{
	//deallocate memory
	- delete[] _lambdaA2;
	- delete[] _lambdaB2;
	- delete[] _lambdaC2;
	+ delete[] m_lambdaA2;
	+ delete[] m_lambdaB2;
	+ delete[] m_lambdaC2;

	int ia, ib, ic;
	- for ( ib = 0; ib < _nB; ib++ ) {
	- delete[] _HBC[ib];
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ delete[] m_HBC[ib];
	}

	- delete[] _HBC;
	+ delete[] m_HBC;

	- for ( ia = 0; ia < _nA; ia++ ) {
	- delete[] _RA[ia];
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	+ delete[] m_RA[ia];
	}
	- delete[] _RA;
	+ delete[] m_RA;

	- for ( ib = 0; ib < _nB; ib++ ) {
	- delete[] _RB[ib];
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ delete[] m_RB[ib];
	}
	- delete[] _RB;
	+ delete[] m_RB;

	- for ( ic = 0; ic < _nC; ic++ ) {
	- delete[] _RC[ic];
	+ for ( ic = 0; ic < m_nC; ic++ ) {
	+ delete[] m_RC[ic];
	}
	- delete[] _RC;
	+ delete[] m_RC;

	- for ( ia = 0; ia < _nA; ia++ ) {
	- for ( ib = 0; ib < _nB; ib++ ) {
	- delete[] _amp[ia][ib];
	- delete[] _amp1[ia][ib];
	- delete[] _amp3[ia][ib];
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ delete[] m_amp[ia][ib];
	+ delete[] m_amp1[ia][ib];
	+ delete[] m_amp3[ia][ib];
	}
	- delete[] _amp[ia];
	- delete[] _amp1[ia];
	- delete[] _amp3[ia];
	+ delete[] m_amp[ia];
	+ delete[] m_amp1[ia];
	+ delete[] m_amp3[ia];
	}

	- delete[] _amp;
	- delete[] _amp1;
	- delete[] _amp3;
	+ delete[] m_amp;
	+ delete[] m_amp1;
	+ delete[] m_amp3;
	}

	EvtEvalHelAmp::EvtEvalHelAmp( EvtId idA, EvtId idB, EvtId idC,
	@@ -86,69 +86,69 @@
	EvtSpinType::spintype typeC = EvtPDL::getSpinType( idC );

	//find out how many states each particle have
	- _nA = EvtSpinType::getSpinStates( typeA );
	- _nB = EvtSpinType::getSpinStates( typeB );
	- _nC = EvtSpinType::getSpinStates( typeC );
	+ m_nA = EvtSpinType::getSpinStates( typeA );
	+ m_nB = EvtSpinType::getSpinStates( typeB );
	+ m_nC = EvtSpinType::getSpinStates( typeC );

	//find out what 2 times the spin is
	- _JA2 = EvtSpinType::getSpin2( typeA );
	- _JB2 = EvtSpinType::getSpin2( typeB );
	- _JC2 = EvtSpinType::getSpin2( typeC );
	+ m_JA2 = EvtSpinType::getSpin2( typeA );
	+ m_JB2 = EvtSpinType::getSpin2( typeB );
	+ m_JC2 = EvtSpinType::getSpin2( typeC );

	//allocate memory
	- _lambdaA2 = new int[_nA];
	- _lambdaB2 = new int[_nB];
	- _lambdaC2 = new int[_nC];
	+ m_lambdaA2 = new int[m_nA];
	+ m_lambdaB2 = new int[m_nB];
	+ m_lambdaC2 = new int[m_nC];

	- _HBC = new EvtComplexPtr[_nB];
	+ m_HBC = new EvtComplexPtr[m_nB];
	int ia, ib, ic;
	- for ( ib = 0; ib < _nB; ib++ ) {
	- _HBC[ib] = new EvtComplex[_nC];
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ m_HBC[ib] = new EvtComplex[m_nC];
	}

	- _RA = new EvtComplexPtr[_nA];
	- for ( ia = 0; ia < _nA; ia++ ) {
	- _RA[ia] = new EvtComplex[_nA];
	+ m_RA = new EvtComplexPtr[m_nA];
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	+ m_RA[ia] = new EvtComplex[m_nA];
	}
	- _RB = new EvtComplexPtr[_nB];
	- for ( ib = 0; ib < _nB; ib++ ) {
	- _RB[ib] = new EvtComplex[_nB];
	+ m_RB = new EvtComplexPtr[m_nB];
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ m_RB[ib] = new EvtComplex[m_nB];
	}
	- _RC = new EvtComplexPtr[_nC];
	- for ( ic = 0; ic < _nC; ic++ ) {
	- _RC[ic] = new EvtComplex[_nC];
	+ m_RC = new EvtComplexPtr[m_nC];
	+ for ( ic = 0; ic < m_nC; ic++ ) {
	+ m_RC[ic] = new EvtComplex[m_nC];
	}

	- _amp = new EvtComplexPtrPtr[_nA];
	- _amp1 = new EvtComplexPtrPtr[_nA];
	- _amp3 = new EvtComplexPtrPtr[_nA];
	- for ( ia = 0; ia < _nA; ia++ ) {
	- _amp[ia] = new EvtComplexPtr[_nB];
	- _amp1[ia] = new EvtComplexPtr[_nB];
	- _amp3[ia] = new EvtComplexPtr[_nB];
	- for ( ib = 0; ib < _nB; ib++ ) {
	- _amp[ia][ib] = new EvtComplex[_nC];
	- _amp1[ia][ib] = new EvtComplex[_nC];
	- _amp3[ia][ib] = new EvtComplex[_nC];
	+ m_amp = new EvtComplexPtrPtr[m_nA];
	+ m_amp1 = new EvtComplexPtrPtr[m_nA];
	+ m_amp3 = new EvtComplexPtrPtr[m_nA];
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	+ m_amp[ia] = new EvtComplexPtr[m_nB];
	+ m_amp1[ia] = new EvtComplexPtr[m_nB];
	+ m_amp3[ia] = new EvtComplexPtr[m_nB];
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ m_amp[ia][ib] = new EvtComplex[m_nC];
	+ m_amp1[ia][ib] = new EvtComplex[m_nC];
	+ m_amp3[ia][ib] = new EvtComplex[m_nC];
	}
	}

	//find the allowed helicities (actually 2*times the helicity!)

	- fillHelicity( _lambdaA2, _nA, _JA2, idA );
	- fillHelicity( _lambdaB2, _nB, _JB2, idB );
	- fillHelicity( _lambdaC2, _nC, _JC2, idC );
	+ fillHelicity( m_lambdaA2, m_nA, m_JA2, idA );
	+ fillHelicity( m_lambdaB2, m_nB, m_JB2, idB );
	+ fillHelicity( m_lambdaC2, m_nC, m_JC2, idC );

	- for ( ib = 0; ib < _nB; ib++ ) {
	- for ( ic = 0; ic < _nC; ic++ ) {
	- _HBC[ib][ic] = HBC[ib][ic];
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ for ( ic = 0; ic < m_nC; ic++ ) {
	+ m_HBC[ib][ic] = HBC[ib][ic];
	}
	}
	}

	double EvtEvalHelAmp::probMax()
	{
	- double c = 1.0 / sqrt( 4 * EvtConst::pi / ( _JA2 + 1 ) );
	+ double c = 1.0 / sqrt( 4 * EvtConst::pi / ( m_JA2 + 1 ) );

	int ia, ib, ic;

	@@ -159,24 +159,24 @@

	for ( itheta = -10; itheta <= 10; itheta++ ) {
	theta = acos( 0.099999 * itheta );
	- for ( ia = 0; ia < _nA; ia++ ) {
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	double prob = 0.0;
	- for ( ib = 0; ib < _nB; ib++ ) {
	- for ( ic = 0; ic < _nC; ic++ ) {
	- _amp[ia][ib][ic] = 0.0;
	- if ( abs( _lambdaB2[ib] - _lambdaC2[ic] ) <= _JA2 ) {
	- _amp[ia][ib][ic] = c * _HBC[ib][ic] *
	- EvtdFunction::d( _JA2, _lambdaA2[ia],
	- _lambdaB2[ib] -
	- _lambdaC2[ic],
	- theta );
	- prob += real( _amp[ia][ib][ic] *
	- conj( _amp[ia][ib][ic] ) );
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ for ( ic = 0; ic < m_nC; ic++ ) {
	+ m_amp[ia][ib][ic] = 0.0;
	+ if ( abs( m_lambdaB2[ib] - m_lambdaC2[ic] ) <= m_JA2 ) {
	+ m_amp[ia][ib][ic] =
	+ c * m_HBC[ib][ic] *
	+ EvtdFunction::d( m_JA2, m_lambdaA2[ia],
	+ m_lambdaB2[ib] - m_lambdaC2[ic],
	+ theta );
	+ prob += real( m_amp[ia][ib][ic] *
	+ conj( m_amp[ia][ib][ic] ) );
	}
	}
	}

	- prob = sqrt( 1.0 _nA );
	+ prob = sqrt( 1.0 m_nA );

	if ( prob > maxprob )
	maxprob = prob;
	@@ -195,29 +195,30 @@
	double theta = acos( pB.get( 3 ) / pB.d3mag() );
	double phi = atan2( pB.get( 2 ), pB.get( 1 ) );

	- double c = sqrt( ( _JA2 + 1 ) / ( 4 * EvtConst::pi ) );
	+ double c = sqrt( ( m_JA2 + 1 ) / ( 4 * EvtConst::pi ) );

	int ia, ib, ic;

	double prob1 = 0.0;

	- for ( ia = 0; ia < _nA; ia++ ) {
	- for ( ib = 0; ib < _nB; ib++ ) {
	- for ( ic = 0; ic < _nC; ic++ ) {
	- _amp[ia][ib][ic] = 0.0;
	- if ( abs( _lambdaB2[ib] - _lambdaC2[ic] ) <= _JA2 ) {
	- double dfun = EvtdFunction::d( _JA2, _lambdaA2[ia],
	- _lambdaB2[ib] - _lambdaC2[ic],
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ for ( ic = 0; ic < m_nC; ic++ ) {
	+ m_amp[ia][ib][ic] = 0.0;
	+ if ( abs( m_lambdaB2[ib] - m_lambdaC2[ic] ) <= m_JA2 ) {
	+ double dfun = EvtdFunction::d( m_JA2, m_lambdaA2[ia],
	+ m_lambdaB2[ib] - m_lambdaC2[ic],
	theta );

	- _amp[ia][ib][ic] =
	- c * _HBC[ib][ic] *
	- exp( EvtComplex( 0.0, phi * 0.5 *
	- ( _lambdaA2[ia] - _lambdaB2[ib] +
	- _lambdaC2[ic] ) ) ) *
	+ m_amp[ia][ib][ic] =
	+ c * m_HBC[ib][ic] *
	+ exp( EvtComplex( 0.0,
	+ phi * 0.5 *
	+ ( m_lambdaA2[ia] - m_lambdaB2[ib] +
	+ m_lambdaC2[ic] ) ) ) *
	dfun;
	}
	- prob1 += real( _amp[ia][ib][ic] * conj( _amp[ia][ib][ic] ) );
	+ prob1 += real( m_amp[ia][ib][ic] * conj( m_amp[ia][ib][ic] ) );
	}
	}
	}
	@@ -228,36 +229,36 @@

	double prob2 = 0.0;

	- for ( ia = 0; ia < _nA; ia++ ) {
	- for ( ib = 0; ib < _nB; ib++ ) {
	- for ( ic = 0; ic < _nC; ic++ ) {
	- prob2 += real( _amp[ia][ib][ic] * conj( _amp[ia][ib][ic] ) );
	- if ( _nA == 1 ) {
	- if ( _nB == 1 ) {
	- if ( _nC == 1 ) {
	- amp.vertex( _amp[ia][ib][ic] );
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ for ( ic = 0; ic < m_nC; ic++ ) {
	+ prob2 += real( m_amp[ia][ib][ic] * conj( m_amp[ia][ib][ic] ) );
	+ if ( m_nA == 1 ) {
	+ if ( m_nB == 1 ) {
	+ if ( m_nC == 1 ) {
	+ amp.vertex( m_amp[ia][ib][ic] );
	} else {
	- amp.vertex( ic, _amp[ia][ib][ic] );
	+ amp.vertex( ic, m_amp[ia][ib][ic] );
	}
	} else {
	- if ( _nC == 1 ) {
	- amp.vertex( ib, _amp[ia][ib][ic] );
	+ if ( m_nC == 1 ) {
	+ amp.vertex( ib, m_amp[ia][ib][ic] );
	} else {
	- amp.vertex( ib, ic, _amp[ia][ib][ic] );
	+ amp.vertex( ib, ic, m_amp[ia][ib][ic] );
	}
	}
	} else {
	- if ( _nB == 1 ) {
	- if ( _nC == 1 ) {
	- amp.vertex( ia, _amp[ia][ib][ic] );
	+ if ( m_nB == 1 ) {
	+ if ( m_nC == 1 ) {
	+ amp.vertex( ia, m_amp[ia][ib][ic] );
	} else {
	- amp.vertex( ia, ic, _amp[ia][ib][ic] );
	+ amp.vertex( ia, ic, m_amp[ia][ib][ic] );
	}
	} else {
	- if ( _nC == 1 ) {
	- amp.vertex( ia, ib, _amp[ia][ib][ic] );
	+ if ( m_nC == 1 ) {
	+ amp.vertex( ia, ib, m_amp[ia][ib][ic] );
	} else {
	- amp.vertex( ia, ib, ic, _amp[ia][ib][ic] );
	+ amp.vertex( ia, ib, ic, m_amp[ia][ib][ic] );
	}
	}
	}
	@@ -309,7 +310,7 @@
	void EvtEvalHelAmp::setUpRotationMatrices( EvtParticle* p, double theta,
	double phi )
	{
	- switch ( _JA2 ) {
	+ switch ( m_JA2 ) {
	case 0:
	case 1:
	case 2:
	@@ -327,11 +328,11 @@

	n = R.getDim();

	- assert( n == _nA );
	+ assert( n == m_nA );

	for ( i = 0; i < n; i++ ) {
	for ( j = 0; j < n; j++ ) {
	- _RA[i][j] = R.get( i, j );
	+ m_RA[i][j] = R.get( i, j );
	}
	}

	@@ -341,11 +342,11 @@

	default:
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "Spin2(_JA2)=" << _JA2 << " not supported!" << endl;
	+ << "Spin2(m_JA2)=" << m_JA2 << " not supported!" << endl;
	::abort();
	}

	- switch ( _JB2 ) {
	+ switch ( m_JB2 ) {
	case 0:
	case 1:
	case 2:
	@@ -364,11 +365,11 @@

	n = R.getDim();

	- assert( n == _nB );
	+ assert( n == m_nB );

	for ( i = 0; i < n; i++ ) {
	for ( j = 0; j < n; j++ ) {
	- _RB[i][j] = conj( R.get( i, j ) );
	+ m_RB[i][j] = conj( R.get( i, j ) );
	}
	}

	@@ -378,11 +379,11 @@

	default:
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "Spin2(_JB2)=" << _JB2 << " not supported!" << endl;
	+ << "Spin2(m_JB2)=" << m_JB2 << " not supported!" << endl;
	::abort();
	}

	- switch ( _JC2 ) {
	+ switch ( m_JC2 ) {
	case 0:
	case 1:
	case 2:
	@@ -401,11 +402,11 @@

	n = R.getDim();

	- assert( n == _nC );
	+ assert( n == m_nC );

	for ( i = 0; i < n; i++ ) {
	for ( j = 0; j < n; j++ ) {
	- _RC[i][j] = conj( R.get( i, j ) );
	+ m_RC[i][j] = conj( R.get( i, j ) );
	}
	}

	@@ -415,7 +416,7 @@

	default:
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "Spin2(_JC2)=" << _JC2 << " not supported!" << endl;
	+ << "Spin2(m_JC2)=" << m_JC2 << " not supported!" << endl;
	::abort();
	}
	}
	@@ -426,38 +427,38 @@

	EvtComplex temp;

	- for ( ia = 0; ia < _nA; ia++ ) {
	- for ( ib = 0; ib < _nB; ib++ ) {
	- for ( ic = 0; ic < _nC; ic++ ) {
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ for ( ic = 0; ic < m_nC; ic++ ) {
	temp = 0;
	- for ( i = 0; i < _nC; i++ ) {
	- temp += _RC[i][ic] * _amp[ia][ib][i];
	+ for ( i = 0; i < m_nC; i++ ) {
	+ temp += m_RC[i][ic] * m_amp[ia][ib][i];
	}
	- _amp1[ia][ib][ic] = temp;
	+ m_amp1[ia][ib][ic] = temp;
	}
	}
	}

	- for ( ia = 0; ia < _nA; ia++ ) {
	- for ( ic = 0; ic < _nC; ic++ ) {
	- for ( ib = 0; ib < _nB; ib++ ) {
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	+ for ( ic = 0; ic < m_nC; ic++ ) {
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	temp = 0;
	- for ( i = 0; i < _nB; i++ ) {
	- temp += _RB[i][ib] * _amp1[ia][i][ic];
	+ for ( i = 0; i < m_nB; i++ ) {
	+ temp += m_RB[i][ib] * m_amp1[ia][i][ic];
	}
	- _amp3[ia][ib][ic] = temp;
	+ m_amp3[ia][ib][ic] = temp;
	}
	}
	}

	- for ( ib = 0; ib < _nB; ib++ ) {
	- for ( ic = 0; ic < _nC; ic++ ) {
	- for ( ia = 0; ia < _nA; ia++ ) {
	+ for ( ib = 0; ib < m_nB; ib++ ) {
	+ for ( ic = 0; ic < m_nC; ic++ ) {
	+ for ( ia = 0; ia < m_nA; ia++ ) {
	temp = 0;
	- for ( i = 0; i < _nA; i++ ) {
	- temp += _RA[i][ia] * _amp3[i][ib][ic];
	+ for ( i = 0; i < m_nA; i++ ) {
	+ temp += m_RA[i][ia] * m_amp3[i][ib][ic];
	}
	- _amp[ia][ib][ic] = temp;
	+ m_amp[ia][ib][ic] = temp;
	}
	}
	}
	diff --git a/src/EvtGenBase/EvtExtGeneratorCommandsTable.cpp b/src/EvtGenBase/EvtExtGeneratorCommandsTable.cpp
	--- a/src/EvtGenBase/EvtExtGeneratorCommandsTable.cpp
	+++ b/src/EvtGenBase/EvtExtGeneratorCommandsTable.cpp
	@@ -22,12 +22,12 @@

	EvtExtGeneratorCommandsTable::EvtExtGeneratorCommandsTable()
	{
	- _commandMap.clear();
	+ m_commandMap.clear();
	}

	EvtExtGeneratorCommandsTable::~EvtExtGeneratorCommandsTable()
	{
	- _commandMap.clear();
	+ m_commandMap.clear();
	}

	EvtExtGeneratorCommandsTable* EvtExtGeneratorCommandsTable::getInstance()
	diff --git a/src/EvtGenBase/EvtFlatLineShape.cpp b/src/EvtGenBase/EvtFlatLineShape.cpp
	--- a/src/EvtGenBase/EvtFlatLineShape.cpp
	+++ b/src/EvtGenBase/EvtFlatLineShape.cpp
	@@ -32,39 +32,39 @@
	EvtFlatLineShape::EvtFlatLineShape( double mass, double width, double maxRange,
	EvtSpinType::spintype sp )
	{
	- _mass = mass;
	- _width = width;
	- _spin = sp;
	- _maxRange = maxRange;
	+ m_mass = mass;
	+ m_width = width;
	+ m_spin = sp;
	+ m_maxRange = maxRange;

	double maxdelta = width;

	- _massMax = mass + maxdelta;
	- _massMin = mass - maxdelta;
	+ m_massMax = mass + maxdelta;
	+ m_massMin = mass - maxdelta;

	- if ( _massMin < 0. )
	- _massMin = 0.;
	+ if ( m_massMin < 0. )
	+ m_massMin = 0.;
	}

	EvtFlatLineShape::EvtFlatLineShape( const EvtFlatLineShape& x ) :
	EvtAbsLineShape( x )
	{
	- _mass = x._mass;
	- _width = x._width;
	- _spin = x._spin;
	- _massMax = x._massMax;
	- _massMin = x._massMin;
	- _maxRange = x._maxRange;
	+ m_mass = x.m_mass;
	+ m_width = x.m_width;
	+ m_spin = x.m_spin;
	+ m_massMax = x.m_massMax;
	+ m_massMin = x.m_massMin;
	+ m_maxRange = x.m_maxRange;
	}

	EvtFlatLineShape& EvtFlatLineShape::operator=( const EvtFlatLineShape& x )
	{
	- _mass = x._mass;
	- _massMax = x._massMax;
	- _massMin = x._massMin;
	- _width = x._width;
	- _maxRange = x._maxRange;
	- _spin = x._spin;
	+ m_mass = x.m_mass;
	+ m_massMax = x.m_massMax;
	+ m_massMin = x.m_massMin;
	+ m_width = x.m_width;
	+ m_maxRange = x.m_maxRange;
	+ m_spin = x.m_spin;
	return *this;
	}

	@@ -96,5 +96,5 @@
	double EvtFlatLineShape::getRandMass( EvtId, int, EvtId, EvtId*, double,
	double* )
	{
	- return EvtRandom::Flat( _massMin, _massMax );
	+ return EvtRandom::Flat( m_massMin, m_massMax );
	}
	diff --git a/src/EvtGenBase/EvtFlatte.cpp b/src/EvtGenBase/EvtFlatte.cpp
	--- a/src/EvtGenBase/EvtFlatte.cpp
	+++ b/src/EvtGenBase/EvtFlatte.cpp
	@@ -35,19 +35,13 @@
	{
	if ( &n == this )
	return *this;
	- _p4_p = n._p4_p;
	- _p4_d1 = n._p4_d1;
	- _p4_d2 = n._p4_d2;
	- _ampl = n._ampl;
	- _theta = n._theta;
	- _mass = n._mass;
	- _params = n._params;
	- // _m1a = n._m1a;
	- // _m1b = n._m1b;
	- // _g1 = n._g1;
	- // _m2a = n._m2a;
	- // _m2b = n._m2b;
	- // _g2 = n._g2;
	+ m_p4_p = n.m_p4_p;
	+ m_p4_d1 = n.m_p4_d1;
	+ m_p4_d2 = n.m_p4_d2;
	+ m_ampl = n.m_ampl;
	+ m_theta = n.m_theta;
	+ m_mass = n.m_mass;
	+ m_params = n.m_params;
	return *this;
	}

	@@ -55,19 +49,14 @@

	EvtFlatte::EvtFlatte( const EvtVector4R& p4_p, const EvtVector4R& p4_d1,
	const EvtVector4R& p4_d2, double ampl, double theta,
	- double mass, vector<EvtFlatteParam>& params
	- // double m1a, double m1b, double g1,
	- // double m2a, double m2b, double g2
	- ) :
	- _p4_p( p4_p ),
	- _p4_d1( p4_d1 ),
	- _p4_d2( p4_d2 ),
	- _ampl( ampl ),
	- _theta( theta ),
	- _mass( mass ),
	- _params( params )
	-// _m1a(m1a), _m1b(m1b), _g1(g1),
	-// _m2a(m2a), _m2b(m2b), _g2(g2)
	+ double mass, vector<EvtFlatteParam>& params ) :
	+ m_p4_p( p4_p ),
	+ m_p4_d1( p4_d1 ),
	+ m_p4_d2( p4_d2 ),
	+ m_ampl( ampl ),
	+ m_theta( theta ),
	+ m_mass( mass ),
	+ m_params( params )
	{
	}

	@@ -77,30 +66,25 @@
	{
	double pi180inv = 1.0 / EvtConst::radToDegrees;

	- // EvtComplex ampl(cos(_thetapi180inv), sin(_thetapi180inv));
	- // ampl *= _ampl;
	-
	// SCALARS ONLY
	- double mR = ( _p4_d1 + _p4_d2 ).mass();
	+ double mR = ( m_p4_d1 + m_p4_d2 ).mass();

	EvtComplex w;

	- for ( vector<EvtFlatteParam>::const_iterator param = _params.begin();
	- param != _params.end(); ++param ) {
	+ for ( vector<EvtFlatteParam>::const_iterator param = m_params.begin();
	+ param != m_params.end(); ++param ) {
	double m1 = ( *param ).m1();
	double m2 = ( *param ).m2();
	double g = ( *param ).g();
	w += ( g * g *
	sqrtCplx( ( 1 - ( ( m1 - m2 ) * ( m1 - m2 ) ) / ( mR * mR ) ) *
	( 1 - ( ( m1 + m2 ) * ( m1 + m2 ) ) / ( mR * mR ) ) ) );
	- // cout << m1 << " " << mR << " " << w << endl;
	}

	- EvtComplex denom = _mass * _mass - mR * mR - EvtComplex( 0, 1 ) * w;
	- EvtComplex ampl = _ampl *
	- EvtComplex( cos( _theta * pi180inv ),
	- sin( _theta * pi180inv ) ) /
	+ EvtComplex denom = m_mass * m_mass - mR * mR - EvtComplex( 0, 1 ) * w;
	+ EvtComplex ampl = m_ampl *
	+ EvtComplex( cos( m_theta * pi180inv ),
	+ sin( m_theta * pi180inv ) ) /
	denom;
	- // cout << abs(1/denom) << endl;
	return ampl;
	}
	diff --git a/src/EvtGenBase/EvtGammaMatrix.cpp b/src/EvtGenBase/EvtGammaMatrix.cpp
	--- a/src/EvtGenBase/EvtGammaMatrix.cpp
	+++ b/src/EvtGenBase/EvtGammaMatrix.cpp
	@@ -42,7 +42,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _gamma[i][j] = zero;
	+ m_gamma[i][j] = zero;
	}
	}
	}
	@@ -60,7 +60,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- temp._gamma[i][j] = g._gamma[i][j] * c;
	+ temp.m_gamma[i][j] = g.m_gamma[i][j] * c;
	}
	}

	@@ -69,14 +69,14 @@

	ostream& operator<<( ostream& s, const EvtGammaMatrix& g )
	{
	- s << "[" << g._gamma[0][0] << "," << g._gamma[0][1] << "," << g._gamma[0][2]
	- << "," << g._gamma[0][3] << "]" << endl;
	- s << "[" << g._gamma[1][0] << "," << g._gamma[1][1] << "," << g._gamma[1][2]
	- << "," << g._gamma[1][3] << "]" << endl;
	- s << "[" << g._gamma[2][0] << "," << g._gamma[2][1] << "," << g._gamma[2][2]
	- << "," << g._gamma[2][3] << "]" << endl;
	- s << "[" << g._gamma[3][0] << "," << g._gamma[3][1] << "," << g._gamma[3][2]
	- << "," << g._gamma[3][3] << "]" << endl;
	+ s << "[" << g.m_gamma[0][0] << "," << g.m_gamma[0][1] << ","
	+ << g.m_gamma[0][2] << "," << g.m_gamma[0][3] << "]" << endl;
	+ s << "[" << g.m_gamma[1][0] << "," << g.m_gamma[1][1] << ","
	+ << g.m_gamma[1][2] << "," << g.m_gamma[1][3] << "]" << endl;
	+ s << "[" << g.m_gamma[2][0] << "," << g.m_gamma[2][1] << ","
	+ << g.m_gamma[2][2] << "," << g.m_gamma[2][3] << "]" << endl;
	+ s << "[" << g.m_gamma[3][0] << "," << g.m_gamma[3][1] << ","
	+ << g.m_gamma[3][2] << "," << g.m_gamma[3][3] << "]" << endl;

	return s;
	}
	@@ -87,7 +87,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _gamma[i][j] = gm._gamma[i][j];
	+ m_gamma[i][j] = gm.m_gamma[i][j];
	}
	}
	}
	@@ -98,7 +98,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _gamma[i][j] = gm._gamma[i][j];
	+ m_gamma[i][j] = gm.m_gamma[i][j];
	}
	}
	return *this;
	@@ -112,7 +112,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _gamma[i][j] = zero;
	+ m_gamma[i][j] = zero;
	}
	}
	}
	@@ -124,22 +124,22 @@

	if ( first ) {
	first = 0;
	- g._gamma[0][0] = EvtComplex( 1.0, 0.0 );
	- g._gamma[0][1] = EvtComplex( 0.0, 0.0 );
	- g._gamma[0][2] = EvtComplex( -1.0, 0.0 );
	- g._gamma[0][3] = EvtComplex( 0.0, 0.0 );
	- g._gamma[1][0] = EvtComplex( 0.0, 0.0 );
	- g._gamma[1][1] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][2] = EvtComplex( 0.0, 0.0 );
	- g._gamma[1][3] = EvtComplex( -1.0, 0.0 );
	- g._gamma[2][0] = EvtComplex( -1.0, 0.0 );
	- g._gamma[2][1] = EvtComplex( 0.0, 0.0 );
	- g._gamma[2][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[2][3] = EvtComplex( 0.0, 0.0 );
	- g._gamma[3][0] = EvtComplex( 0.0, 0.0 );
	- g._gamma[3][1] = EvtComplex( -1.0, 0.0 );
	- g._gamma[3][2] = EvtComplex( 0.0, 0.0 );
	- g._gamma[3][3] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[0][0] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[0][1] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[0][2] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[0][3] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[1][0] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[1][1] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][2] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[1][3] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[2][0] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[2][1] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[2][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[2][3] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[3][0] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[3][1] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[3][2] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[3][3] = EvtComplex( 1.0, 0.0 );
	}

	return g;
	@@ -152,22 +152,22 @@

	if ( first ) {
	first = 0;
	- g._gamma[0][0] = EvtComplex( 0.0, 0.0 );
	- g._gamma[0][1] = EvtComplex( -1.0, 0.0 );
	- g._gamma[0][2] = EvtComplex( 0.0, 0.0 );
	- g._gamma[0][3] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][0] = EvtComplex( -1.0, 0.0 );
	- g._gamma[1][1] = EvtComplex( 0.0, 0.0 );
	- g._gamma[1][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][3] = EvtComplex( 0.0, 0.0 );
	- g._gamma[2][0] = EvtComplex( 0.0, 0.0 );
	- g._gamma[2][1] = EvtComplex( 1.0, 0.0 );
	- g._gamma[2][2] = EvtComplex( 0.0, 0.0 );
	- g._gamma[2][3] = EvtComplex( -1.0, 0.0 );
	- g._gamma[3][0] = EvtComplex( 1.0, 0.0 );
	- g._gamma[3][1] = EvtComplex( 0.0, 0.0 );
	- g._gamma[3][2] = EvtComplex( -1.0, 0.0 );
	- g._gamma[3][3] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[0][0] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[0][1] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[0][2] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[0][3] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][0] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[1][1] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[1][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][3] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[2][0] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[2][1] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[2][2] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[2][3] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[3][0] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[3][1] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[3][2] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[3][3] = EvtComplex( 0.0, 0.0 );
	}

	return g;
	@@ -180,22 +180,22 @@

	if ( first ) {
	first = 0;
	- g._gamma[0][0] = EvtComplex( 0.0, 0.0 );
	- g._gamma[0][1] = EvtComplex( 0.0, 1.0 );
	- g._gamma[0][2] = EvtComplex( 0.0, 0.0 );
	- g._gamma[0][3] = EvtComplex( 0.0, -1.0 );
	- g._gamma[1][0] = EvtComplex( 0.0, -1.0 );
	- g._gamma[1][1] = EvtComplex( 0.0, 0.0 );
	- g._gamma[1][2] = EvtComplex( 0.0, 1.0 );
	- g._gamma[1][3] = EvtComplex( 0.0, 0.0 );
	- g._gamma[2][0] = EvtComplex( 0.0, 0.0 );
	- g._gamma[2][1] = EvtComplex( 0.0, -1.0 );
	- g._gamma[2][2] = EvtComplex( 0.0, 0.0 );
	- g._gamma[2][3] = EvtComplex( 0.0, 1.0 );
	- g._gamma[3][0] = EvtComplex( 0.0, 1.0 );
	- g._gamma[3][1] = EvtComplex( 0.0, 0.0 );
	- g._gamma[3][2] = EvtComplex( 0.0, -1.0 );
	- g._gamma[3][3] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[0][0] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[0][1] = EvtComplex( 0.0, 1.0 );
	+ g.m_gamma[0][2] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[0][3] = EvtComplex( 0.0, -1.0 );
	+ g.m_gamma[1][0] = EvtComplex( 0.0, -1.0 );
	+ g.m_gamma[1][1] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[1][2] = EvtComplex( 0.0, 1.0 );
	+ g.m_gamma[1][3] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[2][0] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[2][1] = EvtComplex( 0.0, -1.0 );
	+ g.m_gamma[2][2] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[2][3] = EvtComplex( 0.0, 1.0 );
	+ g.m_gamma[3][0] = EvtComplex( 0.0, 1.0 );
	+ g.m_gamma[3][1] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[3][2] = EvtComplex( 0.0, -1.0 );
	+ g.m_gamma[3][3] = EvtComplex( 0.0, 0.0 );
	}

	return g;
	@@ -208,22 +208,22 @@

	if ( first ) {
	first = 0;
	- g._gamma[0][0] = EvtComplex( -1.0, 0.0 );
	- g._gamma[0][1] = EvtComplex( 0.0, 0.0 );
	- g._gamma[0][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[0][3] = EvtComplex( 0.0, 0.0 );
	- g._gamma[1][0] = EvtComplex( 0.0, 0.0 );
	- g._gamma[1][1] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][2] = EvtComplex( 0.0, 0.0 );
	- g._gamma[1][3] = EvtComplex( -1.0, 0.0 );
	- g._gamma[2][0] = EvtComplex( 1.0, 0.0 );
	- g._gamma[2][1] = EvtComplex( 0.0, 0.0 );
	- g._gamma[2][2] = EvtComplex( -1.0, 0.0 );
	- g._gamma[2][3] = EvtComplex( 0.0, 0.0 );
	- g._gamma[3][0] = EvtComplex( 0.0, 0.0 );
	- g._gamma[3][1] = EvtComplex( -1.0, 0.0 );
	- g._gamma[3][2] = EvtComplex( 0.0, 0.0 );
	- g._gamma[3][3] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[0][0] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[0][1] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[0][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[0][3] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[1][0] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[1][1] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][2] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[1][3] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[2][0] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[2][1] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[2][2] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[2][3] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[3][0] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[3][1] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[3][2] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[3][3] = EvtComplex( 1.0, 0.0 );
	}

	return g;
	@@ -241,14 +241,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][0] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][1] = EvtComplex( 1.0, 0.0 );
	- g._gamma[2][2] = EvtComplex( -1.0, 0.0 );
	- g._gamma[3][3] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[0][0] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][1] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[2][2] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[3][3] = EvtComplex( -1.0, 0.0 );
	}

	return g;
	@@ -265,14 +265,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][3] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[2][1] = EvtComplex( -1.0, 0.0 );
	- g._gamma[3][0] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[0][3] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[2][1] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[3][0] = EvtComplex( -1.0, 0.0 );
	}

	return g;
	@@ -289,14 +289,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][3] = EvtComplex( 0.0, -1.0 );
	- g._gamma[1][2] = EvtComplex( 0.0, 1.0 );
	- g._gamma[2][1] = EvtComplex( 0.0, 1.0 );
	- g._gamma[3][0] = EvtComplex( 0.0, -1.0 );
	+ g.m_gamma[0][3] = EvtComplex( 0.0, -1.0 );
	+ g.m_gamma[1][2] = EvtComplex( 0.0, 1.0 );
	+ g.m_gamma[2][1] = EvtComplex( 0.0, 1.0 );
	+ g.m_gamma[3][0] = EvtComplex( 0.0, -1.0 );
	}

	return g;
	@@ -313,14 +313,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][3] = EvtComplex( -1.0, 0.0 );
	- g._gamma[2][0] = EvtComplex( -1.0, 0.0 );
	- g._gamma[3][1] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[0][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][3] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[2][0] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[3][1] = EvtComplex( 1.0, 0.0 );
	}

	return g;
	@@ -337,14 +337,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][3] = EvtComplex( 1.0, 0.0 );
	- g._gamma[2][0] = EvtComplex( 1.0, 0.0 );
	- g._gamma[3][1] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[0][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][3] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[2][0] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[3][1] = EvtComplex( 1.0, 0.0 );
	}

	return g;
	@@ -381,14 +381,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][0] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][1] = EvtComplex( 1.0, 0.0 );
	- g._gamma[2][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[3][3] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[0][0] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][1] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[2][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[3][3] = EvtComplex( 1.0, 0.0 );
	}

	return g;
	@@ -405,14 +405,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][3] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[2][1] = EvtComplex( 1.0, 0.0 );
	- g._gamma[3][0] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[0][3] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[2][1] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[3][0] = EvtComplex( 1.0, 0.0 );
	}

	return g;
	@@ -429,14 +429,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][3] = EvtComplex( 0.0, -1.0 );
	- g._gamma[1][2] = EvtComplex( 0.0, 1.0 );
	- g._gamma[2][1] = EvtComplex( 0.0, -1.0 );
	- g._gamma[3][0] = EvtComplex( 0.0, 1.0 );
	+ g.m_gamma[0][3] = EvtComplex( 0.0, -1.0 );
	+ g.m_gamma[1][2] = EvtComplex( 0.0, 1.0 );
	+ g.m_gamma[2][1] = EvtComplex( 0.0, -1.0 );
	+ g.m_gamma[3][0] = EvtComplex( 0.0, 1.0 );
	}

	return g;
	@@ -453,14 +453,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][3] = EvtComplex( -1.0, 0.0 );
	- g._gamma[2][0] = EvtComplex( 1.0, 0.0 );
	- g._gamma[3][1] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[0][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][3] = EvtComplex( -1.0, 0.0 );
	+ g.m_gamma[2][0] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[3][1] = EvtComplex( -1.0, 0.0 );
	}

	return g;
	@@ -477,14 +477,14 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- g._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ g.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}

	- g._gamma[0][0] = EvtComplex( 1.0, 0.0 );
	- g._gamma[1][1] = EvtComplex( 1.0, 0.0 );
	- g._gamma[2][2] = EvtComplex( 1.0, 0.0 );
	- g._gamma[3][3] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[0][0] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[1][1] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[2][2] = EvtComplex( 1.0, 0.0 );
	+ g.m_gamma[3][3] = EvtComplex( 1.0, 0.0 );
	}

	return g;
	@@ -496,7 +496,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _gamma[i][j] += g._gamma[i][j];
	+ m_gamma[i][j] += g.m_gamma[i][j];
	}
	}
	return *this;
	@@ -508,7 +508,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _gamma[i][j] -= g._gamma[i][j];
	+ m_gamma[i][j] -= g.m_gamma[i][j];
	}
	}
	return *this;
	@@ -521,16 +521,16 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- temp._gamma[i][j] = EvtComplex( 0.0, 0.0 );
	+ temp.m_gamma[i][j] = EvtComplex( 0.0, 0.0 );
	for ( k = 0; k < 4; k++ ) {
	- temp._gamma[i][j] += _gamma[i][k] * g._gamma[k][j];
	+ temp.m_gamma[i][j] += m_gamma[i][k] * g.m_gamma[k][j];
	}
	}
	}

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _gamma[i][j] = temp._gamma[i][j];
	+ m_gamma[i][j] = temp.m_gamma[i][j];
	}
	}

	@@ -546,7 +546,7 @@
	temp.set_spinor( i, EvtComplex( 0.0, 0.0 ) );
	for ( j = 0; j < 4; j++ ) {
	temp.set_spinor( i, temp.get_spinor( i ) +
	- g._gamma[i][j] * d.get_spinor( j ) );
	+ g.m_gamma[i][j] * d.get_spinor( j ) );
	}
	}

	diff --git a/src/EvtGenBase/EvtHepMCEvent.cpp b/src/EvtGenBase/EvtHepMCEvent.cpp
	--- a/src/EvtGenBase/EvtHepMCEvent.cpp
	+++ b/src/EvtGenBase/EvtHepMCEvent.cpp
	@@ -25,7 +25,7 @@
	#include "EvtGenBase/EvtPatches.hh"

	EvtHepMCEvent::EvtHepMCEvent() :
	- _theEvent( nullptr ), _translation( 0.0, 0.0, 0.0, 0.0 )
	+ m_theEvent( nullptr ), m_translation( 0.0, 0.0, 0.0, 0.0 )
	{
	}

	@@ -36,10 +36,10 @@

	void EvtHepMCEvent::deleteEvent()
	{
	- if ( _theEvent != nullptr ) {
	- _theEvent->clear();
	- delete _theEvent;
	- _theEvent = nullptr;
	+ if ( m_theEvent != nullptr ) {
	+ m_theEvent->clear();
	+ delete m_theEvent;
	+ m_theEvent = nullptr;
	}
	}

	@@ -60,8 +60,8 @@
	return;
	}

	- _theEvent = new GenEvent( Units::GEV, Units::MM );
	- _translation = translation;
	+ m_theEvent = new GenEvent( Units::GEV, Units::MM );
	+ m_translation = translation;

	// Use the recursive function addVertex to add a vertex with incoming/outgoing
	// particles. Adds a new vertex for any EvtParticles with decay daughters.
	@@ -127,7 +127,7 @@
	// be the same GenParticle pointer, hence the reason for using it as a 2nd argument
	// in this function.

	- if ( _theEvent == nullptr \|\| inEvtParticle == nullptr \|\|
	+ if ( m_theEvent == nullptr \|\| inEvtParticle == nullptr \|\|
	inGenParticle == nullptr ) {
	return;
	}
	@@ -137,7 +137,7 @@
	GenVertexPtr theVertex = newGenVertexPtr( vtxCoord );

	// Add the vertex to the event
	- _theEvent->add_vertex( theVertex );
	+ m_theEvent->add_vertex( theVertex );

	// Set the incoming particle
	theVertex->add_particle_in( inGenParticle );
	@@ -181,7 +181,7 @@
	EvtParticle* daugParticle = theParticle->getDaug( 0 );

	if ( daugParticle != nullptr ) {
	- EvtVector4R vtxPosition = daugParticle->get4Pos() + _translation;
	+ EvtVector4R vtxPosition = daugParticle->get4Pos() + m_translation;

	// Create the HepMC 4 vector of the position (x,y,z,t)
	vertexCoord.setX( vtxPosition.get( 1 ) );
	diff --git a/src/EvtGenBase/EvtHighSpinParticle.cpp b/src/EvtGenBase/EvtHighSpinParticle.cpp
	--- a/src/EvtGenBase/EvtHighSpinParticle.cpp
	+++ b/src/EvtGenBase/EvtHighSpinParticle.cpp
	@@ -32,7 +32,7 @@

	void EvtHighSpinParticle::init( EvtId id, const EvtVector4R& p4 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( id );

	@@ -53,8 +53,6 @@
	double beta,
	double gamma ) const
	{
	- int i, j;
	-
	int n = EvtSpinType::getSpinStates( EvtPDL::getSpinType( getId() ) );

	EvtSpinDensity R;
	@@ -67,8 +65,8 @@

	auto lambda2 = [J2]( int i ) { return J2 - i * 2; };

	- for ( i = 0; i < n; i++ ) {
	- for ( j = 0; j < n; j++ ) {
	+ for ( int i = 0; i < n; i++ ) {
	+ for ( int j = 0; j < n; j++ ) {
	R.set( i, j,
	EvtdFunction::d( J2, lambda2( j ), lambda2( i ), beta ) *
	exp( EvtComplex( 0.0, 0.5 * ( alpha * lambda2( i ) -
	diff --git a/src/EvtGenBase/EvtId.cpp b/src/EvtGenBase/EvtId.cpp
	--- a/src/EvtGenBase/EvtId.cpp
	+++ b/src/EvtGenBase/EvtId.cpp
	@@ -28,7 +28,7 @@

	ostream& operator<<( ostream& s, const EvtId& id )
	{
	- s << "(Id=" << id._id << " Alias=" << id._alias << ")";
	+ s << "(Id=" << id.m_id << " Alias=" << id.m_alias << ")";

	return s;
	}
	diff --git a/src/EvtGenBase/EvtIncoherentMixing.cpp b/src/EvtGenBase/EvtIncoherentMixing.cpp
	--- a/src/EvtGenBase/EvtIncoherentMixing.cpp
	+++ b/src/EvtGenBase/EvtIncoherentMixing.cpp
	@@ -32,28 +32,28 @@
	// 2003-10-09 : Patrick Robbe
	//-----------------------------------------------------------------------------

	-bool EvtIncoherentMixing::_doB0Mixing = false;
	-bool EvtIncoherentMixing::_doBsMixing = false;
	-bool EvtIncoherentMixing::_enableFlip = false;
	-double EvtIncoherentMixing::_dGammad = 0.;
	-double EvtIncoherentMixing::_deltamd = 0.502e12;
	+bool EvtIncoherentMixing::m_doB0Mixing = false;
	+bool EvtIncoherentMixing::m_doBsMixing = false;
	+bool EvtIncoherentMixing::m_enableFlip = false;
	+double EvtIncoherentMixing::m_dGammad = 0.;
	+double EvtIncoherentMixing::m_deltamd = 0.502e12;
	// dGamma_s corresponds to DeltaGamma / Gamma = 10 %
	-double EvtIncoherentMixing::_dGammas = 6.852e10;
	-double EvtIncoherentMixing::_deltams = 20.e12;
	+double EvtIncoherentMixing::m_dGammas = 6.852e10;
	+double EvtIncoherentMixing::m_deltams = 20.e12;

	//=============================================================================
	// Standard constructor, initializes variables
	//=============================================================================
	EvtIncoherentMixing::EvtIncoherentMixing()
	{
	- _doB0Mixing = false;
	- _doBsMixing = false;
	- _dGammad = 0.;
	+ m_doB0Mixing = false;
	+ m_doBsMixing = false;
	+ m_dGammad = 0.;
	// dGammas corresponds to DeltaGamma / Gamma = 10 %
	- _dGammas = 6.852e10;
	- _deltamd = 0.502e12;
	- _deltams = 20.e12;
	- _enableFlip = false;
	+ m_dGammas = 6.852e10;
	+ m_deltamd = 0.502e12;
	+ m_deltams = 20.e12;
	+ m_enableFlip = false;
	}
	//=============================================================================
	void EvtIncoherentMixing::incoherentB0Mix( const EvtId id, double& t, int& mix )
	@@ -247,78 +247,78 @@
	// activate or desactivate the Bs mixing
	void EvtIncoherentMixing::setB0Mixing()
	{
	- _doB0Mixing = true;
	+ m_doB0Mixing = true;
	}
	void EvtIncoherentMixing::unsetB0Mixing()
	{
	- _doB0Mixing = false;
	+ m_doB0Mixing = false;
	}

	// activate or desactivate the B0 mixing
	void EvtIncoherentMixing::setBsMixing()
	{
	- _doBsMixing = true;
	+ m_doBsMixing = true;
	}
	void EvtIncoherentMixing::unsetBsMixing()
	{
	- _doBsMixing = false;
	+ m_doBsMixing = false;
	}

	// is mixing activated ?
	bool EvtIncoherentMixing::doB0Mixing()
	{
	- return _doB0Mixing;
	+ return m_doB0Mixing;
	}
	bool EvtIncoherentMixing::doBsMixing()
	{
	- return _doBsMixing;
	+ return m_doBsMixing;
	}

	// set values for the mixing
	void EvtIncoherentMixing::setdGammad( double value )
	{
	- _dGammad = value;
	+ m_dGammad = value;
	}
	void EvtIncoherentMixing::setdeltamd( double value )
	{
	- _deltamd = value;
	+ m_deltamd = value;
	}
	void EvtIncoherentMixing::setdGammas( double value )
	{
	- _dGammas = value;
	+ m_dGammas = value;
	}
	void EvtIncoherentMixing::setdeltams( double value )
	{
	- _deltams = value;
	+ m_deltams = value;
	}

	// get parameters for mixing
	double EvtIncoherentMixing::getdGammad()
	{
	- return _dGammad;
	+ return m_dGammad;
	}
	double EvtIncoherentMixing::getdeltamd()
	{
	- return _deltamd;
	+ return m_deltamd;
	}
	double EvtIncoherentMixing::getdGammas()
	{
	- return _dGammas;
	+ return m_dGammas;
	}
	double EvtIncoherentMixing::getdeltams()
	{
	- return _deltams;
	+ return m_deltams;
	}

	bool EvtIncoherentMixing::flipIsEnabled()
	{
	- return _enableFlip;
	+ return m_enableFlip;
	}
	void EvtIncoherentMixing::enableFlip()
	{
	- _enableFlip = true;
	+ m_enableFlip = true;
	}
	void EvtIncoherentMixing::disableFlip()
	{
	- _enableFlip = false;
	+ m_enableFlip = false;
	}
	diff --git a/src/EvtGenBase/EvtIntervalFlatPdf.cpp b/src/EvtGenBase/EvtIntervalFlatPdf.cpp
	--- a/src/EvtGenBase/EvtIntervalFlatPdf.cpp
	+++ b/src/EvtGenBase/EvtIntervalFlatPdf.cpp
	@@ -26,13 +26,13 @@
	#include <assert.h>

	EvtIntervalFlatPdf::EvtIntervalFlatPdf( double min, double max ) :
	- EvtPdf<EvtPoint1D>(), _min( min ), _max( max )
	+ EvtPdf<EvtPoint1D>(), m_min( min ), m_max( max )
	{
	assert( max >= min );
	}

	EvtIntervalFlatPdf::EvtIntervalFlatPdf( const EvtIntervalFlatPdf& other ) :
	- EvtPdf<EvtPoint1D>( other ), _min( other._min ), _max( other._max )
	+ EvtPdf<EvtPoint1D>( other ), m_min( other.m_min ), m_max( other.m_max )
	{
	}

	@@ -48,10 +48,10 @@

	EvtValError EvtIntervalFlatPdf::compute_integral() const
	{
	- return EvtValError( _max - _min, 0. );
	+ return EvtValError( m_max - m_min, 0. );
	}

	EvtPoint1D EvtIntervalFlatPdf::randomPoint()
	{
	- return EvtPoint1D( _min, _max, EvtRandom::Flat( _min, _max ) );
	+ return EvtPoint1D( m_min, m_max, EvtRandom::Flat( m_min, m_max ) );
	}
	diff --git a/src/EvtGenBase/EvtLASSAmp.cpp b/src/EvtGenBase/EvtLASSAmp.cpp
	--- a/src/EvtGenBase/EvtLASSAmp.cpp
	+++ b/src/EvtGenBase/EvtLASSAmp.cpp
	@@ -36,21 +36,21 @@
	double g0, double a, double r, double cutoff,
	std::string subtype ) :
	EvtAmplitude<EvtDalitzPoint>(),
	- _pair( pair ),
	- _m0( m0 ),
	- _g0( g0 ),
	- _r( r ),
	- _a( a ),
	- _cutoff( cutoff ),
	- _subtype( subtype )
	+ m_pair( pair ),
	+ m_m0( m0 ),
	+ m_g0( g0 ),
	+ m_r( r ),
	+ m_a( a ),
	+ m_cutoff( cutoff ),
	+ m_subtype( subtype )
	{
	- _dalitzSpace = dp;
	+ m_dalitzSpace = dp;
	double ma = dp->m( first( pair ) );
	double mb = dp->m( second( pair ) );
	- double E0a = 0.5 * ( _m0 * _m0 + ma * ma - mb * mb ) / _m0;
	- _q0 = E0a * E0a - ma * ma;
	- assert( _q0 > 0 );
	- _q0 = sqrt( _q0 );
	+ double E0a = 0.5 * ( m_m0 * m_m0 + ma * ma - mb * mb ) / m_m0;
	+ m_q0 = E0a * E0a - ma * ma;
	+ assert( m_q0 > 0 );
	+ m_q0 = sqrt( m_q0 );
	}

	EvtComplex EvtLASSAmp::amplitude( const EvtDalitzPoint& dalitzPoint ) const
	@@ -76,14 +76,14 @@

	*/

	- double s = dalitzPoint.q( _pair );
	+ double s = dalitzPoint.q( m_pair );
	double m = sqrt( s );
	- double q = dalitzPoint.p( first( _pair ), _pair );
	+ double q = dalitzPoint.p( first( m_pair ), m_pair );

	// elastic scattering
	- double qcotd = 1. / _a + 0.5 * _r * q * q;
	- EvtComplex lass_elastic = m < _cutoff ? m / ( qcotd - EvtComplex( 0, q ) )
	- : 0;
	+ double qcotd = 1. / m_a + 0.5 * m_r * q * q;
	+ EvtComplex lass_elastic = m < m_cutoff ? m / ( qcotd - EvtComplex( 0, q ) )
	+ : 0;

	// relative phase
	double cosd = 1;
	@@ -97,16 +97,17 @@
	lass_phase *= lass_phase;

	// K*(1430)
	- double gamma = _g0 * q / m * _m0 / _q0;
	- EvtComplex lass_Kstar = ( _m0 * _m0 ) * ( _g0 / _q0 ) /
	- ( _m0 * _m0 - m * m - EvtComplex( 0., _m0 * gamma ) );
	+ double gamma = m_g0 * q / m * m_m0 / m_q0;
	+ EvtComplex lass_Kstar = ( m_m0 * m_m0 ) * ( m_g0 / m_q0 ) /
	+ ( m_m0 * m_m0 - m * m -
	+ EvtComplex( 0., m_m0 * gamma ) );

	EvtComplex theAmplitude( 0.0, 0.0 );

	- if ( _subtype == "LASS_ELASTIC" ) {
	+ if ( m_subtype == "LASS_ELASTIC" ) {
	theAmplitude = lass_elastic;

	- } else if ( _subtype == "LASS_RESONANT" ) {
	+ } else if ( m_subtype == "LASS_RESONANT" ) {
	theAmplitude = lass_phase * lass_Kstar;

	} else {
	diff --git a/src/EvtGenBase/EvtMTRandomEngine.cpp b/src/EvtGenBase/EvtMTRandomEngine.cpp
	--- a/src/EvtGenBase/EvtMTRandomEngine.cpp
	+++ b/src/EvtGenBase/EvtMTRandomEngine.cpp
	@@ -26,7 +26,7 @@
	#include <iostream>

	EvtMTRandomEngine::EvtMTRandomEngine( unsigned int seed ) :
	- engine_( seed ), distribution_( URDist( 0.0, 1.0 ) )
	+ m_engine( seed ), m_distribution( URDist( 0.0, 1.0 ) )
	{
	EvtGenReport( EVTGEN_INFO, "EvtMTRandomEngine" )
	<< "Mersenne-Twister random number generator with seed = " << seed
	@@ -35,5 +35,5 @@

	double EvtMTRandomEngine::random()
	{
	- return distribution_( engine_ );
	+ return m_distribution( m_engine );
	}
	diff --git a/src/EvtGenBase/EvtManyDeltaFuncLineShape.cpp b/src/EvtGenBase/EvtManyDeltaFuncLineShape.cpp
	--- a/src/EvtGenBase/EvtManyDeltaFuncLineShape.cpp
	+++ b/src/EvtGenBase/EvtManyDeltaFuncLineShape.cpp
	@@ -37,41 +37,41 @@
	double maxRange,
	EvtSpinType::spintype sp )
	{
	- _mass = mass;
	- _width = width;
	- _spin = sp;
	- _maxRange = maxRange;
	+ m_mass = mass;
	+ m_width = width;
	+ m_spin = sp;
	+ m_maxRange = maxRange;

	double maxdelta = width;

	- _massMax = mass + maxdelta;
	- _massMin = mass - maxdelta;
	+ m_massMax = mass + maxdelta;
	+ m_massMin = mass - maxdelta;

	- if ( _massMin < 0. )
	- _massMin = 0.;
	+ if ( m_massMin < 0. )
	+ m_massMin = 0.;
	}

	EvtManyDeltaFuncLineShape::EvtManyDeltaFuncLineShape(
	const EvtManyDeltaFuncLineShape& x ) :
	EvtAbsLineShape( x )
	{
	- _mass = x._mass;
	- _width = x._width;
	- _spin = x._spin;
	- _massMax = x._massMax;
	- _massMin = x._massMin;
	- _maxRange = x._maxRange;
	+ m_mass = x.m_mass;
	+ m_width = x.m_width;
	+ m_spin = x.m_spin;
	+ m_massMax = x.m_massMax;
	+ m_massMin = x.m_massMin;
	+ m_maxRange = x.m_maxRange;
	}

	EvtManyDeltaFuncLineShape& EvtManyDeltaFuncLineShape::operator=(
	const EvtManyDeltaFuncLineShape& x )
	{
	- _mass = x._mass;
	- _massMax = x._massMax;
	- _massMin = x._massMin;
	- _width = x._width;
	- _maxRange = x._maxRange;
	- _spin = x._spin;
	+ m_mass = x.m_mass;
	+ m_massMax = x.m_massMax;
	+ m_massMin = x.m_massMin;
	+ m_width = x.m_width;
	+ m_maxRange = x.m_maxRange;
	+ m_spin = x.m_spin;
	return *this;
	}

	@@ -103,9 +103,9 @@
	double EvtManyDeltaFuncLineShape::getRandMass( EvtId, int, EvtId, EvtId*,
	double, double* )
	{
	- int nDelta = int( ( _massMax - _massMin ) / _width );
	+ int nDelta = int( ( m_massMax - m_massMin ) / m_width );
	nDelta++;
	double rand = EvtRandom::Flat( 0., float( nDelta ) );
	int randI = int( rand );
	- return _massMin + randI * _width;
	+ return m_massMin + randI * m_width;
	}
	diff --git a/src/EvtGenBase/EvtMassAmp.cpp b/src/EvtGenBase/EvtMassAmp.cpp
	--- a/src/EvtGenBase/EvtMassAmp.cpp
	+++ b/src/EvtGenBase/EvtMassAmp.cpp
	@@ -25,37 +25,37 @@
	EvtMassAmp::EvtMassAmp( const EvtPropBreitWignerRel& prop,
	const EvtTwoBodyVertex& vd ) :
	EvtAmplitude<EvtPoint1D>(),
	- _prop( prop ),
	- _vd( vd ),
	- _useBirthFact( false ),
	- _useDeathFact( false ),
	- _useBirthFactFF( false ),
	- _useDeathFactFF( false )
	+ m_prop( prop ),
	+ m_vd( vd ),
	+ m_useBirthFact( false ),
	+ m_useDeathFact( false ),
	+ m_useBirthFactFF( false ),
	+ m_useDeathFactFF( false )
	{
	}

	EvtMassAmp::EvtMassAmp( const EvtMassAmp& other ) :
	EvtAmplitude<EvtPoint1D>( other ),
	- _prop( other._prop ),
	- _vd( other._vd ),
	- _vb( other._vb ? new EvtTwoBodyVertex( *other._vb ) : nullptr ),
	- _useBirthFact( other._useBirthFact ),
	- _useDeathFact( other._useDeathFact ),
	- _useBirthFactFF( other._useBirthFactFF ),
	- _useDeathFactFF( other._useDeathFactFF )
	+ m_prop( other.m_prop ),
	+ m_vd( other.m_vd ),
	+ m_vb( other.m_vb ? new EvtTwoBodyVertex( *other.m_vb ) : nullptr ),
	+ m_useBirthFact( other.m_useBirthFact ),
	+ m_useDeathFact( other.m_useDeathFact ),
	+ m_useBirthFactFF( other.m_useBirthFactFF ),
	+ m_useDeathFactFF( other.m_useDeathFactFF )
	{
	}

	EvtMassAmp& EvtMassAmp::operator=( const EvtMassAmp& other )
	{
	EvtAmplitude<EvtPoint1D>::operator=( other );
	- _prop = other._prop;
	- _vd = other._vd;
	- _vb.reset( other._vb ? new EvtTwoBodyVertex( *other._vb ) : nullptr );
	- _useBirthFact = other._useBirthFact;
	- _useDeathFact = other._useDeathFact;
	- _useBirthFactFF = other._useBirthFactFF;
	- _useDeathFactFF = other._useDeathFactFF;
	+ m_prop = other.m_prop;
	+ m_vd = other.m_vd;
	+ m_vb.reset( other.m_vb ? new EvtTwoBodyVertex( *other.m_vb ) : nullptr );
	+ m_useBirthFact = other.m_useBirthFact;
	+ m_useDeathFact = other.m_useDeathFact;
	+ m_useBirthFactFF = other.m_useBirthFactFF;
	+ m_useDeathFactFF = other.m_useDeathFactFF;
	return *this;
	}

	@@ -66,43 +66,43 @@
	double m = p.value();
	// keep things from crashing..

	- if ( m < ( _vd.mA() + _vd.mB() ) )
	+ if ( m < ( m_vd.mA() + m_vd.mB() ) )
	return EvtComplex( 0., 0. );

	- EvtTwoBodyKine vd( _vd.mA(), _vd.mB(), m );
	+ EvtTwoBodyKine vd( m_vd.mA(), m_vd.mB(), m );

	// Compute mass-dependent width for relativistic propagator

	- EvtPropBreitWignerRel bw( _prop.m0(), _prop.g0() * _vd.widthFactor( vd ) );
	+ EvtPropBreitWignerRel bw( m_prop.m0(), m_prop.g0() * m_vd.widthFactor( vd ) );
	EvtComplex amp = bw.evaluate( m );

	// Birth vertex factors

	- if ( _useBirthFact ) {
	- assert( _vb );
	- if ( ( m + _vb->mB() ) < _vb->mAB() ) {
	- EvtTwoBodyKine vb( m, _vb->mB(), _vb->mAB() );
	- amp *= _vb->phaseSpaceFactor( vb, EvtTwoBodyKine::AB );
	- amp *= sqrt( ( vb.p() / _vb->pD() ) );
	+ if ( m_useBirthFact ) {
	+ assert( m_vb );
	+ if ( ( m + m_vb->mB() ) < m_vb->mAB() ) {
	+ EvtTwoBodyKine vb( m, m_vb->mB(), m_vb->mAB() );
	+ amp *= m_vb->phaseSpaceFactor( vb, EvtTwoBodyKine::AB );
	+ amp *= sqrt( ( vb.p() / m_vb->pD() ) );

	- if ( _useBirthFactFF ) {
	- assert( _vb );
	- amp *= _vb->formFactor( vb );
	+ if ( m_useBirthFactFF ) {
	+ assert( m_vb );
	+ amp *= m_vb->formFactor( vb );
	}
	} else {
	- if ( _vb->L() != 0 )
	+ if ( m_vb->L() != 0 )
	amp = 0.;
	}
	}

	// Decay vertex factors

	- if ( _useDeathFact ) {
	- amp *= _vd.phaseSpaceFactor( vd, EvtTwoBodyKine::AB );
	- amp *= sqrt( ( vd.p() / _vd.pD() ) );
	+ if ( m_useDeathFact ) {
	+ amp *= m_vd.phaseSpaceFactor( vd, EvtTwoBodyKine::AB );
	+ amp *= sqrt( ( vd.p() / m_vd.pD() ) );
	}
	- if ( _useDeathFactFF )
	- amp *= _vd.formFactor( vd );
	+ if ( m_useDeathFactFF )
	+ amp *= m_vd.formFactor( vd );

	return amp;
	}
	diff --git a/src/EvtGenBase/EvtModel.cpp b/src/EvtGenBase/EvtModel.cpp
	--- a/src/EvtGenBase/EvtModel.cpp
	+++ b/src/EvtGenBase/EvtModel.cpp
	@@ -38,7 +38,7 @@
	#include <string>
	using std::fstream;

	-EvtModel* EvtModel::_instance = nullptr;
	+EvtModel* EvtModel::m_instance = nullptr;

	EvtModel::EvtModel()
	{
	@@ -47,8 +47,8 @@
	EvtDecayBase* EvtModel::getFcn( std::string model_name )
	{
	EvtDecayBase* model = nullptr;
	- if ( _modelNameHash.find( model_name ) != _modelNameHash.end() ) {
	- model = _modelNameHash[model_name];
	+ if ( m_modelNameHash.find( model_name ) != m_modelNameHash.end() ) {
	+ model = m_modelNameHash[model_name];
	}

	if ( !model ) {
	@@ -64,18 +64,18 @@
	{
	std::string modelName = prototype->getName();

	- _modelNameHash[modelName] = prototype;
	+ m_modelNameHash[modelName] = prototype;

	std::string commandName = prototype->commandName();

	if ( commandName != "" ) {
	- _commandNameHash[commandName] = prototype;
	+ m_commandNameHash[commandName] = prototype;
	}
	}

	int EvtModel::isModel( std::string model_name )
	{
	- if ( _modelNameHash.find( model_name ) != _modelNameHash.end() ) {
	+ if ( m_modelNameHash.find( model_name ) != m_modelNameHash.end() ) {
	return 1;
	}
	return 0;
	@@ -83,7 +83,7 @@

	int EvtModel::isCommand( std::string cmd )
	{
	- if ( _commandNameHash.find( cmd ) != _commandNameHash.end() ) {
	+ if ( m_commandNameHash.find( cmd ) != m_commandNameHash.end() ) {
	return 1;
	}
	return 0;
	@@ -92,8 +92,8 @@
	void EvtModel::storeCommand( std::string cmd, std::string cnfgstr )
	{
	EvtDecayBase* model = nullptr;
	- if ( _commandNameHash.find( cmd ) != _commandNameHash.end() ) {
	- model = _commandNameHash[cmd];
	+ if ( m_commandNameHash.find( cmd ) != m_commandNameHash.end() ) {
	+ model = m_commandNameHash[cmd];
	}

	assert( model );
	diff --git a/src/EvtGenBase/EvtModelAlias.cpp b/src/EvtGenBase/EvtModelAlias.cpp
	--- a/src/EvtGenBase/EvtModelAlias.cpp
	+++ b/src/EvtGenBase/EvtModelAlias.cpp
	@@ -25,30 +25,30 @@
	EvtModelAlias::EvtModelAlias( std::string alias, std::string model,
	std::vector<std::string> args ) :

	- _aliasName( alias ), _model( model ), _modelArgs( args )
	+ m_aliasName( alias ), m_model( model ), m_modelArgs( args )

	{
	}

	EvtModelAlias::EvtModelAlias( const EvtModelAlias& copyMe ) :

	- _aliasName( copyMe._aliasName ),
	- _model( copyMe._model ),
	- _modelArgs( copyMe._modelArgs )
	+ m_aliasName( copyMe.m_aliasName ),
	+ m_model( copyMe.m_model ),
	+ m_modelArgs( copyMe.m_modelArgs )

	{
	}

	EvtModelAlias EvtModelAlias::operator=( const EvtModelAlias& copyMe )
	{
	- _aliasName = copyMe._aliasName;
	- _model = copyMe._model;
	- _modelArgs = copyMe._modelArgs;
	+ m_aliasName = copyMe.m_aliasName;
	+ m_model = copyMe.m_model;
	+ m_modelArgs = copyMe.m_modelArgs;

	return *this;
	}

	std::vector<std::string> EvtModelAlias::getArgList()
	{
	- return _modelArgs;
	+ return m_modelArgs;
	}
	diff --git a/src/EvtGenBase/EvtMultiChannelParser.cpp b/src/EvtGenBase/EvtMultiChannelParser.cpp
	--- a/src/EvtGenBase/EvtMultiChannelParser.cpp
	+++ b/src/EvtGenBase/EvtMultiChannelParser.cpp
	@@ -127,13 +127,13 @@
	// use in the scan.

	if ( v[0] == std::string( "MAXPDF" ) ) {
	- _pdfMax = strtod( v[1].c_str(), tc );
	- if ( _pdfMax <= 0 ) {
	- printf( "Bad pdfMax=%f\n", _pdfMax );
	+ m_pdfMax = strtod( v[1].c_str(), tc );
	+ if ( m_pdfMax <= 0 ) {
	+ printf( "Bad pdfMax=%f\n", m_pdfMax );
	assert( 0 );
	}
	} else if ( v[0] == std::string( "SCANPDF" ) ) {
	- _nScan = atoi( v[1].c_str() );
	+ m_nScan = atoi( v[1].c_str() );
	} else {
	printf( "Error parsing decay file\n" );
	assert( 0 );
	@@ -153,9 +153,9 @@
	assert( conjugate == false );
	conjugate = true;
	i++;
	- _dm = strtod( v[i++].c_str(), tc );
	- _mixAmpli = strtod( v[i++].c_str(), tc );
	- _mixPhase = strtod( v[i++].c_str(), tc );
	+ m_dm = strtod( v[i++].c_str(), tc );
	+ m_mixAmpli = strtod( v[i++].c_str(), tc );
	+ m_mixPhase = strtod( v[i++].c_str(), tc );
	}

	if ( i >= v.size() )
	@@ -167,19 +167,19 @@
	if ( !conjugate && v[i] == std::string( "AMPLITUDE" ) ) {
	while ( !isKeyword( v[++i] ) )
	params.push_back( v[i] );
	- _amp.push_back( params );
	+ m_amp.push_back( params );

	parseComplexCoef( i, v, c, format );
	- _ampCoef.push_back( c );
	- _coefFormat.push_back( format );
	+ m_ampCoef.push_back( c );
	+ m_coefFormat.push_back( format );
	continue;
	} else if ( conjugate && v[i] == std::string( "AMPLITUDE" ) ) {
	while ( !isKeyword( v[++i] ) )
	params.push_back( v[i] );
	- _ampConj.push_back( params );
	+ m_ampConj.push_back( params );
	parseComplexCoef( i, v, c, format );
	- _ampConjCoef.push_back( c );
	- _coefConjFormat.push_back( format );
	+ m_ampConjCoef.push_back( c );
	+ m_coefConjFormat.push_back( format );
	continue;
	} else {
	printf( "Expect keyword, found parameter %s\n", v[i].c_str() );
	@@ -187,12 +187,12 @@
	}

	assert( i > i0 );
	- _unused( i0 );
	+ UNUSED( i0 );
	}

	printf( "PARSING SUCCESSFUL\n" );
	- printf( "%d amplitude terms\n", (int)_amp.size() );
	- printf( "%d conj amplitude terms\n", (int)_ampConj.size() );
	+ printf( "%d amplitude terms\n", (int)m_amp.size() );
	+ printf( "%d conj amplitude terms\n", (int)m_ampConj.size() );
	}

	void EvtMultiChannelParser::parseComplexCoef( size_t& i,
	diff --git a/src/EvtGenBase/EvtNeutrinoParticle.cpp b/src/EvtGenBase/EvtNeutrinoParticle.cpp
	--- a/src/EvtGenBase/EvtNeutrinoParticle.cpp
	+++ b/src/EvtGenBase/EvtNeutrinoParticle.cpp
	@@ -33,7 +33,7 @@

	void EvtNeutrinoParticle::init( EvtId part_n, const EvtVector4R& p4 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( part_n );

	@@ -70,10 +70,10 @@
	cosa = cos( 0.5 * alpha );
	sina = sin( 0.5 * alpha );

	- spinor_parent.set( -norm * sinb * EvtComplex( cosa, -sina ),
	- norm * cosb * EvtComplex( cosa, sina ),
	- norm * sinb * EvtComplex( cosa, -sina ),
	- -norm * cosb * EvtComplex( cosa, sina ) );
	+ m_spinor_parent.set( -norm * sinb * EvtComplex( cosa, -sina ),
	+ norm * cosb * EvtComplex( cosa, sina ),
	+ norm * sinb * EvtComplex( cosa, -sina ),
	+ -norm * cosb * EvtComplex( cosa, sina ) );

	} else {
	px = -p4.get( 1 );
	@@ -85,10 +85,10 @@
	pn = e;
	sqrpn = sqrt( pn - pz );

	- spinor_parent.set( ( 1.0 / sqrpn ) * EvtComplex( px, -py ),
	- EvtComplex( sqrpn, 0.0 ),
	- ( -1.0 / sqrpn ) * EvtComplex( px, -py ),
	- -EvtComplex( sqrpn, 0.0 ) );
	+ m_spinor_parent.set( ( 1.0 / sqrpn ) * EvtComplex( px, -py ),
	+ EvtComplex( sqrpn, 0.0 ),
	+ ( -1.0 / sqrpn ) * EvtComplex( px, -py ),
	+ -EvtComplex( sqrpn, 0.0 ) );
	}

	setLifetime();
	@@ -96,7 +96,7 @@

	EvtDiracSpinor EvtNeutrinoParticle::spParentNeutrino() const
	{
	- return spinor_parent;
	+ return m_spinor_parent;
	}

	EvtDiracSpinor EvtNeutrinoParticle::spNeutrino() const
	@@ -107,7 +107,7 @@

	::abort();

	- return spinor_rest;
	+ return m_spinor_rest;
	}

	EvtSpinDensity EvtNeutrinoParticle::rotateToHelicityBasis() const
	diff --git a/src/EvtGenBase/EvtNonresonantAmp.cpp b/src/EvtGenBase/EvtNonresonantAmp.cpp
	--- a/src/EvtGenBase/EvtNonresonantAmp.cpp
	+++ b/src/EvtGenBase/EvtNonresonantAmp.cpp
	@@ -39,60 +39,60 @@
	EvtCyclic3::Pair pair2, double par2,
	EvtSpinType::spintype spin ) :
	EvtAmplitude<EvtDalitzPoint>(),
	- _dalitzSpace{ dp },
	- _type( type ),
	- _pair1( pair1 ),
	- _pair2( pair2 ),
	- _par1( par1 ),
	- _par2( par2 ),
	- _spin( spin )
	+ m_dalitzSpace{ dp },
	+ m_type( type ),
	+ m_pair1( pair1 ),
	+ m_pair2( pair2 ),
	+ m_par1( par1 ),
	+ m_par2( par2 ),
	+ m_spin( spin )
	{
	}

	EvtComplex EvtNonresonantAmp::amplitude( const EvtDalitzPoint& dalitzPoint ) const
	{
	// flat model
	- if ( _type == EvtPto3PAmp::NONRES ) {
	+ if ( m_type == EvtPto3PAmp::NONRES ) {
	return 1;
	}

	// "linear model" (prop. to m^2)
	- else if ( _type == EvtPto3PAmp::NONRES_LIN ) {
	- return dalitzPoint.q( _pair1 );
	+ else if ( m_type == EvtPto3PAmp::NONRES_LIN ) {
	+ return dalitzPoint.q( m_pair1 );
	}

	// Chen-Chua-Soni
	- else if ( _type == EvtPto3PAmp::NONRES_CCS ) {
	- double s = dalitzPoint.q( _pair1 );
	- double smin = _dalitzSpace->qAbsMin( _pair1 );
	- return sqrt( s - smin ) / ( s * log( s * _par1 ) );
	+ else if ( m_type == EvtPto3PAmp::NONRES_CCS ) {
	+ double s = dalitzPoint.q( m_pair1 );
	+ double smin = m_dalitzSpace->qAbsMin( m_pair1 );
	+ return sqrt( s - smin ) / ( s * log( s * m_par1 ) );
	}

	// exp{par*m^2) (Belle model, Garmash et al, PRD71)
	- else if ( _type == EvtPto3PAmp::NONRES_EXP ) {
	- return exp( _par1 * dalitzPoint.q( _pair1 ) );
	+ else if ( m_type == EvtPto3PAmp::NONRES_EXP ) {
	+ return exp( m_par1 * dalitzPoint.q( m_pair1 ) );
	}

	// exp(par1m12^2 + par2m13^2) (Belle model, Garmash et al, PRD71)
	- else if ( _type == EvtPto3PAmp::NONRES_EXP_ADD ) {
	- return exp( _par1 * dalitzPoint.q( _pair1 ) +
	- _par2 * dalitzPoint.q( _pair2 ) );
	+ else if ( m_type == EvtPto3PAmp::NONRES_EXP_ADD ) {
	+ return exp( m_par1 * dalitzPoint.q( m_pair1 ) +
	+ m_par2 * dalitzPoint.q( m_pair2 ) );
	}

	// Laura model (P.Harrison et al, BAD806)
	- else if ( _type == EvtPto3PAmp::NONRES_LAURA ) {
	- double m = sqrt( dalitzPoint.q( _pair1 ) );
	- double mmin = sqrt( _dalitzSpace->qAbsMin( _pair1 ) );
	+ else if ( m_type == EvtPto3PAmp::NONRES_LAURA ) {
	+ double m = sqrt( dalitzPoint.q( m_pair1 ) );
	+ double mmin = sqrt( m_dalitzSpace->qAbsMin( m_pair1 ) );
	double dm = m - mmin;
	assert( dm > 0 );
	double cosTh = 1;
	- int ispin = EvtSpinType::getSpin2( _spin );
	+ int ispin = EvtSpinType::getSpin2( m_spin );
	if ( ispin > 0 ) {
	- cosTh = dalitzPoint.cosTh( EvtCyclic3::next( _pair1 ), _pair1 );
	+ cosTh = dalitzPoint.cosTh( EvtCyclic3::next( m_pair1 ), m_pair1 );
	if ( ispin > 2 )
	cosTh *= cosTh;
	}
	- return pow( dm, _par1 ) * exp( dm * _par2 ) * cosTh;
	+ return pow( dm, m_par1 ) * exp( dm * m_par2 ) * cosTh;
	}

	return 0;
	diff --git a/src/EvtGenBase/EvtOrthogVector.cpp b/src/EvtGenBase/EvtOrthogVector.cpp
	--- a/src/EvtGenBase/EvtOrthogVector.cpp
	+++ b/src/EvtGenBase/EvtOrthogVector.cpp
	@@ -31,48 +31,48 @@

	EvtOrthogVector::EvtOrthogVector( int n, std::vector<double>* vectors )
	{
	- _dimen = n;
	- _holder.resize( n );
	+ m_dimen = n;
	+ m_holder.resize( n );

	std::vector<int> temp;

	int i;
	for ( i = 0; i < n; i++ ) {
	- _orthogVector.push_back( 0. );
	+ m_orthogVector.push_back( 0. );
	temp.push_back( i );
	}

	- findOrthog( _dimen, temp, vectors );
	+ findOrthog( m_dimen, temp, vectors );
	}

	void EvtOrthogVector::findOrthog( int dim, std::vector<int> invect,
	std::vector<double>* vectors )
	{
	if ( dim == 2 ) {
	- _holder[0] = invect[0];
	- _holder[1] = invect[1];
	+ m_holder[0] = invect[0];
	+ m_holder[1] = invect[1];
	int sign = findEvenOddSwaps();
	{
	double addition = 1;
	int i;
	- for ( i = 1; i < _dimen; i++ ) {
	- addition *= vectors[i - 1][_holder[i]];
	+ for ( i = 1; i < m_dimen; i++ ) {
	+ addition *= vectors[i - 1][m_holder[i]];
	}
	addition *= sign;
	- _orthogVector[_holder[0]] += addition;
	+ m_orthogVector[m_holder[0]] += addition;
	}

	- _holder[0] = invect[1];
	- _holder[1] = invect[0];
	+ m_holder[0] = invect[1];
	+ m_holder[1] = invect[0];

	{
	double addition = 1;
	int i;
	- for ( i = 1; i < _dimen; i++ ) {
	- addition *= vectors[i - 1][_holder[i]];
	+ for ( i = 1; i < m_dimen; i++ ) {
	+ addition *= vectors[i - 1][m_holder[i]];
	}
	addition *= sign;
	- _orthogVector[_holder[0]] -= addition;
	+ m_orthogVector[m_holder[0]] -= addition;
	}

	return;
	@@ -86,7 +86,7 @@
	temp[i + dim] = invect[i];

	for ( i = 0; i < dim; i++ ) {
	- _holder[dim - 1] = temp[dim - 1 + i];
	+ m_holder[dim - 1] = temp[dim - 1 + i];
	std::vector<int> tempDim( ( dim - 1 ) );

	int j;
	@@ -101,15 +101,15 @@

	int EvtOrthogVector::findEvenOddSwaps()
	{
	- std::vector<int> temp( _dimen );
	+ std::vector<int> temp( m_dimen );

	int i, j, nSwap;
	- for ( i = 0; i < _dimen; i++ )
	- temp[i] = _holder[i];
	+ for ( i = 0; i < m_dimen; i++ )
	+ temp[i] = m_holder[i];

	nSwap = 0;
	- for ( i = 0; i < ( _dimen - 1 ); i++ ) {
	- for ( j = i + 1; j < _dimen; j++ ) {
	+ for ( i = 0; i < ( m_dimen - 1 ); i++ ) {
	+ for ( j = i + 1; j < m_dimen; j++ ) {
	if ( temp[i] > temp[j] ) {
	int duh = temp[j];
	temp[j] = temp[i];
	diff --git a/src/EvtGenBase/EvtPDL.cpp b/src/EvtGenBase/EvtPDL.cpp
	--- a/src/EvtGenBase/EvtPDL.cpp
	+++ b/src/EvtGenBase/EvtPDL.cpp
	@@ -26,28 +26,25 @@
	#include "EvtGenBase/EvtPatches.hh"
	#include "EvtGenBase/EvtReport.hh"

	-#include <ctype.h>
	+#include <cstring>
	#include <fstream>
	#include <iostream>
	-#include <stdlib.h>
	-#include <string.h>
	+
	using std::endl;
	-using std::fstream;
	-using std::ifstream;

	static int first = 1;

	-unsigned int EvtPDL::_firstAlias;
	-int EvtPDL::_nentries;
	+unsigned int EvtPDL::m_firstAlias;
	+int EvtPDL::m_nentries;

	-std::map<std::string, int> EvtPDL::_particleNameLookup;
	+std::map<std::string, int> EvtPDL::m_particleNameLookup;

	EvtPDL::EvtPDL()
	{
	if ( first != 0 ) {
	first = 0;
	- _nentries = 0;
	- _firstAlias = 999999;
	+ m_nentries = 0;
	+ m_firstAlias = 999999;
	}
	}

	@@ -112,7 +109,7 @@
	indec >> ctau;
	indec >> lundkc;

	- i = EvtId( _nentries, _nentries );
	+ i = EvtId( m_nentries, m_nentries );

	EvtPartProp tmp;

	@@ -154,8 +151,8 @@
	tmp.setStdHep( stdhepid );
	tmp.setLundKC( lundkc );
	tmp.setName( pname );
	- if ( _particleNameLookup.find( std::string( pname ) ) !=
	- _particleNameLookup.end() ) {
	+ if ( m_particleNameLookup.find( std::string( pname ) ) !=
	+ m_particleNameLookup.end() ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "The particle name:" << pname
	<< " is already defined." << endl;
	@@ -163,14 +160,14 @@
	<< "Will terminate execution.";
	::abort();
	}
	- _particleNameLookup[std::string( pname )] = _nentries;
	+ m_particleNameLookup[std::string( pname )] = m_nentries;
	tmp.setctau( ctau );
	tmp.setChg3( chg3 );

	tmp.initLineShape( mass, pwidth, pmaxwidth );

	partlist().push_back( tmp );
	- _nentries++;
	+ m_nentries++;
	}

	// if find a set read information and discard it
	@@ -255,8 +252,8 @@

	void EvtPDL::alias( EvtId num, const std::string& newname )
	{
	- if ( _firstAlias < partlist().size() ) {
	- for ( size_t i = _firstAlias; i < partlist().size(); i-- ) {
	+ if ( m_firstAlias < partlist().size() ) {
	+ for ( size_t i = m_firstAlias; i < partlist().size(); i-- ) {
	if ( newname == partlist()[i].getName() ) {
	EvtGenReport( EVTGEN_WARNING, "EvtGen" )
	<< "Redefining alias:" << newname.c_str()
	@@ -265,20 +262,20 @@
	}
	}
	} else {
	- _firstAlias = partlist().size();
	+ m_firstAlias = partlist().size();
	}

	partlist().push_back( partlist()[num.getId()] );
	int entry = partlist().size() - 1;
	partlist()[entry].setName( newname );
	- if ( _particleNameLookup.find( std::string( newname ) ) !=
	- _particleNameLookup.end() ) {
	+ if ( m_particleNameLookup.find( std::string( newname ) ) !=
	+ m_particleNameLookup.end() ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "The particle name:" << newname << " is already defined." << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Will terminate execution.";
	::abort();
	}
	- _particleNameLookup[std::string( newname )] = entry;
	+ m_particleNameLookup[std::string( newname )] = entry;
	partlist()[entry].setId( EvtId( num.getId(), entry ) );
	//Lange - Dec7, 2003. Unset the charge conjugate.
	partlist()[entry].setIdChgConj( EvtId( -1, -1 ) );
	@@ -286,9 +283,9 @@

	EvtId EvtPDL::getId( const std::string& name )
	{
	- std::map<std::string, int>::iterator it = _particleNameLookup.find(
	+ std::map<std::string, int>::iterator it = m_particleNameLookup.find(
	std::string( name ) );
	- if ( it == _particleNameLookup.end() )
	+ if ( it == m_particleNameLookup.end() )
	return EvtId( -1, -1 );

	return partlist()[it->second].getId();
	diff --git a/src/EvtGenBase/EvtParser.cpp b/src/EvtGenBase/EvtParser.cpp
	--- a/src/EvtGenBase/EvtParser.cpp
	+++ b/src/EvtGenBase/EvtParser.cpp
	@@ -32,31 +32,31 @@

	EvtParser::EvtParser()
	{
	- _ntoken = 0;
	- _lengthoftokenlist = 0;
	- _tokenlist = nullptr;
	- _linelist = nullptr;
	+ m_ntoken = 0;
	+ m_lengthoftokenlist = 0;
	+ m_tokenlist = nullptr;
	+ m_linelist = nullptr;
	}

	EvtParser::~EvtParser()
	{
	- delete[] _tokenlist;
	- delete[] _linelist;
	+ delete[] m_tokenlist;
	+ delete[] m_linelist;
	}

	int EvtParser::getNToken()
	{
	- return _ntoken;
	+ return m_ntoken;
	}

	const std::string& EvtParser::getToken( int i )
	{
	- return _tokenlist[i];
	+ return m_tokenlist[i];
	}

	int EvtParser::getLineofToken( int i )
	{
	- return _linelist[i];
	+ return m_linelist[i];
	}

	int EvtParser::read( const std::string filename )
	@@ -128,35 +128,35 @@

	void EvtParser::addToken( int line, const std::string& string )
	{
	- //EvtGenReport(EVTGEN_INFO,"EvtGen") <<_ntoken<<" "<<line<<" "<<string<<endl;
	+ //EvtGenReport(EVTGEN_INFO,"EvtGen") <<m_ntoken<<" "<<line<<" "<<string<<endl;

	- if ( _ntoken == _lengthoftokenlist ) {
	- int new_length = 1000 + 4 * _lengthoftokenlist;
	+ if ( m_ntoken == m_lengthoftokenlist ) {
	+ int new_length = 1000 + 4 * m_lengthoftokenlist;

	int* newlinelist = new int[new_length];
	std::string* newtokenlist = new std::string[new_length];

	int i;

	- for ( i = 0; i < _ntoken; i++ ) {
	- newlinelist[i] = _linelist[i];
	- newtokenlist[i] = _tokenlist[i];
	+ for ( i = 0; i < m_ntoken; i++ ) {
	+ newlinelist[i] = m_linelist[i];
	+ newtokenlist[i] = m_tokenlist[i];
	}

	- delete[] _tokenlist;
	- delete[] _linelist;
	+ delete[] m_tokenlist;
	+ delete[] m_linelist;

	- _tokenlist = newtokenlist;
	- _linelist = newlinelist;
	+ m_tokenlist = newtokenlist;
	+ m_linelist = newlinelist;

	- _lengthoftokenlist = new_length;
	+ m_lengthoftokenlist = new_length;
	}

	- _tokenlist[_ntoken] = string;
	+ m_tokenlist[m_ntoken] = string;

	- _linelist[_ntoken] = line;
	+ m_linelist[m_ntoken] = line;

	- _ntoken++;
	+ m_ntoken++;

	- //EvtGenReport(EVTGEN_INFO,"EvtGen") << "First:"<<_tokenlist[0]<<" last:"<<_tokenlist[_ntoken-1]<<endl;
	+ //EvtGenReport(EVTGEN_INFO,"EvtGen") << "First:"<<m_tokenlist[0]<<" last:"<<m_tokenlist[m_ntoken-1]<<endl;
	}
	diff --git a/src/EvtGenBase/EvtParserXml.cpp b/src/EvtGenBase/EvtParserXml.cpp
	--- a/src/EvtGenBase/EvtParserXml.cpp
	+++ b/src/EvtGenBase/EvtParserXml.cpp
	@@ -39,8 +39,8 @@
	return false;
	}

	- _fin.open( filename.c_str() );
	- if ( !_fin ) {
	+ m_fin.open( filename.c_str() );
	+ if ( !m_fin ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Could not open file '" << filename.c_str() << "'" << endl;
	return false;
	@@ -51,7 +51,7 @@

	bool EvtParserXml::close()
	{
	- _fin.close();
	+ m_fin.close();
	return true;
	}

	@@ -59,91 +59,91 @@
	{
	if ( !processTagTree() ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "Unexpected end tag " << _tagTitle << " found near line "
	- << _lineNo << endl;
	+ << "Unexpected end tag " << m_tagTitle << " found near line "
	+ << m_lineNo << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Will terminate execution!" << endl;
	return false;
	} //first process the previous tag to find out where we are in the tag tree

	- while ( _line.find( "<" ) ==
	+ while ( m_line.find( "<" ) ==
	std::string::npos ) { //add lines until we find start of a tag
	std::string addLine;
	- if ( !std::getline( _fin, addLine ) )
	+ if ( !std::getline( m_fin, addLine ) )
	return false;
	- _lineNo++;
	- _line += " ";
	- _line += addLine;
	+ m_lineNo++;
	+ m_line += " ";
	+ m_line += addLine;
	}

	unsigned int startTag;
	unsigned int endTag;
	unsigned int endTagTitle;

	- startTag = _line.find( "<" );
	+ startTag = m_line.find( "<" );

	- if ( _line[startTag + 1] ==
	+ if ( m_line[startTag + 1] ==
	'?' ) { //XML header tag - ignore then read the next tag
	- while ( _line.find( "?>", startTag ) == std::string::npos ) {
	+ while ( m_line.find( "?>", startTag ) == std::string::npos ) {
	std::string addLine;
	- if ( !std::getline( _fin, addLine ) )
	+ if ( !std::getline( m_fin, addLine ) )
	return false;
	- _lineNo++;
	- _line += " ";
	- _line += addLine;
	+ m_lineNo++;
	+ m_line += " ";
	+ m_line += addLine;
	}
	- endTag = _line.find( "?>", startTag );
	- _line = _line.substr( endTag + 2 );
	+ endTag = m_line.find( "?>", startTag );
	+ m_line = m_line.substr( endTag + 2 );
	return readNextTag();
	- } else if ( _line[startTag + 1] ==
	+ } else if ( m_line[startTag + 1] ==
	'!' ) { //XML comment tag - ignore then read the next tag
	- while ( _line.find( "-->", startTag ) == std::string::npos ) {
	+ while ( m_line.find( "-->", startTag ) == std::string::npos ) {
	std::string addLine;
	- if ( !std::getline( _fin, addLine ) )
	+ if ( !std::getline( m_fin, addLine ) )
	return false;
	- _lineNo++;
	- _line += " ";
	- _line += addLine;
	+ m_lineNo++;
	+ m_line += " ";
	+ m_line += addLine;
	}
	- endTag = _line.find( "-->", startTag );
	- _line = _line.substr( endTag + 3 );
	- _tagTitle = "";
	- _tag = "";
	+ endTag = m_line.find( "-->", startTag );
	+ m_line = m_line.substr( endTag + 3 );
	+ m_tagTitle = "";
	+ m_tag = "";
	return readNextTag();
	} else { //parsable

	- while ( _line.find( ">", startTag ) ==
	+ while ( m_line.find( ">", startTag ) ==
	std::string::npos ) { //find end of a tag
	std::string addLine;
	- if ( !std::getline( _fin, addLine ) )
	+ if ( !std::getline( m_fin, addLine ) )
	return false;
	- _lineNo++;
	- _line += " ";
	- _line += addLine;
	+ m_lineNo++;
	+ m_line += " ";
	+ m_line += addLine;
	}
	- endTag = _line.find( ">", startTag );
	- _inLineTag = false;
	- if ( _line.find( "/>", startTag ) < endTag ) {
	+ endTag = m_line.find( ">", startTag );
	+ m_inLineTag = false;
	+ if ( m_line.find( "/>", startTag ) < endTag ) {
	endTag--;
	- _inLineTag = true;
	+ m_inLineTag = true;
	}

	- if ( _line.find( " ", startTag ) != std::string::npos &&
	- _line.find( " ", startTag ) <
	+ if ( m_line.find( " ", startTag ) != std::string::npos &&
	+ m_line.find( " ", startTag ) <
	endTag ) { //find end of the first word in the tag
	- endTagTitle = _line.find( " ", startTag );
	+ endTagTitle = m_line.find( " ", startTag );
	} else {
	endTagTitle = endTag;
	}

	- _tagTitle = _line.substr( startTag + 1, endTagTitle - startTag - 1 );
	- _tag = _line.substr( startTag + 1, endTag - startTag - 1 );
	+ m_tagTitle = m_line.substr( startTag + 1, endTagTitle - startTag - 1 );
	+ m_tag = m_line.substr( startTag + 1, endTag - startTag - 1 );

	//now we have the tag lets remove it from the line
	- if ( _inLineTag ) {
	- _line = _line.substr( endTag + 2 );
	+ if ( m_inLineTag ) {
	+ m_line = m_line.substr( endTag + 2 );
	} else {
	- _line = _line.substr( endTag + 1 );
	+ m_line = m_line.substr( endTag + 1 );
	}
	return true;
	}
	@@ -151,10 +151,10 @@

	std::string EvtParserXml::getParentTagTitle()
	{
	- if ( _tagTree.empty() )
	+ if ( m_tagTree.empty() )
	return "";
	else
	- return _tagTree.back();
	+ return m_tagTree.back();
	}

	std::string EvtParserXml::readAttribute( std::string attribute,
	@@ -164,11 +164,11 @@
	for ( unsigned int i = 0; i < whitespace.size(); i++ ) {
	//find any whitespace followed by the attribute name followed by an '='
	std::string attName = whitespace[i] + attribute + "=";
	- if ( _tag.find( attName ) != std::string::npos ) {
	- int startAttri = _tag.find( attName );
	- int startQuote = _tag.find( "\"", startAttri + 1 );
	- int endQuote = _tag.find( "\"", startQuote + 1 );
	- return _tag.substr( startQuote + 1, endQuote - startQuote - 1 );
	+ if ( m_tag.find( attName ) != std::string::npos ) {
	+ int startAttri = m_tag.find( attName );
	+ int startQuote = m_tag.find( "\"", startAttri + 1 );
	+ int endQuote = m_tag.find( "\"", startQuote + 1 );
	+ return m_tag.substr( startQuote + 1, endQuote - startQuote - 1 );
	}
	}
	return defaultValue;
	@@ -210,16 +210,16 @@

	bool EvtParserXml::processTagTree()
	{
	- if ( _tagTitle == "" )
	+ if ( m_tagTitle == "" )
	return true;
	- if ( _tagTitle[0] == '/' ) {
	- if ( _tagTitle.substr( 1 ) == _tagTree.back() ) {
	- _tagTree.pop_back();
	+ if ( m_tagTitle[0] == '/' ) {
	+ if ( m_tagTitle.substr( 1 ) == m_tagTree.back() ) {
	+ m_tagTree.pop_back();
	} else {
	return false;
	}
	- } else if ( !_inLineTag ) {
	- _tagTree.push_back( _tagTitle );
	+ } else if ( !m_inLineTag ) {
	+ m_tagTree.push_back( m_tagTitle );
	}
	return true;
	}
	diff --git a/src/EvtGenBase/EvtPartProp.cpp b/src/EvtGenBase/EvtPartProp.cpp
	--- a/src/EvtGenBase/EvtPartProp.cpp
	+++ b/src/EvtGenBase/EvtPartProp.cpp
	@@ -34,129 +34,129 @@
	using std::fstream;

	EvtPartProp::EvtPartProp() :
	- _id( -1, -1 ), _idchgconj( -1, -1 ), _chg3( 0 ), _stdhep( 0 ), _lundkc( 0 )
	+ m_id( -1, -1 ), m_idchgconj( -1, -1 ), m_chg3( 0 ), m_stdhep( 0 ), m_lundkc( 0 )
	{
	- _ctau = 0.0;
	- _name = "*******";
	- _spintype = EvtSpinType::SCALAR;
	+ m_ctau = 0.0;
	+ m_name = "*******";
	+ m_spintype = EvtSpinType::SCALAR;
	}

	EvtPartProp::EvtPartProp( const EvtPartProp& x )
	{
	- _lineShape.reset( x._lineShape ? x._lineShape->clone() : nullptr );
	- _ctau = x._ctau;
	- _name = x._name;
	- _spintype = x._spintype;
	- _id = x._id;
	- _idchgconj = x._idchgconj;
	- _chg3 = x._chg3;
	- _stdhep = x._stdhep;
	- _lundkc = x._lundkc;
	+ m_lineShape.reset( x.m_lineShape ? x.m_lineShape->clone() : nullptr );
	+ m_ctau = x.m_ctau;
	+ m_name = x.m_name;
	+ m_spintype = x.m_spintype;
	+ m_id = x.m_id;
	+ m_idchgconj = x.m_idchgconj;
	+ m_chg3 = x.m_chg3;
	+ m_stdhep = x.m_stdhep;
	+ m_lundkc = x.m_lundkc;
	}

	void EvtPartProp::setName( std::string pname )
	{
	- _name = pname;
	+ m_name = pname;
	}

	EvtPartProp& EvtPartProp::operator=( const EvtPartProp& x )
	{
	- _lineShape.reset( x._lineShape ? x._lineShape->clone() : nullptr );
	+ m_lineShape.reset( x.m_lineShape ? x.m_lineShape->clone() : nullptr );

	- _ctau = x._ctau;
	- _name = x._name;
	- _chg3 = x._chg3;
	- _spintype = x._spintype;
	+ m_ctau = x.m_ctau;
	+ m_name = x.m_name;
	+ m_chg3 = x.m_chg3;
	+ m_spintype = x.m_spintype;
	return *this;
	}

	void EvtPartProp::initLineShape( double mass, double width, double maxRange )
	{
	- _lineShape = std::make_unique<EvtRelBreitWignerBarrierFact>( mass, width,
	- maxRange,
	- _spintype );
	+ m_lineShape = std::make_unique<EvtRelBreitWignerBarrierFact>( mass, width,
	+ maxRange,
	+ m_spintype );
	}

	void EvtPartProp::newLineShape( std::string type )
	{
	- double m = _lineShape->getMass();
	- double w = _lineShape->getWidth();
	- double mR = _lineShape->getMaxRange();
	- EvtSpinType::spintype st = _lineShape->getSpinType();
	+ double m = m_lineShape->getMass();
	+ double w = m_lineShape->getWidth();
	+ double mR = m_lineShape->getMaxRange();
	+ EvtSpinType::spintype st = m_lineShape->getSpinType();
	if ( type == "RELBW" ) {
	- _lineShape = std::make_unique<EvtRelBreitWignerBarrierFact>( m, w, mR,
	- st );
	+ m_lineShape = std::make_unique<EvtRelBreitWignerBarrierFact>( m, w, mR,
	+ st );
	} else if ( type == "NONRELBW" ) {
	- _lineShape = std::make_unique<EvtAbsLineShape>( m, w, mR, st );
	+ m_lineShape = std::make_unique<EvtAbsLineShape>( m, w, mR, st );
	} else if ( type == "FLAT" ) {
	- _lineShape = std::make_unique<EvtFlatLineShape>( m, w, mR, st );
	+ m_lineShape = std::make_unique<EvtFlatLineShape>( m, w, mR, st );
	} else if ( type == "MANYDELTAFUNC" ) {
	- _lineShape = std::make_unique<EvtManyDeltaFuncLineShape>( m, w, mR, st );
	+ m_lineShape = std::make_unique<EvtManyDeltaFuncLineShape>( m, w, mR, st );
	} else {
	- _lineShape.reset();
	+ m_lineShape.reset();
	}
	}

	void EvtPartProp::reSetMass( double mass )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->reSetMass( mass );
	+ m_lineShape->reSetMass( mass );
	}
	void EvtPartProp::reSetWidth( double width )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->reSetWidth( width );
	+ m_lineShape->reSetWidth( width );
	}

	void EvtPartProp::setPWForDecay( int spin, EvtId d1, EvtId d2 )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->setPWForDecay( spin, d1, d2 );
	+ m_lineShape->setPWForDecay( spin, d1, d2 );
	}

	void EvtPartProp::setPWForBirthL( int spin, EvtId par, EvtId othD )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->setPWForBirthL( spin, par, othD );
	+ m_lineShape->setPWForBirthL( spin, par, othD );
	}

	void EvtPartProp::reSetMassMin( double mass )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->reSetMassMin( mass );
	+ m_lineShape->reSetMassMin( mass );
	}
	void EvtPartProp::reSetMassMax( double mass )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->reSetMassMax( mass );
	+ m_lineShape->reSetMassMax( mass );
	}
	void EvtPartProp::reSetBlatt( double blatt )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->reSetBlatt( blatt );
	+ m_lineShape->reSetBlatt( blatt );
	}
	void EvtPartProp::reSetBlattBirth( double blatt )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->reSetBlattBirth( blatt );
	+ m_lineShape->reSetBlattBirth( blatt );
	}
	void EvtPartProp::includeBirthFactor( bool yesno )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->includeBirthFactor( yesno );
	+ m_lineShape->includeBirthFactor( yesno );
	}
	void EvtPartProp::includeDecayFactor( bool yesno )
	{
	- if ( !_lineShape )
	+ if ( !m_lineShape )
	::abort();
	- _lineShape->includeDecayFactor( yesno );
	+ m_lineShape->includeDecayFactor( yesno );
	}
	diff --git a/src/EvtGenBase/EvtParticle.cpp b/src/EvtGenBase/EvtParticle.cpp
	--- a/src/EvtGenBase/EvtParticle.cpp
	+++ b/src/EvtGenBase/EvtParticle.cpp
	@@ -54,117 +54,117 @@

	EvtParticle::~EvtParticle()
	{
	- delete _decayProb;
	+ delete m_decayProb;
	}

	EvtParticle::EvtParticle()
	{
	- _ndaug = 0;
	- _parent = nullptr;
	- _channel = -10;
	- _t = 0.0;
	- _genlifetime = 1;
	- _first = 1;
	- _isInit = false;
	- _validP4 = false;
	- _isDecayed = false;
	- _decayProb = nullptr;
	- _intAttributes.clear();
	- _dblAttributes.clear();
	- // _mix=false;
	+ m_ndaug = 0;
	+ m_parent = nullptr;
	+ m_channel = -10;
	+ m_t = 0.0;
	+ m_genlifetime = 1;
	+ m_first = 1;
	+ m_isInit = false;
	+ m_validP4 = false;
	+ m_isDecayed = false;
	+ m_decayProb = nullptr;
	+ m_intAttributes.clear();
	+ m_dblAttributes.clear();
	+ // m_mix=false;
	}

	void EvtParticle::setFirstOrNot()
	{
	- _first = 0;
	+ m_first = 0;
	}
	void EvtParticle::resetFirstOrNot()
	{
	- _first = 1;
	+ m_first = 1;
	}

	void EvtParticle::setChannel( int i )
	{
	- _channel = i;
	+ m_channel = i;
	}

	EvtParticle* EvtParticle::getParent() const
	{
	- return _parent;
	+ return m_parent;
	}

	void EvtParticle::setLifetime( double tau )
	{
	- _t = tau;
	+ m_t = tau;
	}

	void EvtParticle::setLifetime()
	{
	- if ( _genlifetime ) {
	- _t = -log( EvtRandom::Flat() ) * EvtPDL::getctau( getId() );
	+ if ( m_genlifetime ) {
	+ m_t = -log( EvtRandom::Flat() ) * EvtPDL::getctau( getId() );
	}
	}

	double EvtParticle::getLifetime() const
	{
	- return _t;
	+ return m_t;
	}

	void EvtParticle::addDaug( EvtParticle* node )
	{
	- node->_daug[node->_ndaug++] = this;
	- _ndaug = 0;
	- _parent = node;
	+ node->m_daug[node->m_ndaug++] = this;
	+ m_ndaug = 0;
	+ m_parent = node;
	}

	int EvtParticle::firstornot() const
	{
	- return _first;
	+ return m_first;
	}

	EvtId EvtParticle::getId() const
	{
	- return _id;
	+ return m_id;
	}

	int EvtParticle::getPDGId() const
	{
	- return EvtPDL::getStdHep( _id );
	+ return EvtPDL::getStdHep( m_id );
	}

	EvtSpinType::spintype EvtParticle::getSpinType() const
	{
	- return EvtPDL::getSpinType( _id );
	+ return EvtPDL::getSpinType( m_id );
	}

	int EvtParticle::getSpinStates() const
	{
	- return EvtSpinType::getSpinStates( EvtPDL::getSpinType( _id ) );
	+ return EvtSpinType::getSpinStates( EvtPDL::getSpinType( m_id ) );
	}

	const EvtVector4R& EvtParticle::getP4() const
	{
	- return _p;
	+ return m_p;
	}

	int EvtParticle::getChannel() const
	{
	- return _channel;
	+ return m_channel;
	}

	size_t EvtParticle::getNDaug() const
	{
	- return _ndaug;
	+ return m_ndaug;
	}

	double EvtParticle::mass() const
	{
	- return _p.mass();
	+ return m_p.mass();
	}

	void EvtParticle::setDiagonalSpinDensity()
	{
	- _rhoForward.setDiag( getSpinStates() );
	+ m_rhoForward.setDiag( getSpinStates() );
	}

	void EvtParticle::setVectorSpinDensity()
	@@ -175,7 +175,7 @@
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "spin_states:" << getSpinStates() << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "particle:" << EvtPDL::name( _id ).c_str() << endl;
	+ << "particle:" << EvtPDL::name( m_id ).c_str() << endl;
	::abort();
	}

	@@ -196,7 +196,7 @@

	int n = rho.getDim();

	- _rhoForward.setDim( n );
	+ m_rhoForward.setDim( n );

	int i, j, k, l;

	@@ -209,7 +209,7 @@
	conj( R.get( k, j ) );
	}
	}
	- _rhoForward.set( i, j, tmp );
	+ m_rhoForward.set( i, j, tmp );
	}
	}
	}
	@@ -224,7 +224,7 @@

	int n = rho.getDim();

	- _rhoForward.setDim( n );
	+ m_rhoForward.setDim( n );

	int i, j, k, l;

	@@ -237,7 +237,7 @@
	conj( R.get( k, j ) );
	}
	}
	- _rhoForward.set( i, j, tmp );
	+ m_rhoForward.set( i, j, tmp );
	}
	}
	}
	@@ -258,11 +258,11 @@
	}
	}

	- if ( _isInit ) {
	+ if ( m_isInit ) {
	//we have already been here - just reroll the masses!
	- if ( _ndaug > 0 ) {
	- for ( size_t ii = 0; ii < _ndaug; ii++ ) {
	- if ( _ndaug == 1 \|\|
	+ if ( m_ndaug > 0 ) {
	+ for ( size_t ii = 0; ii < m_ndaug; ii++ ) {
	+ if ( m_ndaug == 1 \|\|
	EvtPDL::getWidth( p->getDaug( ii )->getId() ) > 0.0000001 )
	p->getDaug( ii )->initDecay( useMinMass );
	else
	@@ -273,10 +273,10 @@

	EvtId* dauId = nullptr;
	double* dauMasses = nullptr;
	- if ( _ndaug > 0 ) {
	- dauId = new EvtId[_ndaug];
	- dauMasses = new double[_ndaug];
	- for ( size_t j = 0; j < _ndaug; j++ ) {
	+ if ( m_ndaug > 0 ) {
	+ dauId = new EvtId[m_ndaug];
	+ dauMasses = new double[m_ndaug];
	+ for ( size_t j = 0; j < m_ndaug; j++ ) {
	dauId[j] = p->getDaug( j )->getId();
	dauMasses[j] = p->getDaug( j )->mass();
	}
	@@ -293,10 +293,11 @@
	othDauId = new EvtId( tempPar->getDaug( 0 )->getId() );
	}
	}
	- if ( p->getParent() && _validP4 == false ) {
	+ if ( p->getParent() && m_validP4 == false ) {
	if ( !useMinMass ) {
	- p->setMass( EvtPDL::getRandMass( p->getId(), parId, _ndaug, dauId,
	- othDauId, parMass, dauMasses ) );
	+ p->setMass( EvtPDL::getRandMass( p->getId(), parId, m_ndaug,
	+ dauId, othDauId, parMass,
	+ dauMasses ) );
	} else
	p->setMass( EvtPDL::getMinMass( p->getId() ) );
	}
	@@ -366,8 +367,8 @@

	insertDaugPtr( 0, scalar_part );

	- _ndaug = 1;
	- _isInit = true;
	+ m_ndaug = 1;
	+ m_isInit = true;
	p = scalar_part;
	p->initDecay( useMinMass );
	return;
	@@ -432,7 +433,7 @@
	delete[] dauId;
	if ( dauMasses )
	delete[] dauMasses;
	- _isInit = true;
	+ m_isInit = true;
	}

	void EvtParticle::decay()
	@@ -458,7 +459,7 @@
	// for ( ti=0; ti<decayer->getNDaug(); ti++)
	// EvtGenReport(EVTGEN_INFO,"EvtGen") << "Daug " << ti << " " << EvtPDL::name(decayer->getDaug(ti)) << endl;
	// }
	- //if (p->_ndaug>0) {
	+ //if (p->m_ndaug>0) {
	// EvtGenReport(EVTGEN_INFO,"EvtGen") <<"Is decaying particle with daughters!!!!!"<<endl;
	// ::abort();
	//return;
	@@ -468,15 +469,15 @@
	//if there are already daughters, then this step is already done!
	// figure out the masses
	bool massTreeOK( true );
	- if ( _ndaug == 0 ) {
	+ if ( m_ndaug == 0 ) {
	massTreeOK = generateMassTree();
	}

	if ( massTreeOK == false ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Could not decay " << EvtPDL::name( p->getId() ) << " with mass "
	- << p->mass() << " to decay channel number " << _channel << endl;
	- _isDecayed = false;
	+ << p->mass() << " to decay channel number " << m_channel << endl;
	+ m_isDecayed = false;
	return;
	}

	@@ -489,8 +490,8 @@

	EvtId thisId = getId();
	// remove D0 mixing for now..
	- // if ( _ndaug==1 && (thisId==BS0\|\|thisId==BSB\|\|thisId==BD0\|\|thisId==BDB\|\|thisId==D0\|\|thisId==D0B) ) {
	- if ( _ndaug == 1 &&
	+ // if ( m_ndaug==1 && (thisId==BS0\|\|thisId==BSB\|\|thisId==BD0\|\|thisId==BDB\|\|thisId==D0\|\|thisId==D0B) ) {
	+ if ( m_ndaug == 1 &&
	( thisId == BS0 \|\| thisId == BSB \|\| thisId == BD0 \|\| thisId == BDB ) ) {
	p = p->getDaug( 0 );
	decayer = EvtDecayTable::getInstance()->getDecayFunc( p );
	@@ -499,10 +500,10 @@
	if ( decayer != nullptr ) {
	decayer->makeDecay( p );
	} else {
	- p->_rhoBackward.setDiag( p->getSpinStates() );
	+ p->m_rhoBackward.setDiag( p->getSpinStates() );
	}

	- _isDecayed = true;
	+ m_isDecayed = true;
	return;
	}

	@@ -578,7 +579,7 @@

	//If the particle already has a mass, we dont need to include
	//it in the probability calculation
	- if ( ( !p->getParent() \|\| _validP4 ) && temp > 0.0 )
	+ if ( ( !p->getParent() \|\| m_validP4 ) && temp > 0.0 )
	temp = 1.;

	delete[] dMasses;
	@@ -590,15 +591,15 @@

	void EvtParticle::deleteDaughters( bool keepChannel )
	{
	- for ( size_t i = 0; i < _ndaug; i++ ) {
	- _daug[i]->deleteTree();
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	+ m_daug[i]->deleteTree();
	}

	- _ndaug = 0;
	+ m_ndaug = 0;
	if ( !keepChannel )
	- _channel = -10;
	- _first = 1;
	- _isInit = false;
	+ m_channel = -10;
	+ m_first = 1;
	+ m_isInit = false;
	}

	void EvtParticle::deleteTree()
	@@ -774,7 +775,7 @@
	EvtVector4R temp, mom;
	const EvtParticle* ptemp;

	- temp = this->_pBeforeFSR;
	+ temp = this->m_pBeforeFSR;
	ptemp = this;

	while ( ptemp->getParent() ) {
	@@ -802,13 +803,13 @@
	return temp;
	}

	- temp = ( ptemp->_t / ptemp->mass() ) * ( ptemp->getP4() );
	+ temp = ( ptemp->m_t / ptemp->mass() ) * ( ptemp->getP4() );

	while ( ptemp->getParent() ) {
	ptemp = ptemp->getParent();
	mom = ptemp->getP4();
	temp = boostTo( temp, mom );
	- temp = temp + ( ptemp->_t / ptemp->mass() ) * ( ptemp->getP4() );
	+ temp = temp + ( ptemp->m_t / ptemp->mass() ) * ( ptemp->getP4() );
	}

	return temp;
	@@ -822,31 +823,30 @@
	current = this;
	size_t i;

	- if ( _ndaug != 0 )
	- return _daug[0];
	+ if ( m_ndaug != 0 )
	+ return m_daug[0];

	do {
	- bpart = current->_parent;
	+ bpart = current->m_parent;
	if ( !bpart ) {
	return nullptr;
	}
	i = 0;
	- while ( bpart->_daug[i] != current ) {
	+ while ( bpart->m_daug[i] != current ) {
	i++;
	}

	if ( bpart == rootOfTree ) {
	- if ( i + 1 == bpart->_ndaug ) {
	+ if ( i + 1 == bpart->m_ndaug ) {
	return nullptr;
	}
	}

	i++;
	current = bpart;
	+ } while ( i >= bpart->m_ndaug );

	- } while ( i >= bpart->_ndaug );
	-
	- return bpart->_daug[i];
	+ return bpart->m_daug[i];
	}

	void EvtParticle::makeStdHep( EvtStdHep& stdhep, EvtSecondary& secondary,
	@@ -869,13 +869,14 @@
	ii++;
	}

	- for ( size_t i = 0; i < _ndaug; i++ ) {
	- stdhep.createParticle( _daug[i]->getP4Lab(), _daug[i]->get4Pos(), 0, 0,
	- EvtPDL::getStdHep( _daug[i]->getId() ) );
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	+ stdhep.createParticle( m_daug[i]->getP4Lab(), m_daug[i]->get4Pos(), 0,
	+ 0, EvtPDL::getStdHep( m_daug[i]->getId() ) );
	}

	- for ( size_t i = 0; i < _ndaug; i++ ) {
	- _daug[i]->makeStdHepRec( 1 + i, 1 + i, stdhep, secondary, list_of_stable );
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	+ m_daug[i]->makeStdHepRec( 1 + i, 1 + i, stdhep, secondary,
	+ list_of_stable );
	}
	return;
	}
	@@ -886,13 +887,13 @@
	stdhep.createParticle( getP4Lab(), get4Pos(), -1, -1,
	EvtPDL::getStdHep( getId() ) );

	- for ( size_t i = 0; i < _ndaug; i++ ) {
	- stdhep.createParticle( _daug[i]->getP4Lab(), _daug[i]->get4Pos(), 0, 0,
	- EvtPDL::getStdHep( _daug[i]->getId() ) );
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	+ stdhep.createParticle( m_daug[i]->getP4Lab(), m_daug[i]->get4Pos(), 0,
	+ 0, EvtPDL::getStdHep( m_daug[i]->getId() ) );
	}

	- for ( size_t i = 0; i < _ndaug; i++ ) {
	- _daug[i]->makeStdHepRec( 1 + i, 1 + i, stdhep );
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	+ m_daug[i]->makeStdHepRec( 1 + i, 1 + i, stdhep );
	}
	return;
	}
	@@ -915,15 +916,15 @@
	}

	int parent_num = stdhep.getNPart();
	- for ( size_t i = 0; i < _ndaug; i++ ) {
	- stdhep.createParticle( _daug[i]->getP4Lab(), _daug[i]->get4Pos(),
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	+ stdhep.createParticle( m_daug[i]->getP4Lab(), m_daug[i]->get4Pos(),
	firstparent, lastparent,
	- EvtPDL::getStdHep( _daug[i]->getId() ) );
	+ EvtPDL::getStdHep( m_daug[i]->getId() ) );
	}

	- for ( size_t i = 0; i < _ndaug; i++ ) {
	- _daug[i]->makeStdHepRec( parent_num + i, parent_num + i, stdhep,
	- secondary, list_of_stable );
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	+ m_daug[i]->makeStdHepRec( parent_num + i, parent_num + i, stdhep,
	+ secondary, list_of_stable );
	}
	return;
	}
	@@ -932,14 +933,14 @@
	EvtStdHep& stdhep )
	{
	int parent_num = stdhep.getNPart();
	- for ( size_t i = 0; i < _ndaug; i++ ) {
	- stdhep.createParticle( _daug[i]->getP4Lab(), _daug[i]->get4Pos(),
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	+ stdhep.createParticle( m_daug[i]->getP4Lab(), m_daug[i]->get4Pos(),
	firstparent, lastparent,
	- EvtPDL::getStdHep( _daug[i]->getId() ) );
	+ EvtPDL::getStdHep( m_daug[i]->getId() ) );
	}

	- for ( size_t i = 0; i < _ndaug; i++ ) {
	- _daug[i]->makeStdHepRec( parent_num + i, parent_num + i, stdhep );
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	+ m_daug[i]->makeStdHepRec( parent_num + i, parent_num + i, stdhep );
	}
	return;
	}
	@@ -949,26 +950,26 @@
	size_t newlevel, i;
	newlevel = level + 1;

	- if ( _ndaug != 0 ) {
	+ if ( m_ndaug != 0 ) {
	if ( level > 0 ) {
	for ( i = 0; i < ( 5 * level ); i++ ) {
	EvtGenReport( EVTGEN_INFO, "" ) << " ";
	}
	}
	- EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::name( _id ).c_str();
	+ EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::name( m_id ).c_str();
	EvtGenReport( EVTGEN_INFO, "" ) << " -> ";
	- for ( i = 0; i < _ndaug; i++ ) {
	+ for ( i = 0; i < m_ndaug; i++ ) {
	EvtGenReport( EVTGEN_INFO, "" )
	- << EvtPDL::name( _daug[i]->getId() ).c_str() << " ";
	+ << EvtPDL::name( m_daug[i]->getId() ).c_str() << " ";
	}
	- for ( i = 0; i < _ndaug; i++ ) {
	+ for ( i = 0; i < m_ndaug; i++ ) {
	EvtGenReport( EVTGEN_INFO, "" )
	- << _daug[i]->mass() << " " << _daug[i]->getP4() << " "
	- << _daug[i]->getSpinStates() << "; ";
	+ << m_daug[i]->mass() << " " << m_daug[i]->getP4() << " "
	+ << m_daug[i]->getSpinStates() << "; ";
	}
	EvtGenReport( EVTGEN_INFO, "" ) << endl;
	- for ( i = 0; i < _ndaug; i++ ) {
	- _daug[i]->printTreeRec( newlevel );
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ m_daug[i]->printTreeRec( newlevel );
	}
	}
	}
	@@ -978,7 +979,7 @@
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "This is the current decay chain" << endl;
	EvtGenReport( EVTGEN_INFO, "" )
	- << "This top particle is " << EvtPDL::name( _id ).c_str() << " "
	+ << "This top particle is " << EvtPDL::name( m_id ).c_str() << " "
	<< this->mass() << " " << this->getP4() << endl;

	this->printTreeRec( 0 );
	@@ -992,14 +993,14 @@

	std::string retval = "";

	- for ( i = 0; i < _ndaug; i++ ) {
	- retval += EvtPDL::name( _daug[i]->getId() );
	- if ( _daug[i]->getNDaug() > 0 ) {
	+ for ( i = 0; i < m_ndaug; i++ ) {
	+ retval += EvtPDL::name( m_daug[i]->getId() );
	+ if ( m_daug[i]->getNDaug() > 0 ) {
	retval += " (";
	- retval += _daug[i]->treeStrRec( newlevel );
	+ retval += m_daug[i]->treeStrRec( newlevel );
	retval += ") ";
	} else {
	- if ( i + 1 != _ndaug )
	+ if ( i + 1 != m_ndaug )
	retval += " ";
	}
	}
	@@ -1009,7 +1010,7 @@

	std::string EvtParticle::treeStr() const
	{
	- std::string retval = EvtPDL::name( _id );
	+ std::string retval = EvtPDL::name( m_id );
	retval += " -> ";

	retval += treeStrRec( 0 );
	@@ -1019,38 +1020,38 @@

	void EvtParticle::printParticle() const
	{
	- switch ( EvtPDL::getSpinType( _id ) ) {
	+ switch ( EvtPDL::getSpinType( m_id ) ) {
	case EvtSpinType::SCALAR:
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "This is a scalar particle:" << EvtPDL::name( _id ).c_str()
	+ << "This is a scalar particle:" << EvtPDL::name( m_id ).c_str()
	<< "\n";
	break;
	case EvtSpinType::VECTOR:
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "This is a vector particle:" << EvtPDL::name( _id ).c_str()
	+ << "This is a vector particle:" << EvtPDL::name( m_id ).c_str()
	<< "\n";
	break;
	case EvtSpinType::TENSOR:
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "This is a tensor particle:" << EvtPDL::name( _id ).c_str()
	+ << "This is a tensor particle:" << EvtPDL::name( m_id ).c_str()
	<< "\n";
	break;
	case EvtSpinType::DIRAC:
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "This is a dirac particle:" << EvtPDL::name( _id ).c_str()
	+ << "This is a dirac particle:" << EvtPDL::name( m_id ).c_str()
	<< "\n";
	break;
	case EvtSpinType::PHOTON:
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "This is a photon:" << EvtPDL::name( _id ).c_str() << "\n";
	+ << "This is a photon:" << EvtPDL::name( m_id ).c_str() << "\n";
	break;
	case EvtSpinType::NEUTRINO:
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "This is a neutrino:" << EvtPDL::name( _id ).c_str() << "\n";
	+ << "This is a neutrino:" << EvtPDL::name( m_id ).c_str() << "\n";
	break;
	case EvtSpinType::STRING:
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "This is a string:" << EvtPDL::name( _id ).c_str() << "\n";
	+ << "This is a string:" << EvtPDL::name( m_id ).c_str() << "\n";
	break;
	default:
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -1059,7 +1060,7 @@
	break;
	}
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "Number of daughters:" << _ndaug << "\n";
	+ << "Number of daughters:" << m_ndaug << "\n";
	}

	void init_vector( EvtParticle** part )
	@@ -1097,14 +1098,13 @@
	*part = new EvtStringParticle;
	}

	-double EvtParticle::initializePhaseSpace( unsigned int numdaughter,
	- EvtId* daughters,
	+double EvtParticle::initializePhaseSpace( size_t numdaughter, EvtId* daughters,
	bool forceDaugMassReset,
	double poleSize, int whichTwo1,
	int whichTwo2 )
	{
	double m_b;
	- unsigned int i;
	+ size_t i;
	//lange
	// this->makeDaughters(numdaughter,daughters);

	@@ -1209,13 +1209,12 @@
	return weight;
	}

	-void EvtParticle::makeDaughters( unsigned int ndaugstore,
	- std::vector<EvtId> idVector )
	+void EvtParticle::makeDaughters( size_t ndaugstore, std::vector<EvtId> idVector )
	{
	// Convert the STL vector method to use the array method for now, since the
	// array method pervades most of the EvtGen code...

	- unsigned int nVector = idVector.size();
	+ size_t nVector = idVector.size();
	if ( nVector < ndaugstore ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Asking to make " << ndaugstore << " daughters when there "
	@@ -1224,8 +1223,7 @@
	}

	EvtId* idArray = new EvtId[ndaugstore];
	- unsigned int i;
	- for ( i = 0; i < ndaugstore; i++ ) {
	+ for ( size_t i = 0; i < ndaugstore; i++ ) {
	idArray[i] = idVector[i];
	}

	@@ -1234,21 +1232,20 @@
	delete[] idArray;
	}

	-void EvtParticle::makeDaughters( unsigned int ndaugstore, EvtId* id )
	+void EvtParticle::makeDaughters( size_t ndaugstore, EvtId* id )
	{
	- unsigned int i;
	- if ( _channel < 0 ) {
	+ if ( m_channel < 0 ) {
	setChannel( 0 );
	}
	EvtParticle* pdaug;
	- if ( _ndaug != 0 ) {
	- if ( _ndaug != ndaugstore ) {
	+ if ( m_ndaug != 0 ) {
	+ if ( m_ndaug != ndaugstore ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Asking to make a different number of "
	<< "daughters than what was previously created." << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "Original parent:" << EvtPDL::name( _id ) << endl;
	- for ( size_t i = 0; i < _ndaug; i++ ) {
	+ << "Original parent:" << EvtPDL::name( m_id ) << endl;
	+ for ( size_t i = 0; i < m_ndaug; i++ ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Original daugther:"
	<< EvtPDL::name( getDaug( i )->getId() ) << endl;
	@@ -1261,7 +1258,7 @@
	::abort();
	}
	} else {
	- for ( i = 0; i < ndaugstore; i++ ) {
	+ for ( size_t i = 0; i < ndaugstore; i++ ) {
	pdaug = EvtParticleFactory::particleFactory(
	EvtPDL::getSpinType( id[i] ) );
	pdaug->setId( id[i] );
	@@ -1273,14 +1270,14 @@

	void EvtParticle::setDecayProb( double prob )
	{
	- if ( _decayProb == nullptr )
	- _decayProb = new double;
	- *_decayProb = prob;
	+ if ( m_decayProb == nullptr )
	+ m_decayProb = new double;
	+ *m_decayProb = prob;
	}

	std::string EvtParticle::getName() const
	{
	- std::string theName = _id.getName();
	+ std::string theName = m_id.getName();
	return theName;
	}

	@@ -1293,7 +1290,7 @@

	EvtAttIntMap::const_iterator mapIter;

	- if ( ( mapIter = _intAttributes.find( attName ) ) != _intAttributes.end() ) {
	+ if ( ( mapIter = m_intAttributes.find( attName ) ) != m_intAttributes.end() ) {
	attValue = mapIter->second;
	}

	@@ -1309,7 +1306,7 @@

	EvtAttDblMap::const_iterator mapIter;

	- if ( ( mapIter = _dblAttributes.find( attName ) ) != _dblAttributes.end() ) {
	+ if ( ( mapIter = m_dblAttributes.find( attName ) ) != m_dblAttributes.end() ) {
	attValue = mapIter->second;
	}

	diff --git a/src/EvtGenBase/EvtParticleDecay.cpp b/src/EvtGenBase/EvtParticleDecay.cpp
	--- a/src/EvtGenBase/EvtParticleDecay.cpp
	+++ b/src/EvtGenBase/EvtParticleDecay.cpp
	@@ -36,37 +36,39 @@
	using std::fstream;
	void EvtParticleDecay::printSummary()
	{
	- if ( _decay != nullptr )
	- _decay->printSummary();
	+ if ( m_decay != nullptr ) {
	+ m_decay->printSummary();
	+ }
	}

	void EvtParticleDecay::chargeConj( EvtParticleDecay* decay )
	{
	- _brfrsum = decay->_brfrsum;
	- _massmin = decay->_massmin;
	+ m_brfrsum = decay->m_brfrsum;
	+ m_massmin = decay->m_massmin;

	- _decay = decay->_decay->clone();
	+ m_decay = decay->m_decay->clone();

	- int ndaug = decay->_decay->getNDaug();
	- int narg = decay->_decay->getNArg();
	- double brfr = decay->_decay->getBranchingFraction();
	- std::string name = decay->_decay->getName();
	- EvtId ipar = EvtPDL::chargeConj( decay->_decay->getParentId() );
	+ int ndaug = decay->m_decay->getNDaug();
	+ int narg = decay->m_decay->getNArg();
	+ double brfr = decay->m_decay->getBranchingFraction();
	+ std::string name = decay->m_decay->getName();
	+ EvtId ipar = EvtPDL::chargeConj( decay->m_decay->getParentId() );
	int i;
	EvtId* daug = new EvtId[ndaug];
	for ( i = 0; i < ndaug; i++ ) {
	- daug[i] = EvtPDL::chargeConj( decay->_decay->getDaug( i ) );
	+ daug[i] = EvtPDL::chargeConj( decay->m_decay->getDaug( i ) );
	}
	//Had to add 1 to make sure the vector is not empty!
	std::vector<std::string> args;
	for ( i = 0; i < narg; i++ ) {
	- args.push_back( decay->_decay->getArgStr( i ) );
	+ args.push_back( decay->m_decay->getArgStr( i ) );
	}

	- _decay->saveDecayInfo( ipar, ndaug, daug, narg, args, name, brfr );
	+ m_decay->saveDecayInfo( ipar, ndaug, daug, narg, args, name, brfr );

	- if ( decay->_decay->getFSR() )
	- _decay->setFSR();
	+ if ( decay->m_decay->getFSR() ) {
	+ m_decay->setFSR();
	+ }

	delete[] daug;
	}
	diff --git a/src/EvtGenBase/EvtParticleDecayList.cpp b/src/EvtGenBase/EvtParticleDecayList.cpp
	--- a/src/EvtGenBase/EvtParticleDecayList.cpp
	+++ b/src/EvtGenBase/EvtParticleDecayList.cpp
	@@ -36,15 +36,15 @@

	EvtParticleDecayList::EvtParticleDecayList( const EvtParticleDecayList& o )
	{
	- _nmode = o._nmode;
	- _rawbrfrsum = o._rawbrfrsum;
	- _decaylist = new EvtParticleDecayPtr[_nmode];
	+ m_nmode = o.m_nmode;
	+ m_rawbrfrsum = o.m_rawbrfrsum;
	+ m_decaylist = new EvtParticleDecayPtr[m_nmode];

	int i;
	- for ( i = 0; i < _nmode; i++ ) {
	- _decaylist[i] = new EvtParticleDecay;
	+ for ( i = 0; i < m_nmode; i++ ) {
	+ m_decaylist[i] = new EvtParticleDecay;

	- EvtDecayBase* tModel = o._decaylist[i]->getDecayModel();
	+ EvtDecayBase* tModel = o.m_decaylist[i]->getDecayModel();

	EvtDecayBase* tModelNew = tModel->clone();
	if ( tModel->getFSR() ) {
	@@ -65,50 +65,50 @@
	tModel->getDaugs(), tModel->getNArg(), args,
	tModel->getModelName(),
	tModel->getBranchingFraction() );
	- _decaylist[i]->setDecayModel( tModelNew );
	+ m_decaylist[i]->setDecayModel( tModelNew );

	- _decaylist[i]->setBrfrSum( o._decaylist[i]->getBrfrSum() );
	- _decaylist[i]->setMassMin( o._decaylist[i]->getMassMin() );
	+ m_decaylist[i]->setBrfrSum( o.m_decaylist[i]->getBrfrSum() );
	+ m_decaylist[i]->setMassMin( o.m_decaylist[i]->getMassMin() );
	}
	}

	EvtParticleDecayList::~EvtParticleDecayList()
	{
	int i;
	- for ( i = 0; i < _nmode; i++ ) {
	- delete _decaylist[i];
	+ for ( i = 0; i < m_nmode; i++ ) {
	+ delete m_decaylist[i];
	}

	- if ( _decaylist != nullptr )
	- delete[] _decaylist;
	+ if ( m_decaylist != nullptr )
	+ delete[] m_decaylist;
	}

	void EvtParticleDecayList::printSummary()
	{
	int i;
	- for ( i = 0; i < _nmode; i++ ) {
	- _decaylist[i]->printSummary();
	+ for ( i = 0; i < m_nmode; i++ ) {
	+ m_decaylist[i]->printSummary();
	}
	}

	void EvtParticleDecayList::removeDecay()
	{
	int i;
	- for ( i = 0; i < _nmode; i++ ) {
	- delete _decaylist[i];
	+ for ( i = 0; i < m_nmode; i++ ) {
	+ delete m_decaylist[i];
	}

	- delete[] _decaylist;
	- _decaylist = nullptr;
	- _nmode = 0;
	- _rawbrfrsum = 0.0;
	+ delete[] m_decaylist;
	+ m_decaylist = nullptr;
	+ m_nmode = 0;
	+ m_rawbrfrsum = 0.0;
	}

	EvtDecayBase* EvtParticleDecayList::getDecayModel( int imode )
	{
	EvtDecayBase* theModel( nullptr );
	- if ( imode >= 0 && imode < _nmode ) {
	- EvtParticleDecay* theDecay = _decaylist[imode];
	+ if ( imode >= 0 && imode < m_nmode ) {
	+ EvtParticleDecay* theDecay = m_decaylist[imode];
	if ( theDecay != nullptr ) {
	theModel = theDecay->getDecayModel();
	}
	@@ -213,65 +213,65 @@

	void EvtParticleDecayList::setNMode( int nmode )
	{
	- EvtParticleDecayPtr* _decaylist_new = new EvtParticleDecayPtr[nmode];
	+ EvtParticleDecayPtr* m_decaylist_new = new EvtParticleDecayPtr[nmode];

	- if ( _nmode != 0 ) {
	+ if ( m_nmode != 0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "Error _nmode not equal to zero!!!" << endl;
	+ << "Error m_nmode not equal to zero!!!" << endl;
	::abort();
	}
	- if ( _decaylist != nullptr ) {
	- delete[] _decaylist;
	+ if ( m_decaylist != nullptr ) {
	+ delete[] m_decaylist;
	}
	- _decaylist = _decaylist_new;
	- _nmode = nmode;
	+ m_decaylist = m_decaylist_new;
	+ m_nmode = nmode;
	}

	EvtParticleDecay& EvtParticleDecayList::getDecay( int nchannel ) const
	{
	- if ( nchannel >= _nmode ) {
	+ if ( nchannel >= m_nmode ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "Error getting channel:" << nchannel << " with only " << _nmode
	+ << "Error getting channel:" << nchannel << " with only " << m_nmode
	<< " stored!" << endl;
	::abort();
	}
	- return *( _decaylist[nchannel] );
	+ return *( m_decaylist[nchannel] );
	}

	void EvtParticleDecayList::makeChargeConj( EvtParticleDecayList* conjDecayList )
	{
	- _rawbrfrsum = conjDecayList->_rawbrfrsum;
	+ m_rawbrfrsum = conjDecayList->m_rawbrfrsum;

	- setNMode( conjDecayList->_nmode );
	+ setNMode( conjDecayList->m_nmode );

	int i;

	- for ( i = 0; i < _nmode; i++ ) {
	- _decaylist[i] = new EvtParticleDecay;
	- _decaylist[i]->chargeConj( conjDecayList->_decaylist[i] );
	+ for ( i = 0; i < m_nmode; i++ ) {
	+ m_decaylist[i] = new EvtParticleDecay;
	+ m_decaylist[i]->chargeConj( conjDecayList->m_decaylist[i] );
	}
	}

	void EvtParticleDecayList::addMode( EvtDecayBase* decay, double brfrsum,
	double massmin )
	{
	- EvtParticleDecayPtr* newlist = new EvtParticleDecayPtr[_nmode + 1];
	+ EvtParticleDecayPtr* newlist = new EvtParticleDecayPtr[m_nmode + 1];

	int i;
	- for ( i = 0; i < _nmode; i++ ) {
	- newlist[i] = _decaylist[i];
	+ for ( i = 0; i < m_nmode; i++ ) {
	+ newlist[i] = m_decaylist[i];
	}

	- _rawbrfrsum = brfrsum;
	+ m_rawbrfrsum = brfrsum;

	- newlist[_nmode] = new EvtParticleDecay;
	+ newlist[m_nmode] = new EvtParticleDecay;

	- newlist[_nmode]->setDecayModel( decay );
	- newlist[_nmode]->setBrfrSum( brfrsum );
	- newlist[_nmode]->setMassMin( massmin );
	+ newlist[m_nmode]->setDecayModel( decay );
	+ newlist[m_nmode]->setBrfrSum( brfrsum );
	+ newlist[m_nmode]->setMassMin( massmin );

	- EvtDecayBase* newDec = newlist[_nmode]->getDecayModel();
	- for ( i = 0; i < _nmode; i++ ) {
	+ EvtDecayBase* newDec = newlist[m_nmode]->getDecayModel();
	+ for ( i = 0; i < m_nmode; i++ ) {
	if ( newDec->matchingDecay( *( newlist[i]->getDecayModel() ) ) ) {
	//sometimes its ok..
	if ( newDec->getModelName() == "JETSET" \|\|
	@@ -300,41 +300,41 @@
	}
	}

	- if ( _nmode != 0 ) {
	- delete[] _decaylist;
	+ if ( m_nmode != 0 ) {
	+ delete[] m_decaylist;
	}

	- if ( ( _nmode == 0 ) && ( _decaylist != nullptr ) )
	- delete[] _decaylist;
	+ if ( ( m_nmode == 0 ) && ( m_decaylist != nullptr ) )
	+ delete[] m_decaylist;

	- _nmode++;
	+ m_nmode++;

	- _decaylist = newlist;
	+ m_decaylist = newlist;
	}

	void EvtParticleDecayList::finalize()
	{
	- if ( _nmode > 0 ) {
	- if ( _rawbrfrsum < 0.000001 ) {
	+ if ( m_nmode > 0 ) {
	+ if ( m_rawbrfrsum < 0.000001 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Please give me a "
	<< "branching fraction sum greater than 0\n";
	assert( 0 );
	}
	- if ( fabs( _rawbrfrsum - 1.0 ) > 0.0001 ) {
	+ if ( fabs( m_rawbrfrsum - 1.0 ) > 0.0001 ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Warning, sum of branching fractions for "
	- << EvtPDL::name( _decaylist[0]->getDecayModel()->getParentId() )
	+ << EvtPDL::name( m_decaylist[0]->getDecayModel()->getParentId() )
	.c_str()
	- << " is " << _rawbrfrsum << endl;
	+ << " is " << m_rawbrfrsum << endl;
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "rescaled to one! " << endl;
	}

	int i;

	- for ( i = 0; i < _nmode; i++ ) {
	- double brfrsum = _decaylist[i]->getBrfrSum() / _rawbrfrsum;
	- _decaylist[i]->setBrfrSum( brfrsum );
	+ for ( i = 0; i < m_nmode; i++ ) {
	+ double brfrsum = m_decaylist[i]->getBrfrSum() / m_rawbrfrsum;
	+ m_decaylist[i]->setBrfrSum( brfrsum );
	}
	}
	}
	@@ -343,15 +343,15 @@
	{
	if ( this != &o ) {
	removeDecay();
	- _nmode = o._nmode;
	- _rawbrfrsum = o._rawbrfrsum;
	- _decaylist = new EvtParticleDecayPtr[_nmode];
	+ m_nmode = o.m_nmode;
	+ m_rawbrfrsum = o.m_rawbrfrsum;
	+ m_decaylist = new EvtParticleDecayPtr[m_nmode];

	int i;
	- for ( i = 0; i < _nmode; i++ ) {
	- _decaylist[i] = new EvtParticleDecay;
	+ for ( i = 0; i < m_nmode; i++ ) {
	+ m_decaylist[i] = new EvtParticleDecay;

	- EvtDecayBase* tModel = o._decaylist[i]->getDecayModel();
	+ EvtDecayBase* tModel = o.m_decaylist[i]->getDecayModel();

	EvtDecayBase* tModelNew = tModel->clone();
	if ( tModel->getFSR() ) {
	@@ -372,11 +372,11 @@
	tModel->getDaugs(), tModel->getNArg(),
	args, tModel->getModelName(),
	tModel->getBranchingFraction() );
	- _decaylist[i]->setDecayModel( tModelNew );
	+ m_decaylist[i]->setDecayModel( tModelNew );

	- //_decaylist[i]->setDecayModel(tModel);
	- _decaylist[i]->setBrfrSum( o._decaylist[i]->getBrfrSum() );
	- _decaylist[i]->setMassMin( o._decaylist[i]->getMassMin() );
	+ //m_decaylist[i]->setDecayModel(tModel);
	+ m_decaylist[i]->setBrfrSum( o.m_decaylist[i]->getBrfrSum() );
	+ m_decaylist[i]->setMassMin( o.m_decaylist[i]->getMassMin() );
	}
	}
	return *this;
	@@ -390,8 +390,8 @@
	int i;
	double match_bf;

	- for ( i = 0; i < _nmode; i++ ) {
	- if ( decay->matchingDecay( *( _decaylist[i]->getDecayModel() ) ) ) {
	+ for ( i = 0; i < m_nmode; i++ ) {
	+ if ( decay->matchingDecay( *( m_decaylist[i]->getDecayModel() ) ) ) {
	match = i;
	}
	}
	@@ -409,14 +409,14 @@
	}

	if ( match == 0 ) {
	- match_bf = _decaylist[match]->getBrfrSum();
	+ match_bf = m_decaylist[match]->getBrfrSum();
	} else {
	- match_bf = ( _decaylist[match]->getBrfrSum() -
	- _decaylist[match - 1]->getBrfrSum() );
	+ match_bf = ( m_decaylist[match]->getBrfrSum() -
	+ m_decaylist[match - 1]->getBrfrSum() );
	}

	double divisor = 1 - match_bf;
	- if ( divisor < 0.000001 && _nmode > 1 ) {
	+ if ( divisor < 0.000001 && m_nmode > 1 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Removing requested mode leaves "
	<< EvtPDL::name( decay->getParentId() ).c_str()
	@@ -425,26 +425,26 @@
	::abort();
	}

	- EvtParticleDecayPtr* newlist = new EvtParticleDecayPtr[_nmode - 1];
	+ EvtParticleDecayPtr* newlist = new EvtParticleDecayPtr[m_nmode - 1];

	for ( i = 0; i < match; i++ ) {
	- newlist[i] = _decaylist[i];
	+ newlist[i] = m_decaylist[i];
	newlist[i]->setBrfrSum( newlist[i]->getBrfrSum() / divisor );
	}
	- for ( i = match + 1; i < _nmode; i++ ) {
	- newlist[i - 1] = _decaylist[i];
	+ for ( i = match + 1; i < m_nmode; i++ ) {
	+ newlist[i - 1] = m_decaylist[i];
	newlist[i - 1]->setBrfrSum(
	( newlist[i - 1]->getBrfrSum() - match_bf ) / divisor );
	}

	- delete[] _decaylist;
	+ delete[] m_decaylist;

	- _nmode--;
	+ m_nmode--;

	- _decaylist = newlist;
	+ m_decaylist = newlist;

	- if ( _nmode == 0 ) {
	- delete[] _decaylist;
	+ if ( m_nmode == 0 ) {
	+ delete[] m_decaylist;
	}
	}

	diff --git a/src/EvtGenBase/EvtPhotonParticle.cpp b/src/EvtGenBase/EvtPhotonParticle.cpp
	--- a/src/EvtGenBase/EvtPhotonParticle.cpp
	+++ b/src/EvtGenBase/EvtPhotonParticle.cpp
	@@ -38,7 +38,7 @@
	void EvtPhotonParticle::init( EvtId part_n, double e, double px, double py,
	double pz )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( e, px, py, pz );
	setpart_num( part_n );

	diff --git a/src/EvtGenBase/EvtPoint1D.cpp b/src/EvtGenBase/EvtPoint1D.cpp
	--- a/src/EvtGenBase/EvtPoint1D.cpp
	+++ b/src/EvtGenBase/EvtPoint1D.cpp
	@@ -25,24 +25,24 @@
	#include <stdio.h>

	EvtPoint1D::EvtPoint1D() :
	- _min( 0. ), _max( -1. ), _value( 0. ), _valid( false )
	+ m_min( 0. ), m_max( -1. ), m_value( 0. ), m_valid( false )
	{
	}

	EvtPoint1D::EvtPoint1D( double value ) :
	- _min( 0. ), _max( -1. ), _value( value ), _valid( true )
	+ m_min( 0. ), m_max( -1. ), m_value( value ), m_valid( true )
	{
	}

	EvtPoint1D::EvtPoint1D( double min, double max, double value ) :
	- _min( min ),
	- _max( max ),
	- _value( value ),
	- _valid( ( _min <= _value && _value <= _max ) ? true : false )
	+ m_min( min ),
	+ m_max( max ),
	+ m_value( value ),
	+ m_valid( ( m_min <= m_value && m_value <= m_max ) ? true : false )
	{
	}

	void EvtPoint1D::print() const
	{
	- printf( "%f (%f : %f)\n", _value, _min, _max );
	+ printf( "%f (%f : %f)\n", m_value, m_min, m_max );
	}
	diff --git a/src/EvtGenBase/EvtPropBreitWigner.cpp b/src/EvtGenBase/EvtPropBreitWigner.cpp
	--- a/src/EvtGenBase/EvtPropBreitWigner.cpp
	+++ b/src/EvtGenBase/EvtPropBreitWigner.cpp
	@@ -38,7 +38,7 @@
	EvtComplex EvtPropBreitWigner::amplitude( const EvtPoint1D& x ) const
	{
	double m = x.value();
	- EvtComplex value = sqrt( _g0 / EvtConst::twoPi ) /
	- ( m - _m0 - EvtComplex( 0.0, _g0 / 2. ) );
	+ EvtComplex value = sqrt( m_g0 / EvtConst::twoPi ) /
	+ ( m - m_m0 - EvtComplex( 0.0, m_g0 / 2. ) );
	return value;
	}
	diff --git a/src/EvtGenBase/EvtPropBreitWignerRel.cpp b/src/EvtGenBase/EvtPropBreitWignerRel.cpp
	--- a/src/EvtGenBase/EvtPropBreitWignerRel.cpp
	+++ b/src/EvtGenBase/EvtPropBreitWignerRel.cpp
	@@ -37,5 +37,5 @@
	EvtComplex EvtPropBreitWignerRel::amplitude( const EvtPoint1D& x ) const
	{
	double m = x.value();
	- return 1. / ( _m0 * _m0 - m * m - EvtComplex( 0., _m0 * _g0 ) );
	+ return 1. / ( m_m0 * m_m0 - m * m - EvtComplex( 0., m_m0 * m_g0 ) );
	}
	diff --git a/src/EvtGenBase/EvtPropFlatte.cpp b/src/EvtGenBase/EvtPropFlatte.cpp
	--- a/src/EvtGenBase/EvtPropFlatte.cpp
	+++ b/src/EvtGenBase/EvtPropFlatte.cpp
	@@ -30,11 +30,11 @@
	EvtPropFlatte::EvtPropFlatte( double m0, double g0, double m0a, double m0b,
	double g1, double m1a, double m1b ) :
	EvtPropagator( m0, g0 ),
	- _m0a( m0a ),
	- _m0b( m0b ),
	- _g1( g1 ),
	- _m1a( m1a ),
	- _m1b( m1b )
	+ m_m0a( m0a ),
	+ m_m0b( m0b ),
	+ m_g1( g1 ),
	+ m_m1a( m1a ),
	+ m_m1b( m1b )
	{
	}

	@@ -72,21 +72,21 @@
	double s = x.value() * x.value();
	double m = x.value();

	- double E0a = 0.5 * ( s + _m0a * _m0a - _m0b * _m0b ) / m;
	- double qSq0 = E0a * E0a - _m0a * _m0a;
	+ double E0a = 0.5 * ( s + m_m0a * m_m0a - m_m0b * m_m0b ) / m;
	+ double qSq0 = E0a * E0a - m_m0a * m_m0a;

	- double E1a = 0.5 * ( s + _m1a * _m1a - _m1b * _m1b ) / m;
	- double qSq1 = E1a * E1a - _m1a * _m1a;
	+ double E1a = 0.5 * ( s + m_m1a * m_m1a - m_m1b * m_m1b ) / m;
	+ double qSq1 = E1a * E1a - m_m1a * m_m1a;

	- EvtComplex gamma0 = qSq0 >= 0 ? EvtComplex( _g0 * sqrt( qSq0 ), 0 )
	- : EvtComplex( 0, _g0 * sqrt( -qSq0 ) );
	- EvtComplex gamma1 = qSq1 >= 0 ? EvtComplex( _g1 * sqrt( qSq1 ), 0 )
	- : EvtComplex( 0, _g1 * sqrt( -qSq1 ) );
	+ EvtComplex gamma0 = qSq0 >= 0 ? EvtComplex( m_g0 * sqrt( qSq0 ), 0 )
	+ : EvtComplex( 0, m_g0 * sqrt( -qSq0 ) );
	+ EvtComplex gamma1 = qSq1 >= 0 ? EvtComplex( m_g1 * sqrt( qSq1 ), 0 )
	+ : EvtComplex( 0, m_g1 * sqrt( -qSq1 ) );

	EvtComplex gamma = gamma0 + gamma1;

	EvtComplex a = 1.0 /
	- ( _m0 * _m0 - s - EvtComplex( 0.0, 2 * _m0 / m ) * gamma );
	+ ( m_m0 * m_m0 - s - EvtComplex( 0.0, 2 * m_m0 / m ) * gamma );

	return a;
	}
	diff --git a/src/EvtGenBase/EvtPropGounarisSakurai.cpp b/src/EvtGenBase/EvtPropGounarisSakurai.cpp
	--- a/src/EvtGenBase/EvtPropGounarisSakurai.cpp
	+++ b/src/EvtGenBase/EvtPropGounarisSakurai.cpp
	@@ -27,11 +27,11 @@
	EvtPropGounarisSakurai::EvtPropGounarisSakurai( EvtDalitzPlot* dp,
	EvtCyclic3::Pair pair,
	double m0, double g0 ) :
	- EvtPropagator( m0, g0 ), _pair( pair ), _gbase( g0 )
	+ EvtPropagator( m0, g0 ), m_pair( pair ), m_gbase( g0 )
	{
	- _dalitzSpace = dp;
	- _m1 = dp->m( EvtCyclic3::first( _pair ) );
	- _m2 = dp->m( EvtCyclic3::second( _pair ) );
	+ m_dalitzSpace = dp;
	+ m_m1 = dp->m( EvtCyclic3::first( m_pair ) );
	+ m_m2 = dp->m( EvtCyclic3::second( m_pair ) );
	}

	EvtAmplitude<EvtPoint1D>* EvtPropGounarisSakurai::clone() const
	@@ -43,14 +43,14 @@
	{
	double m = x.value();
	double s = m * m;
	- double m2 = _m0 * _m0;
	- double _width = _gbase;
	- double _mass = _m0;
	+ double m2 = m_m0 * m_m0;
	+ double f_width = m_gbase;
	+ double f_mass = m_m0;

	- double A = ( 1 + dFun( m2 ) * _width / _mass );
	+ double A = ( 1 + dFun( m2 ) * f_width / f_mass );
	double B = s - m2 - fsFun( s );
	// double C = sqrt(s)*_g0;//wrong!
	- double C = sqrt( m2 ) * _g0; //correct!
	+ double C = sqrt( m2 ) * m_g0; //correct!
	double D = B * B + C * C;

	EvtComplex rpt( A * B / D, -A * C / D );
	@@ -60,14 +60,14 @@
	// adapted from RhoPiTools
	double EvtPropGounarisSakurai::fsFun( double s ) const
	{
	- double m2 = _m0 * _m0;
	+ double m2 = m_m0 * m_m0;

	- EvtTwoBodyKine vd( _m1, _m2, sqrt( s ) );
	- EvtTwoBodyKine vR( _m1, _m2, _m0 );
	+ EvtTwoBodyKine vd( m_m1, m_m2, sqrt( s ) );
	+ EvtTwoBodyKine vR( m_m1, m_m2, m_m0 );
	double k_s = vd.p();
	double k_Am2 = vR.p();
	//
	- double f = _gbase * m2 / pow( k_Am2, 3 ) *
	+ double f = m_gbase * m2 / pow( k_Am2, 3 ) *
	( pow( k_s, 2 ) * ( hFun( s ) - hFun( m2 ) ) +
	( m2 - s ) * pow( k_Am2, 2 ) * dh_dsFun( m2 ) );

	@@ -76,9 +76,9 @@

	double EvtPropGounarisSakurai::hFun( double s ) const
	{
	- double sm = _m1 + _m2;
	+ double sm = m_m1 + m_m2;
	double SQRTs = sqrt( s );
	- EvtTwoBodyKine vd( _m1, _m2, sqrt( s ) );
	+ EvtTwoBodyKine vd( m_m1, m_m2, sqrt( s ) );
	double k_s = vd.p();

	return 2 / EvtConst::pi * ( k_s / SQRTs ) *
	@@ -87,7 +87,7 @@

	double EvtPropGounarisSakurai::dh_dsFun( double s ) const
	{
	- EvtTwoBodyKine vd( _m1, _m2, sqrt( s ) );
	+ EvtTwoBodyKine vd( m_m1, m_m2, sqrt( s ) );
	double k_s = vd.p();

	return hFun( s ) * ( 1 / ( 8 * pow( k_s, 2 ) ) - 1 / ( 2 * s ) ) +
	@@ -96,13 +96,13 @@

	double EvtPropGounarisSakurai::dFun( double s ) const
	{
	- double sm = _m1 + _m2;
	+ double sm = m_m1 + m_m2;
	double sm24 = sm * sm / 4;
	double m = sqrt( s );
	- EvtTwoBodyKine vd( _m1, _m2, sqrt( s ) );
	+ EvtTwoBodyKine vd( m_m1, m_m2, sqrt( s ) );
	double k_m2 = vd.p();
	- double _pi = EvtConst::pi;
	+ double pi = EvtConst::pi;

	- return 3.0 / _pi * sm24 / pow( k_m2, 2 ) * log( ( m + 2 * k_m2 ) / sm ) +
	- m / ( 2 * _pi * k_m2 ) - sm24 * m / ( _pi * pow( k_m2, 3 ) );
	+ return 3.0 / pi * sm24 / pow( k_m2, 2 ) * log( ( m + 2 * k_m2 ) / sm ) +
	+ m / ( 2 * pi * k_m2 ) - sm24 * m / ( pi * pow( k_m2, 3 ) );
	}
	diff --git a/src/EvtGenBase/EvtPto3PAmp.cpp b/src/EvtGenBase/EvtPto3PAmp.cpp
	--- a/src/EvtGenBase/EvtPto3PAmp.cpp
	+++ b/src/EvtGenBase/EvtPto3PAmp.cpp
	@@ -39,68 +39,68 @@
	EvtSpinType::spintype spin, const EvtPropagator& prop,
	NumType typeN ) :
	EvtAmplitude<EvtDalitzPoint>(),
	- _pairAng( pairAng ),
	- _pairRes( pairRes ),
	- _spin( spin ),
	- _typeN( typeN ),
	- _prop( (EvtPropagator*)prop.clone() ),
	- _g0( prop.g0() ),
	- _min( 0 ),
	- _max( 0 ),
	- _vb( prop.m0(), dp.m( EvtCyclic3::other( pairRes ) ), dp.bigM(), spin ),
	- _vd( dp.m( EvtCyclic3::first( pairRes ) ),
	- dp.m( EvtCyclic3::second( pairRes ) ), prop.m0(), spin )
	+ m_pairAng( pairAng ),
	+ m_pairRes( pairRes ),
	+ m_spin( spin ),
	+ m_typeN( typeN ),
	+ m_prop( (EvtPropagator*)prop.clone() ),
	+ m_g0( prop.g0() ),
	+ m_min( 0 ),
	+ m_max( 0 ),
	+ m_vb( prop.m0(), dp.m( EvtCyclic3::other( pairRes ) ), dp.bigM(), spin ),
	+ m_vd( dp.m( EvtCyclic3::first( pairRes ) ),
	+ dp.m( EvtCyclic3::second( pairRes ) ), prop.m0(), spin )
	{
	}

	EvtPto3PAmp::EvtPto3PAmp( const EvtPto3PAmp& other ) :
	EvtAmplitude<EvtDalitzPoint>( other ),
	- _pairAng( other._pairAng ),
	- _pairRes( other._pairRes ),
	- _spin( other._spin ),
	- _typeN( other._typeN ),
	- _prop( ( other._prop ) ? (EvtPropagator*)other._prop->clone() : nullptr ),
	- _g0( other._g0 ),
	- _min( other._min ),
	- _max( other._max ),
	- _vb( other._vb ),
	- _vd( other._vd )
	+ m_pairAng( other.m_pairAng ),
	+ m_pairRes( other.m_pairRes ),
	+ m_spin( other.m_spin ),
	+ m_typeN( other.m_typeN ),
	+ m_prop( ( other.m_prop ) ? (EvtPropagator*)other.m_prop->clone() : nullptr ),
	+ m_g0( other.m_g0 ),
	+ m_min( other.m_min ),
	+ m_max( other.m_max ),
	+ m_vb( other.m_vb ),
	+ m_vd( other.m_vd )
	{
	}

	EvtPto3PAmp::~EvtPto3PAmp()
	{
	- if ( _prop )
	- delete _prop;
	+ if ( m_prop )
	+ delete m_prop;
	}

	void EvtPto3PAmp::set_fd( double R )
	{
	- _vd.set_f( R );
	+ m_vd.set_f( R );
	}

	void EvtPto3PAmp::set_fb( double R )
	{
	- _vb.set_f( R );
	+ m_vb.set_f( R );
	}

	EvtComplex EvtPto3PAmp::amplitude( const EvtDalitzPoint& x ) const
	{
	EvtComplex amp( 1.0, 0.0 );

	- double m = sqrt( x.q( _pairRes ) );
	+ double m = sqrt( x.q( m_pairRes ) );

	- if ( ( _max > 0 && m > _max ) \|\| ( _min > 0 && m < _min ) )
	+ if ( ( m_max > 0 && m > m_max ) \|\| ( m_min > 0 && m < m_min ) )
	return EvtComplex( 0.0, 0.0 );

	- EvtTwoBodyKine vd( x.m( EvtCyclic3::first( _pairRes ) ),
	- x.m( EvtCyclic3::second( _pairRes ) ), m );
	- EvtTwoBodyKine vb( m, x.m( EvtCyclic3::other( _pairRes ) ), x.bigM() );
	+ EvtTwoBodyKine vd( x.m( EvtCyclic3::first( m_pairRes ) ),
	+ x.m( EvtCyclic3::second( m_pairRes ) ), m );
	+ EvtTwoBodyKine vb( m, x.m( EvtCyclic3::other( m_pairRes ) ), x.bigM() );

	// Compute mass-dependent width for relativistic propagators

	- if ( _typeN != NBW && _typeN != FLATTE ) {
	- _prop->set_g0( _g0 * _vd.widthFactor( vd ) );
	+ if ( m_typeN != NBW && m_typeN != FLATTE ) {
	+ m_prop->set_g0( m_g0 * m_vd.widthFactor( vd ) );
	}

	// Compute propagator
	@@ -109,8 +109,8 @@

	// Compute form-factors

	- amp *= _vd.formFactor( vd );
	- amp *= _vb.formFactor( vb );
	+ amp *= m_vd.formFactor( vd );
	+ amp *= m_vb.formFactor( vb );

	amp *= numerator( x );

	@@ -120,27 +120,27 @@
	EvtComplex EvtPto3PAmp::numerator( const EvtDalitzPoint& x ) const
	{
	EvtComplex ret( 0., 0. );
	- double m = sqrt( x.q( _pairRes ) );
	- EvtTwoBodyKine vd( x.m( EvtCyclic3::first( _pairRes ) ),
	- x.m( EvtCyclic3::second( _pairRes ) ), m );
	- EvtTwoBodyKine vb( m, x.m( EvtCyclic3::other( _pairRes ) ), x.bigM() );
	+ double m = sqrt( x.q( m_pairRes ) );
	+ EvtTwoBodyKine vd( x.m( EvtCyclic3::first( m_pairRes ) ),
	+ x.m( EvtCyclic3::second( m_pairRes ) ), m );
	+ EvtTwoBodyKine vb( m, x.m( EvtCyclic3::other( m_pairRes ) ), x.bigM() );

	// Non-relativistic Breit-Wigner

	- if ( NBW == _typeN ) {
	+ if ( NBW == m_typeN ) {
	ret = angDep( x );
	}

	// Standard relativistic Zemach propagator

	- else if ( RBW_ZEMACH == _typeN ) {
	- ret = _vd.phaseSpaceFactor( vd, EvtTwoBodyKine::AB ) * angDep( x );
	+ else if ( RBW_ZEMACH == m_typeN ) {
	+ ret = m_vd.phaseSpaceFactor( vd, EvtTwoBodyKine::AB ) * angDep( x );
	}

	// Kuehn-Santamaria normalization:

	- else if ( RBW_KUEHN == _typeN ) {
	- ret = _prop->m0() * _prop->m0() * angDep( x );
	+ else if ( RBW_KUEHN == m_typeN ) {
	+ ret = m_prop->m0() * m_prop->m0() * angDep( x );
	}

	// CLEO amplitude is not factorizable
	@@ -162,10 +162,11 @@
	// is proportional to +cosTh(BC). In the CLEO expressions, I will
	// therefore exchange AB to get rid of the sign flip.

	- if ( RBW_CLEO == _typeN \|\| FLATTE == _typeN \|\| GS == _typeN ) {
	- Index iA = EvtCyclic3::other( _pairAng ); // A = other(BC)
	- Index iB = EvtCyclic3::common( _pairRes, _pairAng ); // B = common(AB,BC)
	- Index iC = EvtCyclic3::other( _pairRes ); // C = other(AB)
	+ if ( RBW_CLEO == m_typeN \|\| FLATTE == m_typeN \|\| GS == m_typeN ) {
	+ Index iA = EvtCyclic3::other( m_pairAng ); // A = other(BC)
	+ Index iB = EvtCyclic3::common( m_pairRes,
	+ m_pairAng ); // B = common(AB,BC)
	+ Index iC = EvtCyclic3::other( m_pairRes ); // C = other(AB)

	double M = x.bigM();
	double mA = x.m( iA );
	@@ -175,14 +176,14 @@
	double qBC = x.q( EvtCyclic3::combine( iB, iC ) );
	double qCA = x.q( EvtCyclic3::combine( iC, iA ) );

	- //double m0 = _prop->m0();
	+ //double m0 = m_prop->m0();

	- if ( _spin == EvtSpinType::SCALAR )
	+ if ( m_spin == EvtSpinType::SCALAR )
	ret = EvtComplex( 1., 0. );
	- else if ( _spin == EvtSpinType::VECTOR ) {
	+ else if ( m_spin == EvtSpinType::VECTOR ) {
	//ret = qCA - qBC - (MM - mCmC)(mAmA - mB*mB)/m0/m0;
	ret = qCA - qBC - ( M * M - mC * mC ) * ( mA * mA - mB * mB ) / qAB;
	- } else if ( _spin == EvtSpinType::TENSOR ) {
	+ } else if ( m_spin == EvtSpinType::TENSOR ) {
	//double x1 = qBC - qCA + (MM - mCmC)(mAmA - mB*mB)/m0/m0;
	double x1 = qBC - qCA +
	( M * M - mC * mC ) * ( mA * mA - mB * mB ) / qAB;
	@@ -205,7 +206,7 @@
	// Angular dependece for factorizable amplitudes
	// unphysical cosines indicate we are in big trouble

	- double cosTh = x.cosTh( _pairAng, _pairRes );
	+ double cosTh = x.cosTh( m_pairAng, m_pairRes );
	if ( fabs( cosTh ) > 1. ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "cosTh " << cosTh << endl;
	assert( 0 );
	@@ -213,6 +214,6 @@

	// in units of half-spin

	- return EvtdFunction::d( EvtSpinType::getSpin2( _spin ), 2 * 0, 2 * 0,
	+ return EvtdFunction::d( EvtSpinType::getSpin2( m_spin ), 2 * 0, 2 * 0,
	acos( cosTh ) );
	}
	diff --git a/src/EvtGenBase/EvtPto3PAmpFactory.cpp b/src/EvtGenBase/EvtPto3PAmpFactory.cpp
	--- a/src/EvtGenBase/EvtPto3PAmpFactory.cpp
	+++ b/src/EvtGenBase/EvtPto3PAmpFactory.cpp
	@@ -49,7 +49,7 @@
	void EvtPto3PAmpFactory::processAmp( EvtComplex c, std::vector<std::string> vv,
	bool conj )
	{
	- if ( _verbose ) {
	+ if ( m_verbose ) {
	printf( "Make %samplitude\n", conj ? "CP conjugate" : "" );
	unsigned i;
	for ( i = 0; i < vv.size(); i++ )
	@@ -67,7 +67,7 @@
	Experimental amplitudes
	*/
	if ( vv[0] == "PHASESPACE" ) {
	- pdf = std::make_unique<EvtDalitzFlatPdf>( _dp );
	+ pdf = std::make_unique<EvtDalitzFlatPdf>( m_dp );
	amp = std::make_unique<EvtFlatAmp<EvtDalitzPoint>>();
	name = "NR";
	} else if ( !vv[0].find( "NONRES" ) ) {
	@@ -82,8 +82,8 @@
	alpha = strtod( vv[2].c_str(), nullptr );
	} else
	assert( 0 );
	- pdf = std::make_unique<EvtDalitzFlatPdf>( _dp );
	- amp = std::make_unique<EvtNonresonantAmp>( &_dp, typeNRes, pairRes,
	+ pdf = std::make_unique<EvtDalitzFlatPdf>( m_dp );
	+ amp = std::make_unique<EvtNonresonantAmp>( &m_dp, typeNRes, pairRes,
	alpha );
	} else if ( vv[0] == "LASS" \|\| vv[0] == "LASS_ELASTIC" \|\|
	vv[0] == "LASS_RESONANT" ) {
	@@ -93,9 +93,9 @@
	double a = strtod( vv[4].c_str(), nullptr );
	double r = strtod( vv[5].c_str(), nullptr );
	double cutoff = strtod( vv[6].c_str(), nullptr );
	- pdf = std::make_unique<EvtDalitzResPdf>( _dp, m0, g0, pairRes );
	- amp = std::make_unique<EvtLASSAmp>( &_dp, pairRes, m0, g0, a, r, cutoff,
	- vv[0] );
	+ pdf = std::make_unique<EvtDalitzResPdf>( m_dp, m0, g0, pairRes );
	+ amp = std::make_unique<EvtLASSAmp>( &m_dp, pairRes, m0, g0, a, r,
	+ cutoff, vv[0] );
	}

	/*
	@@ -111,7 +111,7 @@
	double mR, gR;
	name = vv[2];
	EvtId resId = EvtPDL::getId( vv[2] );
	- if ( _verbose )
	+ if ( m_verbose )
	printf( "Particles %s form %sresonance %s\n", vv[1].c_str(),
	vv[2].c_str(), conj ? "(conj) " : "" );

	@@ -161,7 +161,7 @@
	// explicitly

	if ( vv[3] != "ANGULAR" ) {
	- if ( _verbose )
	+ if ( m_verbose )
	printf( "Setting m(%s)=%s g(%s)=%s\n", vv[2].c_str(),
	vv[3].c_str(), vv[2].c_str(), vv[4].c_str() );

	@@ -178,7 +178,7 @@
	exit( 0 );
	}
	Pair pairAng = strToPair( vv[++i].c_str() );
	- if ( _verbose )
	+ if ( m_verbose )
	printf( "Angle is measured between particles %s\n", vv[i].c_str() );

	// TYPE stanza
	@@ -186,38 +186,40 @@
	std::string typeName = vv[++i];
	assert( typeName == "TYPE" );
	std::string type = vv[++i];
	- if ( _verbose )
	+ if ( m_verbose )
	printf( "Propagator type %s\n", vv[i].c_str() );

	if ( type == "NBW" ) {
	EvtPropBreitWigner prop( mR, gR );
	- partAmp = std::make_unique<EvtPto3PAmp>( _dp, pairAng, pairRes, spinR,
	- prop, EvtPto3PAmp::NBW );
	+ partAmp = std::make_unique<EvtPto3PAmp>( m_dp, pairAng, pairRes,
	+ spinR, prop,
	+ EvtPto3PAmp::NBW );
	} else if ( type == "RBW_ZEMACH" ) {
	EvtPropBreitWignerRel prop( mR, gR );
	- partAmp = std::make_unique<EvtPto3PAmp>( _dp, pairAng, pairRes,
	+ partAmp = std::make_unique<EvtPto3PAmp>( m_dp, pairAng, pairRes,
	spinR, prop,
	EvtPto3PAmp::RBW_ZEMACH );
	} else if ( type == "RBW_KUEHN" ) {
	EvtPropBreitWignerRel prop( mR, gR );
	- partAmp = std::make_unique<EvtPto3PAmp>( _dp, pairAng, pairRes,
	+ partAmp = std::make_unique<EvtPto3PAmp>( m_dp, pairAng, pairRes,
	spinR, prop,
	EvtPto3PAmp::RBW_KUEHN );
	} else if ( type == "RBW_CLEO" ) {
	EvtPropBreitWignerRel prop( mR, gR );
	- partAmp = std::make_unique<EvtPto3PAmp>( _dp, pairAng, pairRes,
	+ partAmp = std::make_unique<EvtPto3PAmp>( m_dp, pairAng, pairRes,
	spinR, prop,
	EvtPto3PAmp::RBW_CLEO );
	} else if ( type == "FLATTE" ) {
	- double m1a = _dp.m( first( pairRes ) );
	- double m1b = _dp.m( second( pairRes ) );
	+ double m1a = m_dp.m( first( pairRes ) );
	+ double m1b = m_dp.m( second( pairRes ) );
	// 2nd channel
	double g2 = strtod( vv[++i].c_str(), nullptr );
	double m2a = strtod( vv[++i].c_str(), nullptr );
	double m2b = strtod( vv[++i].c_str(), nullptr );
	EvtPropFlatte prop( mR, gR, m1a, m1b, g2, m2a, m2b );
	- partAmp = std::make_unique<EvtPto3PAmp>( _dp, pairAng, pairRes, spinR,
	- prop, EvtPto3PAmp::FLATTE );
	+ partAmp = std::make_unique<EvtPto3PAmp>( m_dp, pairAng, pairRes,
	+ spinR, prop,
	+ EvtPto3PAmp::FLATTE );
	} else
	assert( 0 );

	@@ -238,7 +240,7 @@
	if ( vv[i + 1] == "BVFF" ) {
	i++;
	if ( vv[++i] == "BLATTWEISSKOPF" ) {
	- if ( _verbose )
	+ if ( m_verbose )
	printf( "BVFF=%s\n", vv[i].c_str() );
	double R = strtod( vv[++i].c_str(), nullptr );
	partAmp->set_fb( R );
	@@ -255,7 +257,7 @@
	if ( vv[i + 1] == "MIN" ) {
	i++;
	double min = strtod( vv[++i].c_str(), nullptr );
	- if ( _verbose )
	+ if ( m_verbose )
	std::cout << "CUTOFF MIN = " << min << " " << minwidths
	<< std::endl;
	//ensure against cutting off too close to the resonance
	@@ -264,7 +266,7 @@
	} else if ( vv[i + 1] == "MAX" ) {
	i++;
	double max = strtod( vv[++i].c_str(), nullptr );
	- if ( _verbose )
	+ if ( m_verbose )
	std::cout << "CUTOFF MAX = " << max << " " << minwidths
	<< std::endl;
	//ensure against cutting off too close to the resonance
	@@ -282,7 +284,7 @@
	if ( vv[i + 1] == "MIN" ) {
	i++;
	double min = strtod( vv[++i].c_str(), nullptr );
	- if ( _verbose )
	+ if ( m_verbose )
	std::cout << "CUTOFF MIN = " << min << std::endl;
	//ensure against cutting off too close to the resonance
	assert( min < ( mR - minwidths * gR ) );
	@@ -290,7 +292,7 @@
	} else if ( vv[i + 1] == "MAX" ) {
	i++;
	double max = strtod( vv[++i].c_str(), nullptr );
	- if ( _verbose )
	+ if ( m_verbose )
	std::cout << "CUTOFF MAX = " << max << std::endl;
	//ensure against cutting off too close to the resonance
	assert( max > ( mR + minwidths * gR ) );
	@@ -302,7 +304,7 @@

	i++;

	- pdf = std::make_unique<EvtDalitzResPdf>( _dp, mR, gR, pairRes );
	+ pdf = std::make_unique<EvtDalitzResPdf>( m_dp, mR, gR, pairRes );
	amp = std::move( partAmp );
	}

	@@ -312,13 +314,13 @@
	double scale = matchIsobarCoef( amp, pdf, pairRes );

	if ( !conj ) {
	- _amp->addOwnedTerm( c, std::move( amp ) );
	+ m_amp->addOwnedTerm( c, std::move( amp ) );
	} else {
	- _ampConj->addOwnedTerm( c, std::move( amp ) );
	+ m_ampConj->addOwnedTerm( c, std::move( amp ) );
	}
	- _pc->addOwnedTerm( abs2( c ) * scale, std::move( pdf ) );
	+ m_pc->addOwnedTerm( abs2( c ) * scale, std::move( pdf ) );

	- _names.push_back( name );
	+ m_names.push_back( name );
	}

	double EvtPto3PAmpFactory::matchIsobarCoef( EvtAmplitude<EvtDalitzPoint>& amp,
	@@ -338,19 +340,19 @@
	// Trapezoidal integral
	int N = 10000;

	- double di = ( _dp.qAbsMax( ipair ) - _dp.qAbsMin( ipair ) ) / ( (double)N );
	+ double di = ( m_dp.qAbsMax( ipair ) - m_dp.qAbsMin( ipair ) ) / ( (double)N );

	- double siMin = _dp.qAbsMin( ipair );
	+ double siMin = m_dp.qAbsMin( ipair );

	double s[3]; // playing with fire
	for ( int i = 1; i < N; i++ ) {
	s[ipair] = siMin + di * i;
	- s[jpair] = _dp.q( jpair, 0.9999, ipair, s[ipair] );
	- s[kpair] = _dp.bigM() * _dp.bigM() - s[ipair] - s[jpair] +
	- _dp.mA() * _dp.mA() + _dp.mB() * _dp.mB() +
	- _dp.mC() * _dp.mC();
	+ s[jpair] = m_dp.q( jpair, 0.9999, ipair, s[ipair] );
	+ s[kpair] = m_dp.bigM() * m_dp.bigM() - s[ipair] - s[jpair] +
	+ m_dp.mA() * m_dp.mA() + m_dp.mB() * m_dp.mB() +
	+ m_dp.mC() * m_dp.mC();

	- EvtDalitzPoint point( _dp.mA(), _dp.mB(), _dp.mC(), s[EvtCyclic3::AB],
	+ EvtDalitzPoint point( m_dp.mA(), m_dp.mB(), m_dp.mC(), s[EvtCyclic3::AB],
	s[EvtCyclic3::BC], s[EvtCyclic3::CA] );

	if ( !point.isValid() )
	@@ -362,7 +364,7 @@
	double itg = abs2( amp.evaluate( point ) ) * di * 4 * q * p;
	Iamp2 += itg;
	}
	- if ( _verbose )
	+ if ( m_verbose )
	std::cout << "integral = " << Iamp2 << " pdf=" << Ipdf << std::endl;

	assert( Ipdf > 0 && Iamp2 > 0 );
	diff --git a/src/EvtGenBase/EvtRadCorr.cpp b/src/EvtGenBase/EvtRadCorr.cpp
	--- a/src/EvtGenBase/EvtRadCorr.cpp
	+++ b/src/EvtGenBase/EvtRadCorr.cpp
	@@ -28,68 +28,68 @@
	#include <stdlib.h>
	using std::endl;

	-EvtAbsRadCorr* EvtRadCorr::_fsrEngine = nullptr;
	-bool EvtRadCorr::_alwaysRadCorr = false;
	-bool EvtRadCorr::_neverRadCorr = false;
	+EvtAbsRadCorr* EvtRadCorr::m_fsrEngine = nullptr;
	+bool EvtRadCorr::m_alwaysRadCorr = false;
	+bool EvtRadCorr::m_neverRadCorr = false;

	EvtRadCorr::EvtRadCorr()
	{
	- _fsrEngine = nullptr;
	- _alwaysRadCorr = false;
	- _neverRadCorr = false;
	+ m_fsrEngine = nullptr;
	+ m_alwaysRadCorr = false;
	+ m_neverRadCorr = false;
	}

	EvtRadCorr::~EvtRadCorr()
	{
	- if ( _fsrEngine )
	- delete _fsrEngine;
	- _fsrEngine = nullptr;
	+ if ( m_fsrEngine )
	+ delete m_fsrEngine;
	+ m_fsrEngine = nullptr;
	}

	void EvtRadCorr::setRadCorrEngine( EvtAbsRadCorr* fsrEngine )
	{
	- _fsrEngine = fsrEngine;
	+ m_fsrEngine = fsrEngine;

	- if ( _fsrEngine ) {
	- _fsrEngine->initialise();
	+ if ( m_fsrEngine ) {
	+ m_fsrEngine->initialise();
	}
	}

	void EvtRadCorr::doRadCorr( EvtParticle* p )
	{
	- if ( _fsrEngine == nullptr ) {
	+ if ( m_fsrEngine == nullptr ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "No RadCorr model available in "
	<< "EvtRadCorr::doRadCorr()." << endl;
	::abort();
	}

	- if ( !_neverRadCorr )
	- _fsrEngine->doRadCorr( p );
	+ if ( !m_neverRadCorr )
	+ m_fsrEngine->doRadCorr( p );
	return;
	}

	bool EvtRadCorr::alwaysRadCorr()
	{
	- return _alwaysRadCorr;
	+ return m_alwaysRadCorr;
	}
	bool EvtRadCorr::neverRadCorr()
	{
	- return _neverRadCorr;
	+ return m_neverRadCorr;
	}

	void EvtRadCorr::setAlwaysRadCorr()
	{
	- _alwaysRadCorr = true;
	- _neverRadCorr = false;
	+ m_alwaysRadCorr = true;
	+ m_neverRadCorr = false;
	}
	void EvtRadCorr::setNeverRadCorr()
	{
	- _alwaysRadCorr = false;
	- _neverRadCorr = true;
	+ m_alwaysRadCorr = false;
	+ m_neverRadCorr = true;
	}
	void EvtRadCorr::setNormalRadCorr()
	{
	- _alwaysRadCorr = false;
	- _neverRadCorr = false;
	+ m_alwaysRadCorr = false;
	+ m_neverRadCorr = false;
	}
	diff --git a/src/EvtGenBase/EvtRandom.cpp b/src/EvtGenBase/EvtRandom.cpp
	--- a/src/EvtGenBase/EvtRandom.cpp
	+++ b/src/EvtGenBase/EvtRandom.cpp
	@@ -32,23 +32,23 @@

	using std::endl;

	-EvtRandomEngine* EvtRandom::_randomEngine = nullptr;
	+EvtRandomEngine* EvtRandom::m_randomEngine = nullptr;

	void EvtRandom::setRandomEngine( EvtRandomEngine* randomEngine )
	{
	- _randomEngine = randomEngine;
	+ m_randomEngine = randomEngine;
	}

	double EvtRandom::random()
	{
	- if ( _randomEngine == nullptr ) {
	+ if ( m_randomEngine == nullptr ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "No random engine available in "
	<< "EvtRandom::random()." << endl;
	::abort();
	}

	- return _randomEngine->random();
	+ return m_randomEngine->random();
	}

	// Random number routine to generate numbers between
	diff --git a/src/EvtGenBase/EvtRaritaSchwinger.cpp b/src/EvtGenBase/EvtRaritaSchwinger.cpp
	--- a/src/EvtGenBase/EvtRaritaSchwinger.cpp
	+++ b/src/EvtGenBase/EvtRaritaSchwinger.cpp
	@@ -48,12 +48,12 @@

	void EvtRaritaSchwinger::set( int i, int j, const EvtComplex& sp )
	{
	- _rs[i][j] = sp;
	+ m_rs[i][j] = sp;
	}

	EvtComplex EvtRaritaSchwinger::get( int i, int j ) const
	{
	- return _rs[i][j];
	+ return m_rs[i][j];
	}

	void EvtRaritaSchwinger::applyRotateEuler( double alpha, double beta,
	@@ -132,7 +132,7 @@
	s << endl;
	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- s << rs._rs[i][j];
	+ s << rs.m_rs[i][j];
	}
	s << endl;
	}
	@@ -141,31 +141,31 @@

	EvtVector4C EvtRaritaSchwinger::getVector( int i ) const
	{
	- EvtVector4C tmp( _rs[i][0], _rs[i][1], _rs[i][2], _rs[i][3] );
	+ EvtVector4C tmp( m_rs[i][0], m_rs[i][1], m_rs[i][2], m_rs[i][3] );
	return tmp;
	}

	EvtDiracSpinor EvtRaritaSchwinger::getSpinor( int i ) const
	{
	EvtDiracSpinor tmp;
	- tmp.set( _rs[0][i], _rs[1][i], _rs[2][i], _rs[3][i] );
	+ tmp.set( m_rs[0][i], m_rs[1][i], m_rs[2][i], m_rs[3][i] );
	return tmp;
	}

	void EvtRaritaSchwinger::setVector( int i, const EvtVector4C& v )
	{
	- _rs[i][0] = v.get( 0 );
	- _rs[i][1] = v.get( 1 );
	- _rs[i][2] = v.get( 2 );
	- _rs[i][3] = v.get( 3 );
	+ m_rs[i][0] = v.get( 0 );
	+ m_rs[i][1] = v.get( 1 );
	+ m_rs[i][2] = v.get( 2 );
	+ m_rs[i][3] = v.get( 3 );
	}

	void EvtRaritaSchwinger::setSpinor( int i, const EvtDiracSpinor& sp )
	{
	- _rs[0][i] = sp.get_spinor( 0 );
	- _rs[1][i] = sp.get_spinor( 1 );
	- _rs[2][i] = sp.get_spinor( 2 );
	- _rs[3][i] = sp.get_spinor( 3 );
	+ m_rs[0][i] = sp.get_spinor( 0 );
	+ m_rs[1][i] = sp.get_spinor( 1 );
	+ m_rs[2][i] = sp.get_spinor( 2 );
	+ m_rs[3][i] = sp.get_spinor( 3 );
	}

	EvtRaritaSchwinger dirProd( EvtVector4R v, EvtDiracSpinor u )
	@@ -176,7 +176,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- tmp._rs[i][j] = u.get_spinor( i ) * v.get( j );
	+ tmp.m_rs[i][j] = u.get_spinor( i ) * v.get( j );
	}
	}

	@@ -191,7 +191,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- tmp._rs[i][j] = u.get_spinor( i ) * v.get( j );
	+ tmp.m_rs[i][j] = u.get_spinor( i ) * v.get( j );
	}
	}

	@@ -205,7 +205,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- tmp += conj( u1._rs[i][j] ) * u2._rs[i][j];
	+ tmp += conj( u1.m_rs[i][j] ) * u2.m_rs[i][j];
	}
	}

	@@ -218,7 +218,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _rs[i][j] += u2._rs[i][j];
	+ m_rs[i][j] += u2.m_rs[i][j];
	}
	}

	@@ -237,7 +237,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- _rs[i][j] += u2._rs[i][j];
	+ m_rs[i][j] += u2.m_rs[i][j];
	}
	}

	diff --git a/src/EvtGenBase/EvtRaritaSchwingerParticle.cpp b/src/EvtGenBase/EvtRaritaSchwingerParticle.cpp
	--- a/src/EvtGenBase/EvtRaritaSchwingerParticle.cpp
	+++ b/src/EvtGenBase/EvtRaritaSchwingerParticle.cpp
	@@ -34,7 +34,7 @@

	void EvtRaritaSchwingerParticle::init( EvtId id, const EvtVector4R& p4 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( id );

	@@ -64,17 +64,17 @@
	static EvtVector4C eminus( 0.0, 1.0 / sqrt( 2.0 ),
	EvtComplex( 0.0, -1.0 / sqrt( 2.0 ) ), 0.0 );

	- _spinorRest[0] = dirProd( eplus, spplus );
	- _spinorRest[1] = dirProd( sqrt( 2.0 / 3.0 ) * ezero, spplus ) +
	- dirProd( sqrt( 1.0 / 3.0 ) * eplus, spminus );
	- _spinorRest[2] = dirProd( sqrt( 2.0 / 3.0 ) * ezero, spminus ) +
	- dirProd( sqrt( 1.0 / 3.0 ) * eminus, spplus );
	- _spinorRest[3] = dirProd( eminus, spminus );
	+ m_spinorRest[0] = dirProd( eplus, spplus );
	+ m_spinorRest[1] = dirProd( sqrt( 2.0 / 3.0 ) * ezero, spplus ) +
	+ dirProd( sqrt( 1.0 / 3.0 ) * eplus, spminus );
	+ m_spinorRest[2] = dirProd( sqrt( 2.0 / 3.0 ) * ezero, spminus ) +
	+ dirProd( sqrt( 1.0 / 3.0 ) * eminus, spplus );
	+ m_spinorRest[3] = dirProd( eminus, spminus );

	- _spinor[0] = boostTo( _spinorRest[0], p4 );
	- _spinor[1] = boostTo( _spinorRest[1], p4 );
	- _spinor[2] = boostTo( _spinorRest[2], p4 );
	- _spinor[3] = boostTo( _spinorRest[3], p4 );
	+ m_spinor[0] = boostTo( m_spinorRest[0], p4 );
	+ m_spinor[1] = boostTo( m_spinorRest[1], p4 );
	+ m_spinor[2] = boostTo( m_spinorRest[2], p4 );
	+ m_spinor[3] = boostTo( m_spinorRest[3], p4 );

	setLifetime();
	}
	@@ -86,7 +86,7 @@
	const EvtRaritaSchwinger& rest2, const EvtRaritaSchwinger& rest3,
	const EvtRaritaSchwinger& rest4 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( id );

	@@ -96,27 +96,27 @@
	<< std::endl;
	::abort();
	}
	- _spinorRest[0] = rest1;
	- _spinorRest[1] = rest2;
	- _spinorRest[2] = rest3;
	- _spinorRest[3] = rest4;
	+ m_spinorRest[0] = rest1;
	+ m_spinorRest[1] = rest2;
	+ m_spinorRest[2] = rest3;
	+ m_spinorRest[3] = rest4;

	- _spinor[0] = prod1;
	- _spinor[1] = prod2;
	- _spinor[2] = prod3;
	- _spinor[3] = prod4;
	+ m_spinor[0] = prod1;
	+ m_spinor[1] = prod2;
	+ m_spinor[2] = prod3;
	+ m_spinor[3] = prod4;

	setLifetime();
	}

	EvtRaritaSchwinger EvtRaritaSchwingerParticle::spRSParent( int i ) const
	{
	- return _spinor[i];
	+ return m_spinor[i];
	}

	EvtRaritaSchwinger EvtRaritaSchwingerParticle::spRS( int i ) const
	{
	- return _spinorRest[i];
	+ return m_spinorRest[i];
	}

	EvtSpinDensity EvtRaritaSchwingerParticle::rotateToHelicityBasis() const
	@@ -151,10 +151,10 @@
	R.setDim( 4 );

	for ( int i = 0; i < 4; i++ ) {
	- R.set( 0, i, ( sppp * _spinorRest[i] ) / sqmt2 );
	- R.set( 1, i, ( spp * _spinorRest[i] ) / sqmt2 );
	- R.set( 2, i, ( spm * _spinorRest[i] ) / sqmt2 );
	- R.set( 3, i, ( spmm * _spinorRest[i] ) / sqmt2 );
	+ R.set( 0, i, ( sppp * m_spinorRest[i] ) / sqmt2 );
	+ R.set( 1, i, ( spp * m_spinorRest[i] ) / sqmt2 );
	+ R.set( 2, i, ( spm * m_spinorRest[i] ) / sqmt2 );
	+ R.set( 3, i, ( spmm * m_spinorRest[i] ) / sqmt2 );
	}

	return R;
	@@ -198,10 +198,10 @@
	double sqmt2 = sqrt( 2.0 * ( this->getP4().mass() ) );

	for ( int i = 0; i < 4; i++ ) {
	- R.set( 0, i, ( sppp * _spinorRest[i] ) / sqmt2 );
	- R.set( 1, i, ( spp * _spinorRest[i] ) / sqmt2 );
	- R.set( 2, i, ( spm * _spinorRest[i] ) / sqmt2 );
	- R.set( 3, i, ( spmm * _spinorRest[i] ) / sqmt2 );
	+ R.set( 0, i, ( sppp * m_spinorRest[i] ) / sqmt2 );
	+ R.set( 1, i, ( spp * m_spinorRest[i] ) / sqmt2 );
	+ R.set( 2, i, ( spm * m_spinorRest[i] ) / sqmt2 );
	+ R.set( 3, i, ( spmm * m_spinorRest[i] ) / sqmt2 );
	}

	return R;
	diff --git a/src/EvtGenBase/EvtRelBreitWignerBarrierFact.cpp b/src/EvtGenBase/EvtRelBreitWignerBarrierFact.cpp
	--- a/src/EvtGenBase/EvtRelBreitWignerBarrierFact.cpp
	+++ b/src/EvtGenBase/EvtRelBreitWignerBarrierFact.cpp
	@@ -37,32 +37,32 @@
	EvtAbsLineShape( mass, width, maxRange, sp )
	{ // double mDaug1, double mDaug2, int l) {

	- _includeDecayFact = true;
	- _includeBirthFact = true;
	- _mass = mass;
	- _width = width;
	- _spin = sp;
	- _blattDecay = 3.0;
	- _blattBirth = 1.0;
	- _maxRange = maxRange;
	- _errorCond = false;
	+ m_includeDecayFact = true;
	+ m_includeBirthFact = true;
	+ m_mass = mass;
	+ m_width = width;
	+ m_spin = sp;
	+ m_blattDecay = 3.0;
	+ m_blattBirth = 1.0;
	+ m_maxRange = maxRange;
	+ m_errorCond = false;

	double maxdelta = 15.0 * width;

	if ( maxRange > 0.00001 ) {
	- _massMax = mass + maxdelta;
	- _massMin = mass - maxRange;
	+ m_massMax = mass + maxdelta;
	+ m_massMin = mass - maxRange;
	} else {
	- _massMax = mass + maxdelta;
	- _massMin = mass - 15.0 * width;
	+ m_massMax = mass + maxdelta;
	+ m_massMin = mass - 15.0 * width;
	}

	- _massMax = mass + maxdelta;
	- if ( _massMin < 0. ) {
	- if ( _width > 0.0001 ) {
	- _massMin = 0.00011;
	+ m_massMax = mass + maxdelta;
	+ if ( m_massMin < 0. ) {
	+ if ( m_width > 0.0001 ) {
	+ m_massMin = 0.00011;
	} else {
	- _massMin = 0.;
	+ m_massMin = 0.;
	}
	}
	}
	@@ -71,30 +71,30 @@
	const EvtRelBreitWignerBarrierFact& x ) :
	EvtAbsLineShape( x )
	{
	- _massMax = x._massMax;
	- _massMin = x._massMin;
	- _blattDecay = x._blattDecay;
	- _blattBirth = x._blattBirth;
	- _maxRange = x._maxRange;
	- _includeDecayFact = x._includeDecayFact;
	- _includeBirthFact = x._includeBirthFact;
	- _errorCond = x._errorCond;
	+ m_massMax = x.m_massMax;
	+ m_massMin = x.m_massMin;
	+ m_blattDecay = x.m_blattDecay;
	+ m_blattBirth = x.m_blattBirth;
	+ m_maxRange = x.m_maxRange;
	+ m_includeDecayFact = x.m_includeDecayFact;
	+ m_includeBirthFact = x.m_includeBirthFact;
	+ m_errorCond = x.m_errorCond;
	}

	EvtRelBreitWignerBarrierFact& EvtRelBreitWignerBarrierFact::operator=(
	const EvtRelBreitWignerBarrierFact& x )
	{
	- _mass = x._mass;
	- _width = x._width;
	- _spin = x._spin;
	- _massMax = x._massMax;
	- _massMin = x._massMin;
	- _blattDecay = x._blattDecay;
	- _blattBirth = x._blattBirth;
	- _maxRange = x._maxRange;
	- _includeDecayFact = x._includeDecayFact;
	- _includeBirthFact = x._includeBirthFact;
	- _errorCond = x._errorCond;
	+ m_mass = x.m_mass;
	+ m_width = x.m_width;
	+ m_spin = x.m_spin;
	+ m_massMax = x.m_massMax;
	+ m_massMin = x.m_massMin;
	+ m_blattDecay = x.m_blattDecay;
	+ m_blattBirth = x.m_blattBirth;
	+ m_maxRange = x.m_maxRange;
	+ m_includeDecayFact = x.m_includeDecayFact;
	+ m_includeBirthFact = x.m_includeBirthFact;
	+ m_errorCond = x.m_errorCond;

	return *this;
	}
	@@ -107,7 +107,7 @@
	double EvtRelBreitWignerBarrierFact::getMassProb( double mass, double massPar,
	int nDaug, double* massDau )
	{
	- _errorCond = false;
	+ m_errorCond = false;
	//return EvtAbsLineShape::getMassProb(mass,massPar,nDaug,massDau);
	if ( nDaug != 2 )
	return EvtAbsLineShape::getMassProb( mass, massPar, nDaug, massDau );
	@@ -124,7 +124,7 @@
	if ( ( mass < dTotMass ) )
	return 0.;

	- if ( _width < 0.0001 )
	+ if ( m_width < 0.0001 )
	return 1.;

	if ( massPar > 0.0000000001 ) {
	@@ -132,7 +132,7 @@
	return 0.;
	}

	- if ( _errorCond )
	+ if ( m_errorCond )
	return 0.;

	// we did all the work in getRandMass
	@@ -148,8 +148,8 @@
	return EvtAbsLineShape::getRandMass( parId, nDaug, dauId, othDaugId,
	maxMass, dauMasses );

	- if ( _width < 0.00001 )
	- return _mass;
	+ if ( m_width < 0.00001 )
	+ return m_mass;

	//first figure out L - take the lowest allowed.

	@@ -158,17 +158,17 @@

	int t1 = EvtSpinType::getSpin2( spinD1 );
	int t2 = EvtSpinType::getSpin2( spinD2 );
	- int t3 = EvtSpinType::getSpin2( _spin );
	+ int t3 = EvtSpinType::getSpin2( m_spin );

	int Lmin = -10;

	// the user has overridden the partial wave to use.
	- for ( unsigned int vC = 0; vC < _userSetPW.size(); vC++ ) {
	- if ( dauId[0] == _userSetPWD1[vC] && dauId[1] == _userSetPWD2[vC] ) {
	- Lmin = 2 * _userSetPW[vC];
	+ for ( unsigned int vC = 0; vC < m_userSetPW.size(); vC++ ) {
	+ if ( dauId[0] == m_userSetPWD1[vC] && dauId[1] == m_userSetPWD2[vC] ) {
	+ Lmin = 2 * m_userSetPW[vC];
	}
	- if ( dauId[0] == _userSetPWD2[vC] && dauId[1] == _userSetPWD1[vC] ) {
	- Lmin = 2 * _userSetPW[vC];
	+ if ( dauId[0] == m_userSetPWD2[vC] && dauId[1] == m_userSetPWD1[vC] ) {
	+ Lmin = 2 * m_userSetPW[vC];
	}
	}

	@@ -198,7 +198,7 @@
	double massD2 = dauMasses[1];

	// I'm not sure how to define the vertex factor here - so retreat to nonRel code.
	- if ( ( massD1 + massD2 ) > _mass )
	+ if ( ( massD1 + massD2 ) > m_mass )
	return EvtAbsLineShape::getRandMass( parId, nDaug, dauId, othDaugId,
	maxMass, dauMasses );

	@@ -212,7 +212,7 @@

	int tt1 = EvtSpinType::getSpin2( spinOth );
	int tt2 = EvtSpinType::getSpin2( spinPar );
	- int tt3 = EvtSpinType::getSpin2( _spin );
	+ int tt3 = EvtSpinType::getSpin2( m_spin );

	//figure the min and max allowwed "spins" for the daughters state
	if ( ( tt1 <= 4 ) && ( tt2 <= 4 ) ) {
	@@ -226,14 +226,14 @@
	}

	// allow user to override
	- for ( size_t vC = 0; vC < _userSetBirthPW.size(); vC++ ) {
	- if ( *othDaugId == _userSetBirthOthD[vC] &&
	- *parId == _userSetBirthPar[vC] ) {
	- birthl = 2 * _userSetBirthPW[vC];
	+ for ( size_t vC = 0; vC < m_userSetBirthPW.size(); vC++ ) {
	+ if ( *othDaugId == m_userSetBirthOthD[vC] &&
	+ *parId == m_userSetBirthPar[vC] ) {
	+ birthl = 2 * m_userSetBirthPW[vC];
	}
	}
	}
	- double massM = _massMax;
	+ double massM = m_massMax;
	if ( ( maxMass > -0.5 ) && ( maxMass < massM ) )
	massM = maxMass;

	@@ -242,19 +242,19 @@

	// Define relativistic propagator amplitude

	- EvtTwoBodyVertex vd( massD1, massD2, _mass, Lmin / 2 );
	- vd.set_f( _blattDecay );
	- EvtPropBreitWignerRel bw( _mass, _width );
	+ EvtTwoBodyVertex vd( massD1, massD2, m_mass, Lmin / 2 );
	+ vd.set_f( m_blattDecay );
	+ EvtPropBreitWignerRel bw( m_mass, m_width );
	EvtMassAmp amp( bw, vd );

	- if ( _includeDecayFact ) {
	+ if ( m_includeDecayFact ) {
	amp.addDeathFact();
	amp.addDeathFactFF();
	}
	if ( massParent > -1. ) {
	- if ( _includeBirthFact ) {
	- EvtTwoBodyVertex vb( _mass, massOthD, massParent, birthl / 2 );
	- vb.set_f( _blattBirth );
	+ if ( m_includeBirthFact ) {
	+ EvtTwoBodyVertex vb( m_mass, massOthD, massParent, birthl / 2 );
	+ vb.set_f( m_blattBirth );
	amp.setBirthVtx( vb );
	amp.addBirthFact();
	amp.addBirthFactFF();
	@@ -265,21 +265,21 @@

	// Estimate maximum and create predicate for accept reject

	- double tempMaxLoc = _mass;
	- if ( maxMass > -0.5 && maxMass < _mass )
	+ double tempMaxLoc = m_mass;
	+ if ( maxMass > -0.5 && maxMass < m_mass )
	tempMaxLoc = maxMass;
	- double tempMax = _massMax;
	- if ( maxMass > -0.5 && maxMass < _massMax )
	+ double tempMax = m_massMax;
	+ if ( maxMass > -0.5 && maxMass < m_massMax )
	tempMax = maxMass;
	- double tempMinMass = _massMin;
	- if ( massD1 + massD2 > _massMin )
	+ double tempMinMass = m_massMin;
	+ if ( massD1 + massD2 > m_massMin )
	tempMinMass = massD1 + massD2;

	//redo sanity check - is there a solution to our problem.
	//if not return an error condition that is caught by the
	//mass prob calculation above.
	if ( tempMinMass > tempMax ) {
	- _errorCond = true;
	+ m_errorCond = true;
	return tempMinMass;
	}

	diff --git a/src/EvtGenBase/EvtResonance.cpp b/src/EvtGenBase/EvtResonance.cpp
	--- a/src/EvtGenBase/EvtResonance.cpp
	+++ b/src/EvtGenBase/EvtResonance.cpp
	@@ -34,28 +34,28 @@
	{
	if ( &n == this )
	return *this;
	- _p4_p = n._p4_p;
	- _p4_d1 = n._p4_d1;
	- _p4_d2 = n._p4_d2;
	- _ampl = n._ampl;
	- _theta = n._theta;
	- _gamma = n._gamma;
	- _spin = n._spin;
	- _bwm = n._bwm;
	+ m_p4_p = n.m_p4_p;
	+ m_p4_d1 = n.m_p4_d1;
	+ m_p4_d2 = n.m_p4_d2;
	+ m_ampl = n.m_ampl;
	+ m_theta = n.m_theta;
	+ m_gamma = n.m_gamma;
	+ m_spin = n.m_spin;
	+ m_bwm = n.m_bwm;
	return *this;
	}

	EvtResonance::EvtResonance( const EvtVector4R& p4_p, const EvtVector4R& p4_d1,
	const EvtVector4R& p4_d2, double ampl, double theta,
	double gamma, double bwm, int spin ) :
	- _p4_p( p4_p ),
	- _p4_d1( p4_d1 ),
	- _p4_d2( p4_d2 ),
	- _ampl( ampl ),
	- _theta( theta ),
	- _gamma( gamma ),
	- _bwm( bwm ),
	- _spin( spin )
	+ m_p4_p( p4_p ),
	+ m_p4_d1( p4_d1 ),
	+ m_p4_d2( p4_d2 ),
	+ m_ampl( ampl ),
	+ m_theta( theta ),
	+ m_gamma( gamma ),
	+ m_bwm( bwm ),
	+ m_spin( spin )
	{
	}

	@@ -64,7 +64,7 @@
	double pi180inv = 1.0 / EvtConst::radToDegrees;

	EvtComplex ampl;
	- //EvtVector4R _p4_d3 = _p4_p-_p4_d1-_p4_d2;
	+ //EvtVector4R _p4_d3 = m_p4_p-m_p4_d1-m_p4_d2;

	//get cos of the angle between the daughters from their 4-momenta
	//and the 4-momentum of the parent
	@@ -75,47 +75,47 @@
	//listed particles (12)

	//angle 3 makes with 2 in rest frame of 12 (CS3)
	- double cos_phi_0 = EvtDecayAngle( _p4_p, _p4_d1 + _p4_d2, _p4_d1 );
	+ double cos_phi_0 = EvtDecayAngle( m_p4_p, m_p4_d1 + m_p4_d2, m_p4_d1 );
	//angle 3 makes with 1 in 12 is, of course, -cos_phi_0

	- switch ( _spin ) {
	+ switch ( m_spin ) {
	case 0:
	- ampl = ( _ampl *
	- EvtComplex( cos( _theta * pi180inv ),
	- sin( _theta * pi180inv ) ) *
	- sqrt( _gamma / EvtConst::twoPi ) *
	- ( 1.0 / ( ( _p4_d1 + _p4_d2 ).mass() - _bwm -
	- EvtComplex( 0.0, 0.5 * _gamma ) ) ) );
	+ ampl = ( m_ampl *
	+ EvtComplex( cos( m_theta * pi180inv ),
	+ sin( m_theta * pi180inv ) ) *
	+ sqrt( m_gamma / EvtConst::twoPi ) *
	+ ( 1.0 / ( ( m_p4_d1 + m_p4_d2 ).mass() - m_bwm -
	+ EvtComplex( 0.0, 0.5 * m_gamma ) ) ) );
	break;

	case 1:
	- ampl = ( _ampl *
	- EvtComplex( cos( _theta * pi180inv ),
	- sin( _theta * pi180inv ) ) *
	- sqrt( _gamma / EvtConst::twoPi ) *
	- ( cos_phi_0 / ( ( _p4_d1 + _p4_d2 ).mass() - _bwm -
	- EvtComplex( 0.0, 0.5 * _gamma ) ) ) );
	+ ampl = ( m_ampl *
	+ EvtComplex( cos( m_theta * pi180inv ),
	+ sin( m_theta * pi180inv ) ) *
	+ sqrt( m_gamma / EvtConst::twoPi ) *
	+ ( cos_phi_0 / ( ( m_p4_d1 + m_p4_d2 ).mass() - m_bwm -
	+ EvtComplex( 0.0, 0.5 * m_gamma ) ) ) );
	break;

	case 2:
	- ampl = ( _ampl *
	- EvtComplex( cos( _theta * pi180inv ),
	- sin( _theta * pi180inv ) ) *
	- sqrt( _gamma / EvtConst::twoPi ) *
	+ ampl = ( m_ampl *
	+ EvtComplex( cos( m_theta * pi180inv ),
	+ sin( m_theta * pi180inv ) ) *
	+ sqrt( m_gamma / EvtConst::twoPi ) *
	( ( 1.5 * cos_phi_0 * cos_phi_0 - 0.5 ) /
	- ( ( _p4_d1 + _p4_d2 ).mass() - _bwm -
	- EvtComplex( 0.0, 0.5 * _gamma ) ) ) );
	+ ( ( m_p4_d1 + m_p4_d2 ).mass() - m_bwm -
	+ EvtComplex( 0.0, 0.5 * m_gamma ) ) ) );
	break;

	case 3:
	- ampl = ( _ampl *
	- EvtComplex( cos( _theta * pi180inv ),
	- sin( _theta * pi180inv ) ) *
	- sqrt( _gamma / EvtConst::twoPi ) *
	+ ampl = ( m_ampl *
	+ EvtComplex( cos( m_theta * pi180inv ),
	+ sin( m_theta * pi180inv ) ) *
	+ sqrt( m_gamma / EvtConst::twoPi ) *
	( ( 2.5 * cos_phi_0 * cos_phi_0 * cos_phi_0 -
	1.5 * cos_phi_0 ) /
	- ( ( _p4_d1 + _p4_d2 ).mass() - _bwm -
	- EvtComplex( 0.0, 0.5 * _gamma ) ) ) );
	+ ( ( m_p4_d1 + m_p4_d2 ).mass() - m_bwm -
	+ EvtComplex( 0.0, 0.5 * m_gamma ) ) ) );
	break;

	default:
	@@ -134,29 +134,31 @@
	//for a given resonance (for P-wave decays of scalars only at the moment!)

	EvtComplex BW;
	- EvtVector4R _p4_d3 = _p4_p - _p4_d1 - _p4_d2;
	- EvtVector4R _p4_12 = _p4_d1 + _p4_d2;
	-
	- double msq13 = ( _p4_d1 + _p4_d3 ).mass2();
	- double msq23 = ( _p4_d2 + _p4_d3 ).mass2();
	- double msqParent = _p4_p.mass2();
	- double msq1 = _p4_d1.mass2();
	- double msq2 = _p4_d2.mass2();
	+ EvtVector4R _p4_d3 = m_p4_p - m_p4_d1 - m_p4_d2;
	+ EvtVector4R _p4_12 = m_p4_d1 + m_p4_d2;
	+
	+ double msq13 = ( m_p4_d1 + _p4_d3 ).mass2();
	+ double msq23 = ( m_p4_d2 + _p4_d3 ).mass2();
	+ double msqParent = m_p4_p.mass2();
	+ double msq1 = m_p4_d1.mass2();
	+ double msq2 = m_p4_d2.mass2();
	double msq3 = _p4_d3.mass2();

	double M;

	- double p2 = sqrt( ( _p4_12.mass2() - ( _p4_d1.mass() + _p4_d2.mass() ) *
	- ( _p4_d1.mass() + _p4_d2.mass() ) ) *
	- ( _p4_12.mass2() - ( _p4_d1.mass() - _p4_d2.mass() ) *
	- ( _p4_d1.mass() - _p4_d2.mass() ) ) ) /
	- ( 2.0 * _p4_12.mass() );
	+ double p2 =
	+ sqrt( ( _p4_12.mass2() - ( m_p4_d1.mass() + m_p4_d2.mass() ) *
	+ ( m_p4_d1.mass() + m_p4_d2.mass() ) ) *
	+ ( _p4_12.mass2() - ( m_p4_d1.mass() - m_p4_d2.mass() ) *
	+ ( m_p4_d1.mass() - m_p4_d2.mass() ) ) ) /
	+ ( 2.0 * _p4_12.mass() );

	- double p2R = sqrt( ( _bwm * _bwm - ( _p4_d1.mass() + _p4_d2.mass() ) *
	- ( _p4_d1.mass() + _p4_d2.mass() ) ) *
	- ( _bwm * _bwm - ( _p4_d1.mass() - _p4_d2.mass() ) *
	- ( _p4_d1.mass() - _p4_d2.mass() ) ) ) /
	- ( 2.0 * _bwm );
	+ double p2R =
	+ sqrt( ( m_bwm * m_bwm - ( m_p4_d1.mass() + m_p4_d2.mass() ) *
	+ ( m_p4_d1.mass() + m_p4_d2.mass() ) ) *
	+ ( m_bwm * m_bwm - ( m_p4_d1.mass() - m_p4_d2.mass() ) *
	+ ( m_p4_d1.mass() - m_p4_d2.mass() ) ) ) /
	+ ( 2.0 * m_bwm );

	double gam, R;

	@@ -166,15 +168,15 @@
	} else
	R = 5.0 / ( 0.197 );

	- gam = _gamma * ( _bwm / _p4_12.mass() ) * ( p2 / p2R ) * ( p2 / p2R ) *
	+ gam = m_gamma * ( m_bwm / _p4_12.mass() ) * ( p2 / p2R ) * ( p2 / p2R ) *
	( p2 / p2R ) * ( ( 1 + R * R * p2R * p2R ) / ( 1 + R * R * p2 * p2 ) );
	M = ( msq13 - msq23 -
	- ( msqParent - msq3 ) * ( msq1 - msq2 ) / ( _bwm * _bwm ) ) *
	+ ( msqParent - msq3 ) * ( msq1 - msq2 ) / ( m_bwm * m_bwm ) ) *
	sqrt( ( 1 + R * R * p2R * p2R ) / ( 1 + R * R * p2 * p2 ) );

	- BW = sqrt( _gamma ) * M /
	- ( ( _bwm * _bwm - _p4_12.mass2() ) -
	- EvtComplex( 0.0, 1.0 ) * gam * _bwm );
	+ BW = sqrt( m_gamma ) * M /
	+ ( ( m_bwm * m_bwm - _p4_12.mass2() ) -
	+ EvtComplex( 0.0, 1.0 ) * gam * m_bwm );

	return BW;
	}
	diff --git a/src/EvtGenBase/EvtResonance2.cpp b/src/EvtGenBase/EvtResonance2.cpp
	--- a/src/EvtGenBase/EvtResonance2.cpp
	+++ b/src/EvtGenBase/EvtResonance2.cpp
	@@ -31,17 +31,17 @@
	{
	if ( &n == this )
	return *this;
	- _p4_p = n._p4_p;
	- _p4_d1 = n._p4_d1;
	- _p4_d2 = n._p4_d2;
	- _ampl = n._ampl;
	- _theta = n._theta;
	- _gamma = n._gamma;
	- _spin = n._spin;
	- _bwm = n._bwm;
	- _invmass_angdenom = n._invmass_angdenom;
	- _barrier1 = n._barrier1;
	- _barrier2 = n._barrier2;
	+ m_p4_p = n.m_p4_p;
	+ m_p4_d1 = n.m_p4_d1;
	+ m_p4_d2 = n.m_p4_d2;
	+ m_ampl = n.m_ampl;
	+ m_theta = n.m_theta;
	+ m_gamma = n.m_gamma;
	+ m_spin = n.m_spin;
	+ m_bwm = n.m_bwm;
	+ m_invmass_angdenom = n.m_invmass_angdenom;
	+ m_barrier1 = n.m_barrier1;
	+ m_barrier2 = n.m_barrier2;
	return *this;
	}

	@@ -50,17 +50,17 @@
	double theta, double gamma, double bwm, int spin,
	bool invmass_angdenom, double barrier1,
	double barrier2 ) :
	- _p4_p( p4_p ),
	- _p4_d1( p4_d1 ),
	- _p4_d2( p4_d2 ),
	- _ampl( ampl ),
	- _theta( theta ),
	- _gamma( gamma ),
	- _bwm( bwm ),
	- _barrier1( barrier1 ),
	- _barrier2( barrier2 ),
	- _spin( spin ),
	- _invmass_angdenom( invmass_angdenom )
	+ m_p4_p( p4_p ),
	+ m_p4_d1( p4_d1 ),
	+ m_p4_d2( p4_d2 ),
	+ m_ampl( ampl ),
	+ m_theta( theta ),
	+ m_gamma( gamma ),
	+ m_bwm( bwm ),
	+ m_barrier1( barrier1 ),
	+ m_barrier2( barrier2 ),
	+ m_spin( spin ),
	+ m_invmass_angdenom( invmass_angdenom )
	{
	}

	@@ -69,7 +69,7 @@
	double pi180inv = 1.0 / EvtConst::radToDegrees;

	EvtComplex ampl;
	- EvtVector4R p4_d3 = _p4_p - _p4_d1 - _p4_d2;
	+ EvtVector4R p4_d3 = m_p4_p - m_p4_d1 - m_p4_d2;

	//get cos of the angle between the daughters from their 4-momenta
	//and the 4-momentum of the parent
	@@ -80,22 +80,22 @@
	//listed particles (12)

	//angle 3 makes with 2 in rest frame of 12 (CS3)
	- //double cos_phi_0 = EvtDecayAngle(_p4_p, _p4_d1+_p4_d2, _p4_d1);
	+ //double cos_phi_0 = EvtDecayAngle(m_p4_p, m_p4_d1+m_p4_d2, m_p4_d1);
	//angle 3 makes with 1 in 12 is, of course, -cos_phi_0

	//first compute several quantities...follow CLEO preprint 00-23

	- double mAB = ( _p4_d1 + _p4_d2 ).mass();
	- double mBC = ( _p4_d2 + p4_d3 ).mass();
	- double mAC = ( _p4_d1 + p4_d3 ).mass();
	- double mA = _p4_d1.mass();
	- double mB = _p4_d2.mass();
	- double mD = _p4_p.mass();
	+ double mAB = ( m_p4_d1 + m_p4_d2 ).mass();
	+ double mBC = ( m_p4_d2 + p4_d3 ).mass();
	+ double mAC = ( m_p4_d1 + p4_d3 ).mass();
	+ double mA = m_p4_d1.mass();
	+ double mB = m_p4_d2.mass();
	+ double mD = m_p4_p.mass();
	double mC = p4_d3.mass();

	- double mR = _bwm;
	- double gammaR = _gamma;
	- double mdenom = _invmass_angdenom ? mAB : mR;
	+ double mR = m_bwm;
	+ double gammaR = m_gamma;
	+ double mdenom = m_invmass_angdenom ? mAB : mR;
	double pAB = sqrt( ( ( ( mAB * mAB - mA * mA - mB * mB ) *
	( mAB * mAB - mA * mA - mB * mB ) / 4.0 ) -
	mA * mA * mB * mB ) /
	@@ -122,28 +122,28 @@
	double fR = 1;
	double fD = 1;
	int power = 0;
	- switch ( _spin ) {
	+ switch ( m_spin ) {
	case 0:
	fR = 1.0;
	fD = 1.0;
	power = 1;
	break;
	case 1:
	- fR = sqrt( 1.0 + _barrier1 * _barrier1 * pR * pR ) /
	- sqrt( 1.0 + _barrier1 * _barrier1 * pAB * pAB );
	- fD = sqrt( 1.0 + _barrier2 * _barrier2 * pD * pD ) /
	- sqrt( 1.0 + _barrier2 * _barrier2 * pDAB * pDAB );
	+ fR = sqrt( 1.0 + m_barrier1 * m_barrier1 * pR * pR ) /
	+ sqrt( 1.0 + m_barrier1 * m_barrier1 * pAB * pAB );
	+ fD = sqrt( 1.0 + m_barrier2 * m_barrier2 * pD * pD ) /
	+ sqrt( 1.0 + m_barrier2 * m_barrier2 * pDAB * pDAB );
	power = 3;
	break;
	case 2:
	- fR = sqrt( ( 9 + 3 * pow( ( _barrier1 * pR ), 2 ) +
	- pow( ( _barrier1 * pR ), 4 ) ) /
	- ( 9 + 3 * pow( ( _barrier1 * pAB ), 2 ) +
	- pow( ( _barrier1 * pAB ), 4 ) ) );
	- fD = sqrt( ( 9 + 3 * pow( ( _barrier2 * pD ), 2 ) +
	- pow( ( _barrier2 * pD ), 4 ) ) /
	- ( 9 + 3 * pow( ( _barrier2 * pDAB ), 2 ) +
	- pow( ( _barrier2 * pDAB ), 4 ) ) );
	+ fR = sqrt( ( 9 + 3 * pow( ( m_barrier1 * pR ), 2 ) +
	+ pow( ( m_barrier1 * pR ), 4 ) ) /
	+ ( 9 + 3 * pow( ( m_barrier1 * pAB ), 2 ) +
	+ pow( ( m_barrier1 * pAB ), 4 ) ) );
	+ fD = sqrt( ( 9 + 3 * pow( ( m_barrier2 * pD ), 2 ) +
	+ pow( ( m_barrier2 * pD ), 4 ) ) /
	+ ( 9 + 3 * pow( ( m_barrier2 * pDAB ), 2 ) +
	+ pow( ( m_barrier2 * pDAB ), 4 ) ) );
	power = 5;
	break;
	default:
	@@ -152,18 +152,18 @@
	}

	double gammaAB = gammaR * pow( pAB / pR, power ) * ( mR / mAB ) * fR * fR;
	- switch ( _spin ) {
	+ switch ( m_spin ) {
	case 0:
	- ampl = _ampl *
	- EvtComplex( cos( _theta * pi180inv ),
	- sin( _theta * pi180inv ) ) *
	+ ampl = m_ampl *
	+ EvtComplex( cos( m_theta * pi180inv ),
	+ sin( m_theta * pi180inv ) ) *
	fR * fD /
	( mR * mR - mAB * mAB - EvtComplex( 0.0, mR * gammaAB ) );
	break;
	case 1:
	- ampl = _ampl *
	- EvtComplex( cos( _theta * pi180inv ),
	- sin( _theta * pi180inv ) ) *
	+ ampl = m_ampl *
	+ EvtComplex( cos( m_theta * pi180inv ),
	+ sin( m_theta * pi180inv ) ) *
	( fR * fD *
	( mAC * mAC - mBC * mBC +
	( ( mD * mD - mC * mC ) * ( mB * mB - mA * mA ) /
	@@ -171,9 +171,9 @@
	( mR * mR - mAB * mAB - EvtComplex( 0.0, mR * gammaAB ) ) );
	break;
	case 2:
	- ampl = _ampl *
	- EvtComplex( cos( _theta * pi180inv ),
	- sin( _theta * pi180inv ) ) *
	+ ampl = m_ampl *
	+ EvtComplex( cos( m_theta * pi180inv ),
	+ sin( m_theta * pi180inv ) ) *
	fR * fD /
	( mR * mR - mAB * mAB - EvtComplex( 0.0, mR * gammaAB ) ) *
	( pow( ( mBC * mBC - mAC * mAC +
	diff --git a/src/EvtGenBase/EvtScalarParticle.cpp b/src/EvtGenBase/EvtScalarParticle.cpp
	--- a/src/EvtGenBase/EvtScalarParticle.cpp
	+++ b/src/EvtGenBase/EvtScalarParticle.cpp
	@@ -29,7 +29,7 @@
	void EvtScalarParticle::init( EvtId part_n, double e, double px, double py,
	double pz )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( e, px, py, pz );
	setpart_num( part_n );

	@@ -38,7 +38,7 @@

	void EvtScalarParticle::init( EvtId part_n, const EvtVector4R& p4 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( part_n );

	diff --git a/src/EvtGenBase/EvtSecondary.cpp b/src/EvtGenBase/EvtSecondary.cpp
	--- a/src/EvtGenBase/EvtSecondary.cpp
	+++ b/src/EvtGenBase/EvtSecondary.cpp
	@@ -31,43 +31,43 @@

	void EvtSecondary::init()
	{
	- _npart = 0;
	+ m_npart = 0;
	}

	int EvtSecondary::getNPart()
	{
	- return _npart;
	+ return m_npart;
	}

	void EvtSecondary::createSecondary( int stdhepindex, EvtParticle* prnt )
	{
	- _stdhepindex[_npart] = stdhepindex;
	+ m_stdhepindex[m_npart] = stdhepindex;
	if ( prnt->getNDaug() == 0 ) {
	- _id1[_npart] = 0;
	- _id2[_npart] = 0;
	- _id3[_npart] = 0;
	- _npart++;
	+ m_id1[m_npart] = 0;
	+ m_id2[m_npart] = 0;
	+ m_id3[m_npart] = 0;
	+ m_npart++;
	return;
	}
	if ( prnt->getNDaug() == 1 ) {
	- _id1[_npart] = EvtPDL::getStdHep( prnt->getDaug( 0 )->getId() );
	- _id2[_npart] = 0;
	- _id3[_npart] = 0;
	- _npart++;
	+ m_id1[m_npart] = EvtPDL::getStdHep( prnt->getDaug( 0 )->getId() );
	+ m_id2[m_npart] = 0;
	+ m_id3[m_npart] = 0;
	+ m_npart++;
	return;
	}
	if ( prnt->getNDaug() == 2 ) {
	- _id1[_npart] = EvtPDL::getStdHep( prnt->getDaug( 0 )->getId() );
	- _id2[_npart] = EvtPDL::getStdHep( prnt->getDaug( 1 )->getId() );
	- _id3[_npart] = 0;
	- _npart++;
	+ m_id1[m_npart] = EvtPDL::getStdHep( prnt->getDaug( 0 )->getId() );
	+ m_id2[m_npart] = EvtPDL::getStdHep( prnt->getDaug( 1 )->getId() );
	+ m_id3[m_npart] = 0;
	+ m_npart++;
	return;
	}
	if ( prnt->getNDaug() == 3 ) {
	- _id1[_npart] = EvtPDL::getStdHep( prnt->getDaug( 0 )->getId() );
	- _id2[_npart] = EvtPDL::getStdHep( prnt->getDaug( 1 )->getId() );
	- _id3[_npart] = EvtPDL::getStdHep( prnt->getDaug( 2 )->getId() );
	- _npart++;
	+ m_id1[m_npart] = EvtPDL::getStdHep( prnt->getDaug( 0 )->getId() );
	+ m_id2[m_npart] = EvtPDL::getStdHep( prnt->getDaug( 1 )->getId() );
	+ m_id3[m_npart] = EvtPDL::getStdHep( prnt->getDaug( 2 )->getId() );
	+ m_npart++;
	return;
	}

	@@ -81,10 +81,11 @@
	s << "Secondary decays:" << endl;

	int i;
	- for ( i = 0; i < secondary._npart; i++ ) {
	+ for ( i = 0; i < secondary.m_npart; i++ ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << i << " " << secondary._stdhepindex[i] << " " << secondary._id1[i]
	- << " " << secondary._id2[i] << " " << secondary._id3[i] << endl;
	+ << i << " " << secondary.m_stdhepindex[i] << " "
	+ << secondary.m_id1[i] << " " << secondary.m_id2[i] << " "
	+ << secondary.m_id3[i] << endl;
	}

	s << endl;
	diff --git a/src/EvtGenBase/EvtSemiLeptonicBaryonAmp.cpp b/src/EvtGenBase/EvtSemiLeptonicBaryonAmp.cpp
	--- a/src/EvtGenBase/EvtSemiLeptonicBaryonAmp.cpp
	+++ b/src/EvtGenBase/EvtSemiLeptonicBaryonAmp.cpp
	@@ -550,8 +550,6 @@

	const double form_fact[8] = { f1, f2, f3, f4, g1, g2, g3, g4 };

	- EvtId l_num = parent->getDaug( 1 )->getId();
	-
	EvtVector4C b11, b12, b21, b22, b13, b23, b14, b24, l1, l2;

	// Lepton Current
	diff --git a/src/EvtGenBase/EvtSimpleRandomEngine.cpp b/src/EvtGenBase/EvtSimpleRandomEngine.cpp
	--- a/src/EvtGenBase/EvtSimpleRandomEngine.cpp
	+++ b/src/EvtGenBase/EvtSimpleRandomEngine.cpp
	@@ -28,8 +28,8 @@

	double EvtSimpleRandomEngine::random()
	{
	- _next = _next * 1103515245 + 123345;
	- unsigned temp = (unsigned)( _next / 65536 ) % 32768;
	+ m_next = m_next * 1103515245 + 123345;
	+ unsigned temp = (unsigned)( m_next / 65536 ) % 32768;

	return ( temp + 1.0 ) / 32769.0;
	}
	diff --git a/src/EvtGenBase/EvtSpinDensity.cpp b/src/EvtGenBase/EvtSpinDensity.cpp
	--- a/src/EvtGenBase/EvtSpinDensity.cpp
	+++ b/src/EvtGenBase/EvtSpinDensity.cpp
	@@ -33,15 +33,15 @@

	EvtSpinDensity::EvtSpinDensity( const EvtSpinDensity& density )
	{
	- dim = 0;
	- rho = nullptr;
	+ m_dim = 0;
	+ m_rho = nullptr;

	int i, j;
	- setDim( density.dim );
	+ setDim( density.m_dim );

	- for ( i = 0; i < dim; i++ ) {
	- for ( j = 0; j < dim; j++ ) {
	- rho[i][j] = density.rho[i][j];
	+ for ( i = 0; i < m_dim; i++ ) {
	+ for ( j = 0; j < m_dim; j++ ) {
	+ m_rho[i][j] = density.m_rho[i][j];
	}
	}
	}
	@@ -49,11 +49,11 @@
	EvtSpinDensity& EvtSpinDensity::operator=( const EvtSpinDensity& density )
	{
	int i, j;
	- setDim( density.dim );
	+ setDim( density.m_dim );

	- for ( i = 0; i < dim; i++ ) {
	- for ( j = 0; j < dim; j++ ) {
	- rho[i][j] = density.rho[i][j];
	+ for ( i = 0; i < m_dim; i++ ) {
	+ for ( j = 0; j < m_dim; j++ ) {
	+ m_rho[i][j] = density.m_rho[i][j];
	}
	}

	@@ -62,58 +62,58 @@

	EvtSpinDensity::~EvtSpinDensity()
	{
	- if ( dim != 0 ) {
	+ if ( m_dim != 0 ) {
	int i;
	- for ( i = 0; i < dim; i++ )
	- delete[] rho[i];
	+ for ( i = 0; i < m_dim; i++ )
	+ delete[] m_rho[i];
	}

	- delete[] rho;
	+ delete[] m_rho;
	}

	EvtSpinDensity::EvtSpinDensity()
	{
	- dim = 0;
	- rho = nullptr;
	+ m_dim = 0;
	+ m_rho = nullptr;
	}

	void EvtSpinDensity::setDim( int n )
	{
	- if ( dim == n )
	+ if ( m_dim == n )
	return;
	- if ( dim != 0 ) {
	+ if ( m_dim != 0 ) {
	int i;
	- for ( i = 0; i < dim; i++ )
	- delete[] rho[i];
	- delete[] rho;
	- rho = nullptr;
	- dim = 0;
	+ for ( i = 0; i < m_dim; i++ )
	+ delete[] m_rho[i];
	+ delete[] m_rho;
	+ m_rho = nullptr;
	+ m_dim = 0;
	}
	if ( n == 0 )
	return;
	- dim = n;
	- rho = new EvtComplexPtr[n];
	+ m_dim = n;
	+ m_rho = new EvtComplexPtr[n];
	int i;
	for ( i = 0; i < n; i++ ) {
	- rho[i] = new EvtComplex[n];
	+ m_rho[i] = new EvtComplex[n];
	}
	}

	int EvtSpinDensity::getDim() const
	{
	- return dim;
	+ return m_dim;
	}

	void EvtSpinDensity::set( int i, int j, const EvtComplex& rhoij )
	{
	- assert( i < dim && j < dim );
	- rho[i][j] = rhoij;
	+ assert( i < m_dim && j < m_dim );
	+ m_rho[i][j] = rhoij;
	}

	const EvtComplex& EvtSpinDensity::get( int i, int j ) const
	{
	- assert( i < dim && j < dim );
	- return rho[i][j];
	+ assert( i < m_dim && j < m_dim );
	+ return m_rho[i][j];
	}

	void EvtSpinDensity::setDiag( int n )
	@@ -123,9 +123,9 @@

	for ( i = 0; i < n; i++ ) {
	for ( j = 0; j < n; j++ ) {
	- rho[i][j] = EvtComplex( 0.0 );
	+ m_rho[i][j] = EvtComplex( 0.0 );
	}
	- rho[i][i] = EvtComplex( 1.0 );
	+ m_rho[i][i] = EvtComplex( 1.0 );
	}
	}

	@@ -135,16 +135,16 @@
	EvtComplex prob( 0.0, 0.0 );
	double norm = 0.0;

	- if ( dim != d.dim ) {
	+ if ( m_dim != d.m_dim ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Not matching dimensions in NormalizedProb" << endl;
	::abort();
	}

	- for ( i = 0; i < dim; i++ ) {
	- norm += real( rho[i][i] );
	- for ( j = 0; j < dim; j++ ) {
	- prob += rho[i][j] * d.rho[i][j];
	+ for ( i = 0; i < m_dim; i++ ) {
	+ norm += real( m_rho[i][i] );
	+ for ( j = 0; j < m_dim; j++ ) {
	+ prob += m_rho[i][j] * d.m_rho[i][j];
	}
	}

	@@ -162,23 +162,23 @@

	int EvtSpinDensity::check()
	{
	- if ( dim < 1 ) {
	+ if ( m_dim < 1 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "dim=" << dim << "in SpinDensity::Check" << endl;
	+ << "dim=" << m_dim << "in SpinDensity::Check" << endl;
	}

	int i, j;

	double trace( 0.0 );

	- for ( i = 0; i < dim; i++ ) {
	- trace += abs( rho[i][i] );
	+ for ( i = 0; i < m_dim; i++ ) {
	+ trace += abs( m_rho[i][i] );
	}

	- for ( i = 0; i < dim; i++ ) {
	- if ( real( rho[i][i] ) < 0.0 )
	+ for ( i = 0; i < m_dim; i++ ) {
	+ if ( real( m_rho[i][i] ) < 0.0 )
	return 0;
	- if ( imag( rho[i][i] ) * 1000000.0 > trace ) {
	+ if ( imag( m_rho[i][i] ) * 1000000.0 > trace ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << *this << endl;
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << trace << endl;
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Failing 1" << endl;
	@@ -186,15 +186,15 @@
	}
	}

	- for ( i = 0; i < dim; i++ ) {
	- for ( j = i + 1; j < dim; j++ ) {
	- if ( fabs( real( rho[i][j] - rho[j][i] ) ) >
	- 0.00000001 * ( abs( rho[i][i] ) + abs( rho[j][j] ) ) ) {
	+ for ( i = 0; i < m_dim; i++ ) {
	+ for ( j = i + 1; j < m_dim; j++ ) {
	+ if ( fabs( real( m_rho[i][j] - m_rho[j][i] ) ) >
	+ 0.00000001 * ( abs( m_rho[i][i] ) + abs( m_rho[j][j] ) ) ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Failing 2" << endl;
	return 0;
	}
	- if ( fabs( imag( rho[i][j] + rho[j][i] ) ) >
	- 0.00000001 * ( abs( rho[i][i] ) + abs( rho[j][j] ) ) ) {
	+ if ( fabs( imag( m_rho[i][j] + m_rho[j][i] ) ) >
	+ 0.00000001 * ( abs( m_rho[i][i] ) + abs( m_rho[j][j] ) ) ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Failing 3" << endl;
	return 0;
	}
	@@ -209,11 +209,11 @@
	int i, j;

	s << endl;
	- s << "Dimension:" << d.dim << endl;
	+ s << "Dimension:" << d.m_dim << endl;

	- for ( i = 0; i < d.dim; i++ ) {
	- for ( j = 0; j < d.dim; j++ ) {
	- s << d.rho[i][j] << " ";
	+ for ( i = 0; i < d.m_dim; i++ ) {
	+ for ( j = 0; j < d.m_dim; j++ ) {
	+ s << d.m_rho[i][j] << " ";
	}
	s << endl;
	}
	diff --git a/src/EvtGenBase/EvtStdHep.cpp b/src/EvtGenBase/EvtStdHep.cpp
	--- a/src/EvtGenBase/EvtStdHep.cpp
	+++ b/src/EvtGenBase/EvtStdHep.cpp
	@@ -29,120 +29,115 @@

	void EvtStdHep::init()
	{
	- _npart = 0;
	+ m_npart = 0;
	}

	int EvtStdHep::getNPart()
	{
	- return _npart;
	+ return m_npart;
	}

	void EvtStdHep::createParticle( EvtVector4R p4, EvtVector4R x, int prntfirst,
	int prntlast, int id )
	{
	- _p4[_npart] = p4;
	- _x[_npart] = x;
	- _prntfirst[_npart] = prntfirst;
	- _prntlast[_npart] = prntlast;
	- _daugfirst[_npart] = -1;
	- _dauglast[_npart] = -1;
	- _id[_npart] = id;
	- _istat[_npart] = 1;
	+ m_p4[m_npart] = p4;
	+ m_x[m_npart] = x;
	+ m_prntfirst[m_npart] = prntfirst;
	+ m_prntlast[m_npart] = prntlast;
	+ m_daugfirst[m_npart] = -1;
	+ m_dauglast[m_npart] = -1;
	+ m_id[m_npart] = id;
	+ m_istat[m_npart] = 1;

	//we also need to fix up the parents pointer to the daughter!

	if ( prntfirst >= 0 ) {
	int i;
	for ( i = prntfirst; i <= prntlast; i++ ) {
	- _istat[i] = 2;
	- if ( _daugfirst[i] == -1 )
	- _daugfirst[i] = _npart;
	- if ( _dauglast[i] < _npart )
	- _dauglast[i] = _npart;
	+ m_istat[i] = 2;
	+ if ( m_daugfirst[i] == -1 )
	+ m_daugfirst[i] = m_npart;
	+ if ( m_dauglast[i] < m_npart )
	+ m_dauglast[i] = m_npart;
	}
	}

	- _npart++;
	+ m_npart++;
	}

	void EvtStdHep::translate( EvtVector4R d )
	{
	int i;
	- for ( i = 0; i < _npart; i++ ) {
	- _x[i] += d;
	+ for ( i = 0; i < m_npart; i++ ) {
	+ m_x[i] += d;
	}
	}

	-/*
	-ostream& operator<<(ostream& s, const EvtStdHep& stdhep){
	-
	- int w=s.width();
	- int p=s.precision();
	- std::ios::fmtflags f=s.flags();
	-
	-
	- s <<endl;
	- s << " N Id Ist M1 M2 DF DL px py pz E t x y z"<<endl;
	- int i;
	- for(i=0;i<stdhep._npart;i++){
	-
	- s.width(3);
	- s<<i<<" ";
	- s.width(7);
	- s<<stdhep._id[i]<<" ";
	- s.width(3);
	- s<<stdhep._istat[i]<<" ";
	- s.width(4);
	- s<<stdhep._prntfirst[i]<<" ";
	- s.width(4);
	- s<<stdhep._prntlast[i]<<" ";
	- s.width(4);
	- s<<stdhep._daugfirst[i]<<" ";
	- s.width(4);
	- s<<stdhep._dauglast[i]<<" ";
	- s.width(7);
	- s.precision(4);
	- s<<setiosflags( ios::right\|ios::fixed );
	- s<<stdhep._p4[i].get(1)<<" ";
	- s.width(7);
	- s.precision(4);
	- s<<setiosflags( ios::right\|ios::fixed );
	- s<<stdhep._p4[i].get(2)<<" ";
	- s.width(7);
	- s.precision(4);
	- s<<setiosflags( ios::right\|ios::fixed );
	- s<<stdhep._p4[i].get(3)<<" ";
	- s.width(7);
	- s.precision(4);
	- s<<setiosflags( ios::right\|ios::fixed );
	- s<<stdhep._p4[i].get(0)<<" ";
	- s.width(7);
	- s.precision(4);
	- s<<setiosflags( ios::right\|ios::fixed );
	- s<<stdhep._x[i].get(0)<<" ";
	- s.width(7);
	- s.precision(4);
	- s<<setiosflags( ios::right\|ios::fixed );
	- s<<stdhep._x[i].get(1)<<" ";
	- s.width(7);
	- s.precision(4);
	- s<<setiosflags( ios::right\|ios::fixed );
	- s<<stdhep._x[i].get(2)<<" ";
	- s.width(7);
	- s.precision(4);
	- s<<setiosflags( ios::right\|ios::fixed );
	- s<<stdhep._x[i].get(3)<<endl;
	- s.width(0);
	- }
	-
	- s<<endl;
	-
	- s.width(w);
	- s.precision(p);
	- s.flags((std::ios::fmtflags)f);
	-
	- return s;
	-
	-}
	-
	-*/
	+ostream& operator<<( ostream& s, const EvtStdHep& stdhep )
	+{
	+ int w = s.width();
	+ int p = s.precision();
	+ std::ios::fmtflags f = s.flags();
	+
	+ s << endl;
	+ s << " N Id Ist M1 M2 DF DL px py pz E t x y z"
	+ << endl;
	+ int i;
	+ for ( i = 0; i < stdhep.m_npart; i++ ) {
	+ s.width( 3 );
	+ s << i << " ";
	+ s.width( 7 );
	+ s << stdhep.m_id[i] << " ";
	+ s.width( 3 );
	+ s << stdhep.m_istat[i] << " ";
	+ s.width( 4 );
	+ s << stdhep.m_prntfirst[i] << " ";
	+ s.width( 4 );
	+ s << stdhep.m_prntlast[i] << " ";
	+ s.width( 4 );
	+ s << stdhep.m_daugfirst[i] << " ";
	+ s.width( 4 );
	+ s << stdhep.m_dauglast[i] << " ";
	+ s.width( 7 );
	+ s.precision( 4 );
	+ s << setiosflags( ios::right \| ios::fixed );
	+ s << stdhep.m_p4[i].get( 1 ) << " ";
	+ s.width( 7 );
	+ s.precision( 4 );
	+ s << setiosflags( ios::right \| ios::fixed );
	+ s << stdhep.m_p4[i].get( 2 ) << " ";
	+ s.width( 7 );
	+ s.precision( 4 );
	+ s << setiosflags( ios::right \| ios::fixed );
	+ s << stdhep.m_p4[i].get( 3 ) << " ";
	+ s.width( 7 );
	+ s.precision( 4 );
	+ s << setiosflags( ios::right \| ios::fixed );
	+ s << stdhep.m_p4[i].get( 0 ) << " ";
	+ s.width( 7 );
	+ s.precision( 4 );
	+ s << setiosflags( ios::right \| ios::fixed );
	+ s << stdhep.m_x[i].get( 0 ) << " ";
	+ s.width( 7 );
	+ s.precision( 4 );
	+ s << setiosflags( ios::right \| ios::fixed );
	+ s << stdhep.m_x[i].get( 1 ) << " ";
	+ s.width( 7 );
	+ s.precision( 4 );
	+ s << setiosflags( ios::right \| ios::fixed );
	+ s << stdhep.m_x[i].get( 2 ) << " ";
	+ s.width( 7 );
	+ s.precision( 4 );
	+ s << setiosflags( ios::right \| ios::fixed );
	+ s << stdhep.m_x[i].get( 3 ) << endl;
	+ s.width( 0 );
	+ }
	+
	+ s << endl;
	+
	+ s.width( w );
	+ s.precision( p );
	+ s.flags( (std::ios::fmtflags)f );
	+
	+ return s;
	+}
	diff --git a/src/EvtGenBase/EvtStringParticle.cpp b/src/EvtGenBase/EvtStringParticle.cpp
	--- a/src/EvtGenBase/EvtStringParticle.cpp
	+++ b/src/EvtGenBase/EvtStringParticle.cpp
	@@ -30,7 +30,7 @@

	void EvtStringParticle::init( EvtId id, const EvtVector4R& p4 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( id );
	}
	@@ -38,27 +38,27 @@
	void EvtStringParticle::initPartons( int npartons, EvtVector4R* p4partons,
	EvtId* idpartons )
	{
	- _p4partons.resize( npartons );
	- _idpartons.resize( npartons );
	+ m_p4partons.resize( npartons );
	+ m_idpartons.resize( npartons );
	for ( int i = 0; i < npartons; i++ ) {
	- _p4partons[i] = p4partons[i];
	- _idpartons[i] = idpartons[i];
	+ m_p4partons[i] = p4partons[i];
	+ m_idpartons[i] = idpartons[i];
	}
	}

	int EvtStringParticle::getNPartons()
	{
	- return _p4partons.size();
	+ return m_p4partons.size();
	}

	EvtId EvtStringParticle::getIdParton( int i )
	{
	- return _idpartons[i];
	+ return m_idpartons[i];
	}

	EvtVector4R EvtStringParticle::getP4Parton( int i )
	{
	- return _p4partons[i];
	+ return m_p4partons[i];
	}

	EvtSpinDensity EvtStringParticle::rotateToHelicityBasis() const
	diff --git a/src/EvtGenBase/EvtSymTable.cpp b/src/EvtGenBase/EvtSymTable.cpp
	--- a/src/EvtGenBase/EvtSymTable.cpp
	+++ b/src/EvtGenBase/EvtSymTable.cpp
	@@ -31,7 +31,7 @@
	using std::endl;
	using std::fstream;

	-std::map<std::string, std::string> EvtSymTable::_symMap;
	+std::map<std::string, std::string> EvtSymTable::m_symMap;

	EvtSymTable::EvtSymTable()
	{
	@@ -39,16 +39,16 @@

	void EvtSymTable::define( const std::string& symname, std::string d )
	{
	- if ( _symMap.find( symname ) != _symMap.end() ) {
	+ if ( m_symMap.find( symname ) != m_symMap.end() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Symbol:" << symname.c_str()
	- << " redefined, old value:" << _symMap[symname].c_str()
	+ << " redefined, old value:" << m_symMap[symname].c_str()
	<< " new value:" << d.c_str() << endl;
	- _symMap[symname] = d;
	+ m_symMap[symname] = d;
	return;
	}

	- _symMap[symname] = d;
	+ m_symMap[symname] = d;
	return;
	}

	@@ -56,8 +56,8 @@
	{
	ierr = 0;

	- if ( _symMap.find( symname ) != _symMap.end() )
	- return _symMap[symname];
	+ if ( m_symMap.find( symname ) != m_symMap.end() )
	+ return m_symMap[symname];

	// If no matching symbol found just return the string

	diff --git a/src/EvtGenBase/EvtTensor3C.cpp b/src/EvtGenBase/EvtTensor3C.cpp
	--- a/src/EvtGenBase/EvtTensor3C.cpp
	+++ b/src/EvtGenBase/EvtTensor3C.cpp
	@@ -36,7 +36,7 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] = t1.t[i][j];
	+ m_t[i][j] = t1.m_t[i][j];
	}
	}
	}
	@@ -47,13 +47,13 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] = 0.0;
	+ m_t[i][j] = 0.0;
	}
	}

	- t[0][0] = d11;
	- t[1][1] = d22;
	- t[2][2] = d33;
	+ m_t[0][0] = d11;
	+ m_t[1][1] = d22;
	+ m_t[2][2] = d33;
	}

	EvtTensor3C& EvtTensor3C::operator=( const EvtTensor3C& t1 )
	@@ -62,7 +62,7 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] = t1.t[i][j];
	+ m_t[i][j] = t1.m_t[i][j];
	}
	}
	return *this;
	@@ -76,7 +76,7 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- temp.set( j, i, ::conj( t[i][j] ) );
	+ temp.set( j, i, ::conj( m_t[i][j] ) );
	}
	}
	return temp;
	@@ -87,7 +87,7 @@
	int i, j;
	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] = EvtComplex( 0.0, 0.0 );
	+ m_t[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}
	}
	@@ -98,7 +98,7 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] = EvtComplex( 0.0, 0.0 );
	+ m_t[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}
	}
	@@ -109,7 +109,7 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] += t2.t[i][j];
	+ m_t[i][j] += t2.m_t[i][j];
	}
	}
	return *this;
	@@ -121,7 +121,7 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] -= t2.t[i][j];
	+ m_t[i][j] -= t2.m_t[i][j];
	}
	}
	return *this;
	@@ -133,7 +133,7 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] *= c;
	+ m_t[i][j] *= c;
	}
	}
	return *this;
	@@ -145,7 +145,7 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] *= EvtComplex( c );
	+ m_t[i][j] *= EvtComplex( c );
	}
	}
	return *this;
	@@ -187,7 +187,7 @@

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- temp.t[i][j] = EvtComplex( c1.get( i ) * c2.get( j ), 0.0 );
	+ temp.m_t[i][j] = EvtComplex( c1.get( i ) * c2.get( j ), 0.0 );
	}
	}
	return temp;
	@@ -251,8 +251,8 @@
	int i;

	for ( i = 0; i < 3; i++ ) {
	- temp.set( i, t[0][i] * v.get( 0 ) + t[1][i] * v.get( 1 ) +
	- t[2][i] * v.get( 2 ) );
	+ temp.set( i, m_t[0][i] * v.get( 0 ) + m_t[1][i] * v.get( 1 ) +
	+ m_t[2][i] * v.get( 2 ) );
	}

	return temp;
	@@ -265,8 +265,8 @@
	int i;

	for ( i = 0; i < 3; i++ ) {
	- temp.set( i, t[i][0] * v.get( 0 ) + t[i][1] * v.get( 1 ) +
	- t[i][2] * v.get( 2 ) );
	+ temp.set( i, m_t[i][0] * v.get( 0 ) + m_t[i][1] * v.get( 1 ) +
	+ m_t[i][2] * v.get( 2 ) );
	}

	return temp;
	@@ -279,8 +279,8 @@
	int i;

	for ( i = 0; i < 3; i++ ) {
	- temp.set( i, t[0][i] * v.get( 0 ) + t[1][i] * v.get( 1 ) +
	- t[2][i] * v.get( 2 ) );
	+ temp.set( i, m_t[0][i] * v.get( 0 ) + m_t[1][i] * v.get( 1 ) +
	+ m_t[2][i] * v.get( 2 ) );
	}

	return temp;
	@@ -293,8 +293,8 @@
	int i;

	for ( i = 0; i < 3; i++ ) {
	- temp.set( i, t[i][0] * v.get( 0 ) + t[i][1] * v.get( 1 ) +
	- t[i][2] * v.get( 2 ) );
	+ temp.set( i, m_t[i][0] * v.get( 0 ) + m_t[i][1] * v.get( 1 ) +
	+ m_t[i][2] * v.get( 2 ) );
	}

	return temp;
	@@ -304,18 +304,18 @@
	{
	EvtTensor3C temp;

	- temp.t[0][0] = 0.0;
	- temp.t[1][1] = 0.0;
	- temp.t[2][2] = 0.0;
	+ temp.m_t[0][0] = 0.0;
	+ temp.m_t[1][1] = 0.0;
	+ temp.m_t[2][2] = 0.0;

	- temp.t[0][1] = v.get( 2 );
	- temp.t[0][2] = -v.get( 1 );
	+ temp.m_t[0][1] = v.get( 2 );
	+ temp.m_t[0][2] = -v.get( 1 );

	- temp.t[1][0] = -v.get( 2 );
	- temp.t[1][2] = v.get( 0 );
	+ temp.m_t[1][0] = -v.get( 2 );
	+ temp.m_t[1][2] = v.get( 0 );

	- temp.t[2][0] = v.get( 1 );
	- temp.t[2][1] = -v.get( 0 );
	+ temp.m_t[2][0] = v.get( 1 );
	+ temp.m_t[2][1] = -v.get( 0 );

	return temp;
	}
	@@ -330,11 +330,12 @@
	ostream& operator<<( ostream& s, const EvtTensor3C& v )
	{
	s << endl
	- << "(" << v.t[0][0] << "," << v.t[0][1] << "," << v.t[0][2] << ")";
	+ << "(" << v.m_t[0][0] << "," << v.m_t[0][1] << "," << v.m_t[0][2] << ")";
	s << endl
	- << "(" << v.t[1][0] << "," << v.t[1][1] << "," << v.t[1][2] << ")";
	+ << "(" << v.m_t[1][0] << "," << v.m_t[1][1] << "," << v.m_t[1][2] << ")";
	s << endl
	- << "(" << v.t[2][0] << "," << v.t[2][1] << "," << v.t[2][2] << ")" << endl;
	+ << "(" << v.m_t[2][0] << "," << v.m_t[2][1] << "," << v.m_t[2][2] << ")"
	+ << endl;

	return s;
	}
	@@ -377,16 +378,16 @@
	for ( j = 0; j < 3; j++ ) {
	temp[i][j] = 0.0;
	for ( k = 0; k < 3; k++ ) {
	- temp[i][j] += r[i][k] * t[k][j];
	+ temp[i][j] += r[i][k] * m_t[k][j];
	}
	}
	}

	for ( i = 0; i < 3; i++ ) {
	for ( j = 0; j < 3; j++ ) {
	- t[i][j] = 0.0;
	+ m_t[i][j] = 0.0;
	for ( k = 0; k < 3; k++ ) {
	- t[i][j] += r[i][k] * temp[j][k];
	+ m_t[i][j] += r[i][k] * temp[j][k];
	}
	}
	}
	diff --git a/src/EvtGenBase/EvtTensor4C.cpp b/src/EvtGenBase/EvtTensor4C.cpp
	--- a/src/EvtGenBase/EvtTensor4C.cpp
	+++ b/src/EvtGenBase/EvtTensor4C.cpp
	@@ -36,7 +36,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] = t1.t[i][j];
	+ m_t[i][j] = t1.m_t[i][j];
	}
	}
	}
	@@ -54,7 +54,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] = t1.t[i][j];
	+ m_t[i][j] = t1.m_t[i][j];
	}
	}
	return *this;
	@@ -68,7 +68,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- temp.set( j, i, ::conj( t[i][j] ) );
	+ temp.set( j, i, ::conj( m_t[i][j] ) );
	}
	}
	return temp;
	@@ -162,16 +162,16 @@
	for ( j = 0; j < 4; j++ ) {
	tt[i][j] = EvtComplex( 0.0 );
	for ( k = 0; k < 4; k++ ) {
	- tt[i][j] = tt[i][j] + lambda[j][k] * t[i][k];
	+ tt[i][j] = tt[i][j] + lambda[j][k] * m_t[i][k];
	}
	}
	}

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] = EvtComplex( 0.0 );
	+ m_t[i][j] = EvtComplex( 0.0 );
	for ( k = 0; k < 4; k++ ) {
	- t[i][j] = t[i][j] + lambda[i][k] * tt[k][j];
	+ m_t[i][j] = m_t[i][j] + lambda[i][k] * tt[k][j];
	}
	}
	}
	@@ -182,7 +182,7 @@
	int i, j;
	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] = EvtComplex( 0.0, 0.0 );
	+ m_t[i][j] = EvtComplex( 0.0, 0.0 );
	}
	}
	}
	@@ -193,7 +193,7 @@
	s << endl;
	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- s << t.t[i][j];
	+ s << t.m_t[i][j];
	}
	s << endl;
	}
	@@ -202,22 +202,22 @@

	void EvtTensor4C::setdiag( double g00, double g11, double g22, double g33 )
	{
	- t[0][0] = EvtComplex( g00 );
	- t[1][1] = EvtComplex( g11 );
	- t[2][2] = EvtComplex( g22 );
	- t[3][3] = EvtComplex( g33 );
	- t[0][1] = EvtComplex( 0.0 );
	- t[0][2] = EvtComplex( 0.0 );
	- t[0][3] = EvtComplex( 0.0 );
	- t[1][0] = EvtComplex( 0.0 );
	- t[1][2] = EvtComplex( 0.0 );
	- t[1][3] = EvtComplex( 0.0 );
	- t[2][0] = EvtComplex( 0.0 );
	- t[2][1] = EvtComplex( 0.0 );
	- t[2][3] = EvtComplex( 0.0 );
	- t[3][0] = EvtComplex( 0.0 );
	- t[3][1] = EvtComplex( 0.0 );
	- t[3][2] = EvtComplex( 0.0 );
	+ m_t[0][0] = EvtComplex( g00 );
	+ m_t[1][1] = EvtComplex( g11 );
	+ m_t[2][2] = EvtComplex( g22 );
	+ m_t[3][3] = EvtComplex( g33 );
	+ m_t[0][1] = EvtComplex( 0.0 );
	+ m_t[0][2] = EvtComplex( 0.0 );
	+ m_t[0][3] = EvtComplex( 0.0 );
	+ m_t[1][0] = EvtComplex( 0.0 );
	+ m_t[1][2] = EvtComplex( 0.0 );
	+ m_t[1][3] = EvtComplex( 0.0 );
	+ m_t[2][0] = EvtComplex( 0.0 );
	+ m_t[2][1] = EvtComplex( 0.0 );
	+ m_t[2][3] = EvtComplex( 0.0 );
	+ m_t[3][0] = EvtComplex( 0.0 );
	+ m_t[3][1] = EvtComplex( 0.0 );
	+ m_t[3][2] = EvtComplex( 0.0 );
	}

	EvtTensor4C& EvtTensor4C::operator+=( const EvtTensor4C& t2 )
	@@ -226,7 +226,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] += t2.get( i, j );
	+ m_t[i][j] += t2.get( i, j );
	}
	}
	return *this;
	@@ -238,7 +238,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] -= t2.get( i, j );
	+ m_t[i][j] -= t2.get( i, j );
	}
	}
	return *this;
	@@ -250,7 +250,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] *= c;
	+ m_t[i][j] *= c;
	}
	}
	return *this;
	@@ -272,7 +272,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] *= EvtComplex( d, 0.0 );
	+ m_t[i][j] *= EvtComplex( d, 0.0 );
	}
	}
	return *this;
	@@ -296,9 +296,9 @@
	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	if ( ( i == 0 && j != 0 ) \|\| ( j == 0 && i != 0 ) ) {
	- sum -= t1.t[i][j] * t2.t[i][j];
	+ sum -= t1.m_t[i][j] * t2.m_t[i][j];
	} else {
	- sum += t1.t[i][j] * t2.t[i][j];
	+ sum += t1.m_t[i][j] * t2.m_t[i][j];
	}
	}
	}
	@@ -342,7 +342,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- temp.t[i][j] = EvtComplex( c1.get( i ) * c2.get( j ), 0.0 );
	+ temp.m_t[i][j] = EvtComplex( c1.get( i ) * c2.get( j ), 0.0 );
	}
	}
	return temp;
	@@ -355,7 +355,7 @@

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] += p1.get( i ) * p2.get( j );
	+ m_t[i][j] += p1.get( i ) * p2.get( j );
	}
	}
	return *this;
	@@ -451,8 +451,8 @@
	int i;

	for ( i = 0; i < 4; i++ ) {
	- temp.set( i, t[0][i] * v4.get( 0 ) - t[1][i] * v4.get( 1 ) -
	- t[2][i] * v4.get( 2 ) - t[3][i] * v4.get( 3 ) );
	+ temp.set( i, m_t[0][i] * v4.get( 0 ) - m_t[1][i] * v4.get( 1 ) -
	+ m_t[2][i] * v4.get( 2 ) - m_t[3][i] * v4.get( 3 ) );
	}

	return temp;
	@@ -465,8 +465,8 @@
	int i;

	for ( i = 0; i < 4; i++ ) {
	- temp.set( i, t[i][0] * v4.get( 0 ) - t[i][1] * v4.get( 1 ) -
	- t[i][2] * v4.get( 2 ) - t[i][3] * v4.get( 3 ) );
	+ temp.set( i, m_t[i][0] * v4.get( 0 ) - m_t[i][1] * v4.get( 1 ) -
	+ m_t[i][2] * v4.get( 2 ) - m_t[i][3] * v4.get( 3 ) );
	}

	return temp;
	@@ -479,8 +479,8 @@
	int i;

	for ( i = 0; i < 4; i++ ) {
	- temp.set( i, t[0][i] * v4.get( 0 ) - t[1][i] * v4.get( 1 ) -
	- t[2][i] * v4.get( 2 ) - t[3][i] * v4.get( 3 ) );
	+ temp.set( i, m_t[0][i] * v4.get( 0 ) - m_t[1][i] * v4.get( 1 ) -
	+ m_t[2][i] * v4.get( 2 ) - m_t[3][i] * v4.get( 3 ) );
	}

	return temp;
	@@ -493,8 +493,8 @@
	int i;

	for ( i = 0; i < 4; i++ ) {
	- temp.set( i, t[i][0] * v4.get( 0 ) - t[i][1] * v4.get( 1 ) -
	- t[i][2] * v4.get( 2 ) - t[i][3] * v4.get( 3 ) );
	+ temp.set( i, m_t[i][0] * v4.get( 0 ) - m_t[i][1] * v4.get( 1 ) -
	+ m_t[i][2] * v4.get( 2 ) - m_t[i][3] * v4.get( 3 ) );
	}

	return temp;
	@@ -539,16 +539,16 @@
	for ( j = 0; j < 4; j++ ) {
	tt[i][j] = EvtComplex( 0.0 );
	for ( k = 0; k < 4; k++ ) {
	- tt[i][j] += lambda[j][k] * t[i][k];
	+ tt[i][j] += lambda[j][k] * m_t[i][k];
	}
	}
	}

	for ( i = 0; i < 4; i++ ) {
	for ( j = 0; j < 4; j++ ) {
	- t[i][j] = EvtComplex( 0.0 );
	+ m_t[i][j] = EvtComplex( 0.0 );
	for ( k = 0; k < 4; k++ ) {
	- t[i][j] += lambda[i][k] * tt[k][j];
	+ m_t[i][j] += lambda[i][k] * tt[k][j];
	}
	}
	}
	diff --git a/src/EvtGenBase/EvtTensorParticle.cpp b/src/EvtGenBase/EvtTensorParticle.cpp
	--- a/src/EvtGenBase/EvtTensorParticle.cpp
	+++ b/src/EvtGenBase/EvtTensorParticle.cpp
	@@ -42,23 +42,23 @@
	void EvtTensorParticle::init( EvtId part_n, double e, double px, double py,
	double pz )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( e, px, py, pz );
	setpart_num( part_n );

	- eps[0].setdiag( 0.0, -1.0 / sqrt( 6.0 ), -1.0 / sqrt( 6.0 ),
	- 2.0 / sqrt( 6.0 ) );
	- eps[1].setdiag( 0.0, 1.0 / sqrt( 2.0 ), -1.0 / sqrt( 2.0 ), 0.0 );
	- eps[2].setdiag( 0.0, 0.0, 0.0, 0.0 );
	- eps[3].setdiag( 0.0, 0.0, 0.0, 0.0 );
	- eps[4].setdiag( 0.0, 0.0, 0.0, 0.0 );
	+ m_eps[0].setdiag( 0.0, -1.0 / sqrt( 6.0 ), -1.0 / sqrt( 6.0 ),
	+ 2.0 / sqrt( 6.0 ) );
	+ m_eps[1].setdiag( 0.0, 1.0 / sqrt( 2.0 ), -1.0 / sqrt( 2.0 ), 0.0 );
	+ m_eps[2].setdiag( 0.0, 0.0, 0.0, 0.0 );
	+ m_eps[3].setdiag( 0.0, 0.0, 0.0, 0.0 );
	+ m_eps[4].setdiag( 0.0, 0.0, 0.0, 0.0 );

	- eps[2].set( 1, 2, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	- eps[2].set( 2, 1, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	- eps[3].set( 1, 3, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	- eps[3].set( 3, 1, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	- eps[4].set( 2, 3, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	- eps[4].set( 3, 2, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	+ m_eps[2].set( 1, 2, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	+ m_eps[2].set( 2, 1, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	+ m_eps[3].set( 1, 3, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	+ m_eps[3].set( 3, 1, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	+ m_eps[4].set( 2, 3, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );
	+ m_eps[4].set( 3, 2, EvtComplex( 1.0 / sqrt( 2.0 ), 0.0 ) );

	setLifetime();
	}
	@@ -70,33 +70,31 @@
	const EvtTensor4C& epsin4,
	const EvtTensor4C& epsin5 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( part_n );

	- eps[0] = epsin1;
	- eps[1] = epsin2;
	- eps[2] = epsin3;
	- eps[3] = epsin4;
	- eps[4] = epsin5;
	+ m_eps[0] = epsin1;
	+ m_eps[1] = epsin2;
	+ m_eps[2] = epsin3;
	+ m_eps[3] = epsin4;
	+ m_eps[4] = epsin5;

	setLifetime();
	}

	EvtTensor4C EvtTensorParticle::epsTensorParent( int i ) const
	{
	- assert( i >= 0 && i < eps.size() );
	+ assert( i >= 0 && i < m_eps.size() );

	- return boostTo( eps[i], this->getP4() );
	-
	-} //epsParent
	+ return boostTo( m_eps[i], this->getP4() );
	+}

	EvtTensor4C EvtTensorParticle::epsTensor( int i ) const
	{
	- assert( i >= 0 && i < eps.size() );
	- return eps[i];
	-
	-} //eps
	+ assert( i >= 0 && i < m_eps.size() );
	+ return m_eps[i];
	+}

	EvtSpinDensity EvtTensorParticle::rotateToHelicityBasis() const
	{
	@@ -130,11 +128,11 @@
	R.setDim( 5 );

	for ( int j = 0; j < 5; j++ ) {
	- R.set( 0, j, cont( es0, eps[j] ) );
	- R.set( 1, j, cont( es1, eps[j] ) );
	- R.set( 2, j, cont( es2, eps[j] ) );
	- R.set( 3, j, cont( es3, eps[j] ) );
	- R.set( 4, j, cont( es4, eps[j] ) );
	+ R.set( 0, j, cont( es0, m_eps[j] ) );
	+ R.set( 1, j, cont( es1, m_eps[j] ) );
	+ R.set( 2, j, cont( es2, m_eps[j] ) );
	+ R.set( 3, j, cont( es3, m_eps[j] ) );
	+ R.set( 4, j, cont( es4, m_eps[j] ) );
	}
	return R;
	}
	@@ -176,7 +174,7 @@

	for ( int i = 0; i < 5; i++ )
	for ( int j = 0; j < 5; j++ )
	- R.set( i, j, cont( es[i], eps[j] ) );
	+ R.set( i, j, cont( es[i], m_eps[j] ) );

	return R;
	}
	diff --git a/src/EvtGenBase/EvtTwoBodyKine.cpp b/src/EvtGenBase/EvtTwoBodyKine.cpp
	--- a/src/EvtGenBase/EvtTwoBodyKine.cpp
	+++ b/src/EvtGenBase/EvtTwoBodyKine.cpp
	@@ -29,12 +29,12 @@
	using std::endl;
	using std::ostream;

	-EvtTwoBodyKine::EvtTwoBodyKine() : _mA( 0. ), _mB( 0. ), _mAB( 0. )
	+EvtTwoBodyKine::EvtTwoBodyKine() : m_mA( 0. ), m_mB( 0. ), m_mAB( 0. )
	{
	}

	EvtTwoBodyKine::EvtTwoBodyKine( double mA, double mB, double mAB ) :
	- _mA( mA ), _mB( mB ), _mAB( mAB )
	+ m_mA( mA ), m_mB( mB ), m_mAB( mAB )
	{
	if ( mAB < mA + mB ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -45,11 +45,11 @@

	double EvtTwoBodyKine::m( Index i ) const
	{
	- double ret = _mAB;
	+ double ret = m_mAB;
	if ( A == i )
	- ret = _mA;
	+ ret = m_mA;
	else if ( B == i )
	- ret = _mB;
	+ ret = m_mB;

	return ret;
	}
	@@ -59,17 +59,17 @@
	double p0 = 0.;

	if ( i == AB ) {
	- double x = _mAB * _mAB - _mA * _mA - _mB * _mB;
	- double y = 2 * _mA * _mB;
	- p0 = sqrt( x * x - y * y ) / 2. / _mAB;
	+ double x = m_mAB * m_mAB - m_mA * m_mA - m_mB * m_mB;
	+ double y = 2 * m_mA * m_mB;
	+ p0 = sqrt( x * x - y * y ) / 2. / m_mAB;
	} else if ( i == A ) {
	- double x = _mA * _mA - _mAB * _mAB - _mB * _mB;
	- double y = 2 * _mAB * _mB;
	- p0 = sqrt( x * x - y * y ) / 2. / _mA;
	+ double x = m_mA * m_mA - m_mAB * m_mAB - m_mB * m_mB;
	+ double y = 2 * m_mAB * m_mB;
	+ p0 = sqrt( x * x - y * y ) / 2. / m_mA;
	} else {
	- double x = _mB * _mB - _mAB * _mAB - _mA * _mA;
	- double y = 2 * _mAB * _mA;
	- p0 = sqrt( x * x - y * y ) / 2. / _mB;
	+ double x = m_mB * m_mB - m_mAB * m_mAB - m_mA * m_mA;
	+ double y = 2 * m_mAB * m_mA;
	+ p0 = sqrt( x * x - y * y ) / 2. / m_mB;
	}

	return p0;
	@@ -87,9 +87,9 @@

	void EvtTwoBodyKine::print( ostream& os ) const
	{
	- os << " mA = " << _mA << endl;
	- os << " mB = " << _mB << endl;
	- os << "mAB = " << _mAB << endl;
	+ os << " mA = " << m_mA << endl;
	+ os << " mB = " << m_mB << endl;
	+ os << "mAB = " << m_mAB << endl;
	}

	ostream& operator<<( ostream& os, const EvtTwoBodyKine& p )
	diff --git a/src/EvtGenBase/EvtTwoBodyVertex.cpp b/src/EvtGenBase/EvtTwoBodyVertex.cpp
	--- a/src/EvtGenBase/EvtTwoBodyVertex.cpp
	+++ b/src/EvtGenBase/EvtTwoBodyVertex.cpp
	@@ -24,57 +24,58 @@
	#include "EvtGenBase/EvtPatches.hh"

	#include <assert.h>
	+#include <cmath>
	#include <iostream>
	-#include <math.h>
	+#include <memory>
	using std::endl;
	using std::ostream;

	// Default ctor can sometimes be useful

	-EvtTwoBodyVertex::EvtTwoBodyVertex() : _LL( 0 ), _p0( 0 )
	+EvtTwoBodyVertex::EvtTwoBodyVertex() : m_LL( 0 ), m_p0( 0 )
	{
	}

	EvtTwoBodyVertex::EvtTwoBodyVertex( double mA, double mB, double mAB, int L ) :
	- _kine(), _LL( L ), _p0( 0 )
	+ m_kine(), m_LL( L ), m_p0( 0 )
	{
	// Kinematics is initialized only if the decay is above threshold

	if ( mAB > mA + mB ) {
	- _kine = EvtTwoBodyKine( mA, mB, mAB );
	- _p0 = _kine.p();
	+ m_kine = EvtTwoBodyKine( mA, mB, mAB );
	+ m_p0 = m_kine.p();
	}
	}

	EvtTwoBodyVertex::EvtTwoBodyVertex( const EvtTwoBodyVertex& other ) :
	- _kine( other._kine ),
	- _LL( other._LL ),
	- _p0( other._p0 ),
	- _f( ( other._f ) ? new EvtBlattWeisskopf( *other._f ) : nullptr )
	+ m_kine( other.m_kine ),
	+ m_LL( other.m_LL ),
	+ m_p0( other.m_p0 ),
	+ m_f( ( other.m_f ) ? new EvtBlattWeisskopf( *other.m_f ) : nullptr )
	{
	}

	EvtTwoBodyVertex& EvtTwoBodyVertex::operator=( const EvtTwoBodyVertex& other )
	{
	- _kine = other._kine;
	- _LL = other._LL;
	- _p0 = other._p0;
	- _f.reset( other._f ? new EvtBlattWeisskopf( *other._f ) : nullptr );
	+ m_kine = other.m_kine;
	+ m_LL = other.m_LL;
	+ m_p0 = other.m_p0;
	+ m_f.reset( other.m_f ? new EvtBlattWeisskopf( *other.m_f ) : nullptr );
	return *this;
	}

	void EvtTwoBodyVertex::set_f( double R )
	{
	- _f = std::make_unique<EvtBlattWeisskopf>( _LL, R, _p0 );
	+ m_f = std::make_unique<EvtBlattWeisskopf>( m_LL, R, m_p0 );
	}

	double EvtTwoBodyVertex::widthFactor( EvtTwoBodyKine x ) const
	{
	- assert( _p0 > 0. );
	+ assert( m_p0 > 0. );

	double p1 = x.p();
	double ff = formFactor( x );
	- double factor = pow( p1 / _p0, 2 * _LL + 1 ) * mAB() / x.mAB() * ff * ff;
	+ double factor = pow( p1 / m_p0, 2 * m_LL + 1 ) * mAB() / x.mAB() * ff * ff;

	return factor;
	}
	@@ -83,7 +84,7 @@
	EvtTwoBodyKine::Index i ) const
	{
	double p1 = x.p( i );
	- double factor = pow( p1, _LL );
	+ double factor = pow( p1, m_LL );
	return factor;
	}

	@@ -91,9 +92,9 @@
	{
	double ff = 1.;

	- if ( _f ) {
	+ if ( m_f ) {
	double p1 = x.p();
	- ff = ( *_f )( p1 );
	+ ff = ( *m_f )( p1 );
	}

	return ff;
	@@ -104,8 +105,8 @@
	os << " mA = " << mA() << endl;
	os << " mB = " << mB() << endl;
	os << "mAB = " << mAB() << endl;
	- os << " L = " << _LL << endl;
	- os << " p0 = " << _p0 << endl;
	+ os << " L = " << m_LL << endl;
	+ os << " p0 = " << m_p0 << endl;
	}

	ostream& operator<<( ostream& os, const EvtTwoBodyVertex& v )
	diff --git a/src/EvtGenBase/EvtValError.cpp b/src/EvtGenBase/EvtValError.cpp
	--- a/src/EvtGenBase/EvtValError.cpp
	+++ b/src/EvtGenBase/EvtValError.cpp
	@@ -29,81 +29,81 @@
	using std::ostream;

	EvtValError::EvtValError() :
	- _valKnown( 0 ), _val( 0. ), _errKnown( 0 ), _err( 0. )
	+ m_valKnown( 0 ), m_val( 0. ), m_errKnown( 0 ), m_err( 0. )
	{
	}

	EvtValError::EvtValError( double val ) :
	- _valKnown( 1 ), _val( val ), _errKnown( 0 ), _err( 0. )
	+ m_valKnown( 1 ), m_val( val ), m_errKnown( 0 ), m_err( 0. )
	{
	}

	EvtValError::EvtValError( double val, double err ) :
	- _valKnown( 1 ), _val( val ), _errKnown( 1 ), _err( err )
	+ m_valKnown( 1 ), m_val( val ), m_errKnown( 1 ), m_err( err )
	{
	}

	EvtValError::EvtValError( const EvtValError& other ) :
	- _valKnown( other._valKnown ),
	- _val( other._val ),
	- _errKnown( other._errKnown ),
	- _err( other._err )
	+ m_valKnown( other.m_valKnown ),
	+ m_val( other.m_val ),
	+ m_errKnown( other.m_errKnown ),
	+ m_err( other.m_err )
	{
	}

	double EvtValError::prec() const
	{
	- assert( _valKnown && _errKnown );
	- return ( _val != 0 ) ? _err / _val : 0;
	+ assert( m_valKnown && m_errKnown );
	+ return ( m_val != 0 ) ? m_err / m_val : 0;
	}

	void EvtValError::operator=( const EvtValError& other )
	{
	- _valKnown = other._valKnown;
	- _val = other._val;
	- _errKnown = other._errKnown;
	- _err = other._err;
	+ m_valKnown = other.m_valKnown;
	+ m_val = other.m_val;
	+ m_errKnown = other.m_errKnown;
	+ m_err = other.m_err;
	}

	void EvtValError::operator*=( const EvtValError& other )
	{
	- assert( _valKnown && other._valKnown );
	+ assert( m_valKnown && other.m_valKnown );

	// Relative errors add in quadrature
	- if ( _errKnown && other._errKnown )
	- _err = _val * other._val *
	- sqrt( prec() * prec() + other.prec() * other.prec() );
	+ if ( m_errKnown && other.m_errKnown )
	+ m_err = m_val * other.m_val *
	+ sqrt( prec() * prec() + other.prec() * other.prec() );
	else
	- _errKnown = 0;
	+ m_errKnown = 0;

	// Modify the value
	- _val *= other._val;
	+ m_val *= other.m_val;
	}

	void EvtValError::operator/=( const EvtValError& other )
	{
	- assert( _valKnown && other._valKnown && other._val != 0. );
	+ assert( m_valKnown && other.m_valKnown && other.m_val != 0. );

	// Relative errors add in quadrature
	- if ( _errKnown && other._errKnown )
	- _err = _val / other._val *
	- sqrt( prec() * prec() + other.prec() * other.prec() );
	+ if ( m_errKnown && other.m_errKnown )
	+ m_err = m_val / other.m_val *
	+ sqrt( prec() * prec() + other.prec() * other.prec() );
	else
	- _errKnown = 0;
	+ m_errKnown = 0;

	// Modify the value
	- _val /= other._val;
	+ m_val /= other.m_val;
	}

	void EvtValError::print( ostream& os ) const
	{
	- if ( _valKnown )
	- os << _val;
	+ if ( m_valKnown )
	+ os << m_val;
	else
	os << "Undef";
	os << " +/- ";
	- if ( _errKnown )
	- os << _err;
	+ if ( m_errKnown )
	+ os << m_err;
	else
	os << "Undef";
	os << endl;
	@@ -111,25 +111,25 @@

	void EvtValError::operator+=( const EvtValError& other )
	{
	- assert( _valKnown );
	- assert( other._valKnown );
	- _val += other._val;
	+ assert( m_valKnown );
	+ assert( other.m_valKnown );
	+ m_val += other.m_val;

	// add errors in quadrature

	- if ( _errKnown && other._errKnown ) {
	- _err = sqrt( _err * _err + other._err * other._err );
	+ if ( m_errKnown && other.m_errKnown ) {
	+ m_err = sqrt( m_err * m_err + other.m_err * other.m_err );
	} else {
	- _errKnown = 0;
	+ m_errKnown = 0;
	}
	}

	void EvtValError::operator*=( double c )
	{
	- assert( _valKnown );
	- _val *= c;
	- if ( _errKnown )
	- _err *= c;
	+ assert( m_valKnown );
	+ m_val *= c;
	+ if ( m_errKnown )
	+ m_err *= c;
	}

	EvtValError operator*( const EvtValError& x1, const EvtValError& x2 )
	diff --git a/src/EvtGenBase/EvtVector3C.cpp b/src/EvtGenBase/EvtVector3C.cpp
	--- a/src/EvtGenBase/EvtVector3C.cpp
	+++ b/src/EvtGenBase/EvtVector3C.cpp
	@@ -29,17 +29,17 @@

	EvtVector3C::EvtVector3C()
	{
	- v[0] = EvtComplex( 0.0 );
	- v[1] = EvtComplex( 0.0 );
	- v[2] = EvtComplex( 0.0 );
	+ m_v[0] = EvtComplex( 0.0 );
	+ m_v[1] = EvtComplex( 0.0 );
	+ m_v[2] = EvtComplex( 0.0 );
	}

	EvtVector3C::EvtVector3C( const EvtComplex& e1, const EvtComplex& e2,
	const EvtComplex& e3 )
	{
	- v[0] = e1;
	- v[1] = e2;
	- v[2] = e3;
	+ m_v[0] = e1;
	+ m_v[1] = e2;
	+ m_v[2] = e3;
	}

	EvtVector3C EvtVector3C::cross( const EvtVector3C& p2 )
	@@ -48,9 +48,9 @@

	EvtVector3C temp;

	- temp.v[0] = v[1] * p2.v[2] - v[2] * p2.v[1];
	- temp.v[1] = v[2] * p2.v[0] - v[0] * p2.v[2];
	- temp.v[2] = v[0] * p2.v[1] - v[1] * p2.v[0];
	+ temp.m_v[0] = m_v[1] * p2.m_v[2] - m_v[2] * p2.m_v[1];
	+ temp.m_v[1] = m_v[2] * p2.m_v[0] - m_v[0] * p2.m_v[2];
	+ temp.m_v[2] = m_v[0] * p2.m_v[1] - m_v[1] * p2.m_v[0];

	return temp;
	}
	@@ -75,20 +75,20 @@
	ct = cos( theta );
	ck = cos( ksi );

	- temp[0] = ( ck * ct * cp - sk * sp ) * v[0] +
	- ( -sk * ct * cp - ck * sp ) * v[1] + st * cp * v[2];
	- temp[1] = ( ck * ct * sp + sk * cp ) * v[0] +
	- ( -sk * ct * sp + ck * cp ) * v[1] + st * sp * v[2];
	- temp[2] = -ck * st * v[0] + sk * st * v[1] + ct * v[2];
	+ temp[0] = ( ck * ct * cp - sk * sp ) * m_v[0] +
	+ ( -sk * ct * cp - ck * sp ) * m_v[1] + st * cp * m_v[2];
	+ temp[1] = ( ck * ct * sp + sk * cp ) * m_v[0] +
	+ ( -sk * ct * sp + ck * cp ) * m_v[1] + st * sp * m_v[2];
	+ temp[2] = -ck * st * m_v[0] + sk * st * m_v[1] + ct * m_v[2];

	- v[0] = temp[0];
	- v[1] = temp[1];
	- v[2] = temp[2];
	+ m_v[0] = temp[0];
	+ m_v[1] = temp[1];
	+ m_v[2] = temp[2];
	}

	ostream& operator<<( ostream& s, const EvtVector3C& v )
	{
	- s << "(" << v.v[0] << "," << v.v[1] << "," << v.v[2] << ")";
	+ s << "(" << v.m_v[0] << "," << v.m_v[1] << "," << v.m_v[2] << ")";

	return s;
	}
	diff --git a/src/EvtGenBase/EvtVector3R.cpp b/src/EvtGenBase/EvtVector3R.cpp
	--- a/src/EvtGenBase/EvtVector3R.cpp
	+++ b/src/EvtGenBase/EvtVector3R.cpp
	@@ -28,14 +28,14 @@

	EvtVector3R::EvtVector3R()
	{
	- v[0] = v[1] = v[2] = 0.0;
	+ m_v[0] = m_v[1] = m_v[2] = 0.0;
	}

	EvtVector3R::EvtVector3R( double x, double y, double z )
	{
	- v[0] = x;
	- v[1] = y;
	- v[2] = z;
	+ m_v[0] = x;
	+ m_v[1] = y;
	+ m_v[2] = z;
	}

	EvtVector3R rotateEuler( const EvtVector3R& v, double alpha, double beta,
	@@ -58,20 +58,20 @@
	ct = cos( theta );
	ck = cos( ksi );

	- temp[0] = ( ck * ct * cp - sk * sp ) * v[0] +
	- ( -sk * ct * cp - ck * sp ) * v[1] + st * cp * v[2];
	- temp[1] = ( ck * ct * sp + sk * cp ) * v[0] +
	- ( -sk * ct * sp + ck * cp ) * v[1] + st * sp * v[2];
	- temp[2] = -ck * st * v[0] + sk * st * v[1] + ct * v[2];
	+ temp[0] = ( ck * ct * cp - sk * sp ) * m_v[0] +
	+ ( -sk * ct * cp - ck * sp ) * m_v[1] + st * cp * m_v[2];
	+ temp[1] = ( ck * ct * sp + sk * cp ) * m_v[0] +
	+ ( -sk * ct * sp + ck * cp ) * m_v[1] + st * sp * m_v[2];
	+ temp[2] = -ck * st * m_v[0] + sk * st * m_v[1] + ct * m_v[2];

	- v[0] = temp[0];
	- v[1] = temp[1];
	- v[2] = temp[2];
	+ m_v[0] = temp[0];
	+ m_v[1] = temp[1];
	+ m_v[2] = temp[2];
	}

	ostream& operator<<( ostream& s, const EvtVector3R& v )
	{
	- s << "(" << v.v[0] << "," << v.v[1] << "," << v.v[2] << ")";
	+ s << "(" << v.m_v[0] << "," << v.m_v[1] << "," << v.m_v[2] << ")";

	return s;
	}
	@@ -81,9 +81,9 @@
	//Calcs the cross product. Added by djl on July 27, 1995.
	//Modified for real vectros by ryd Aug 28-96

	- return EvtVector3R( p1.v[1] * p2.v[2] - p1.v[2] * p2.v[1],
	- p1.v[2] * p2.v[0] - p1.v[0] * p2.v[2],
	- p1.v[0] * p2.v[1] - p1.v[1] * p2.v[0] );
	+ return EvtVector3R( p1.m_v[1] * p2.m_v[2] - p1.m_v[2] * p2.m_v[1],
	+ p1.m_v[2] * p2.m_v[0] - p1.m_v[0] * p2.m_v[2],
	+ p1.m_v[0] * p2.m_v[1] - p1.m_v[1] * p2.m_v[0] );
	}

	double EvtVector3R::d3mag() const
	@@ -91,7 +91,7 @@
	// Returns the 3 momentum mag
	double temp;

	- temp = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
	+ temp = m_v[0] * m_v[0] + m_v[1] * m_v[1] + m_v[2] * m_v[2];
	temp = sqrt( temp );

	return temp;
	@@ -101,9 +101,9 @@
	{
	double temp;

	- temp = v[0] * p2.v[0];
	- temp += v[1] * p2.v[1];
	- temp += v[2] * p2.v[2];
	+ temp = m_v[0] * p2.m_v[0];
	+ temp += m_v[1] * p2.m_v[1];
	+ temp += m_v[2] * p2.m_v[2];

	return temp;
	}
	diff --git a/src/EvtGenBase/EvtVector4C.cpp b/src/EvtGenBase/EvtVector4C.cpp
	--- a/src/EvtGenBase/EvtVector4C.cpp
	+++ b/src/EvtGenBase/EvtVector4C.cpp
	@@ -30,19 +30,19 @@

	EvtVector4C::EvtVector4C()
	{
	- v[0] = EvtComplex( 0.0 );
	- v[1] = EvtComplex( 0.0 );
	- v[2] = EvtComplex( 0.0 );
	- v[3] = EvtComplex( 0.0 );
	+ m_v[0] = EvtComplex( 0.0 );
	+ m_v[1] = EvtComplex( 0.0 );
	+ m_v[2] = EvtComplex( 0.0 );
	+ m_v[3] = EvtComplex( 0.0 );
	}

	EvtVector4C::EvtVector4C( const EvtComplex& e0, const EvtComplex& e1,
	const EvtComplex& e2, const EvtComplex& e3 )
	{
	- v[0] = e0;
	- v[1] = e1;
	- v[2] = e2;
	- v[3] = e3;
	+ m_v[0] = e0;
	+ m_v[1] = e1;
	+ m_v[2] = e2;
	+ m_v[3] = e3;
	}

	EvtVector4C rotateEuler( const EvtVector4C& rs, double alpha, double beta,
	@@ -110,18 +110,18 @@
	double gby = gamma * by;
	double gbz = gamma * bz;

	- EvtComplex e2 = v[0];
	- EvtComplex px2 = v[1];
	- EvtComplex py2 = v[2];
	- EvtComplex pz2 = v[3];
	+ EvtComplex e2 = m_v[0];
	+ EvtComplex px2 = m_v[1];
	+ EvtComplex py2 = m_v[2];
	+ EvtComplex pz2 = m_v[3];

	- v[0] = gamma * e2 + gbx * px2 + gby * py2 + gbz * pz2;
	+ m_v[0] = gamma * e2 + gbx * px2 + gby * py2 + gbz * pz2;

	- v[1] = gbx * e2 + gb2 * bxx * px2 + px2 + gb2xy * py2 + gb2xz * pz2;
	+ m_v[1] = gbx * e2 + gb2 * bxx * px2 + px2 + gb2xy * py2 + gb2xz * pz2;

	- v[2] = gby * e2 + gb2 * byy * py2 + py2 + gb2xy * px2 + gb2yz * pz2;
	+ m_v[2] = gby * e2 + gb2 * byy * py2 + py2 + gb2xy * px2 + gb2yz * pz2;

	- v[3] = gbz * e2 + gb2 * bzz * pz2 + pz2 + gb2yz * py2 + gb2xz * px2;
	+ m_v[3] = gbz * e2 + gb2 * bzz * pz2 + pz2 + gb2yz * py2 + gb2xz * px2;

	return;
	}
	@@ -135,20 +135,21 @@
	double ct = cos( theta );
	double ck = cos( ksi );

	- EvtComplex x = ( ck * ct * cp - sk * sp ) * v[1] +
	- ( -sk * ct * cp - ck * sp ) * v[2] + st * cp * v[3];
	- EvtComplex y = ( ck * ct * sp + sk * cp ) * v[1] +
	- ( -sk * ct * sp + ck * cp ) * v[2] + st * sp * v[3];
	- EvtComplex z = -ck * st * v[1] + sk * st * v[2] + ct * v[3];
	+ EvtComplex x = ( ck * ct * cp - sk * sp ) * m_v[1] +
	+ ( -sk * ct * cp - ck * sp ) * m_v[2] + st * cp * m_v[3];
	+ EvtComplex y = ( ck * ct * sp + sk * cp ) * m_v[1] +
	+ ( -sk * ct * sp + ck * cp ) * m_v[2] + st * sp * m_v[3];
	+ EvtComplex z = -ck * st * m_v[1] + sk * st * m_v[2] + ct * m_v[3];

	- v[1] = x;
	- v[2] = y;
	- v[3] = z;
	+ m_v[1] = x;
	+ m_v[2] = y;
	+ m_v[3] = z;
	}

	ostream& operator<<( ostream& s, const EvtVector4C& v )
	{
	- s << "(" << v.v[0] << "," << v.v[1] << "," << v.v[2] << "," << v.v[3] << ")";
	+ s << "(" << v.m_v[0] << "," << v.m_v[1] << "," << v.m_v[2] << ","
	+ << v.m_v[3] << ")";

	return s;
	}
	diff --git a/src/EvtGenBase/EvtVector4R.cpp b/src/EvtGenBase/EvtVector4R.cpp
	--- a/src/EvtGenBase/EvtVector4R.cpp
	+++ b/src/EvtGenBase/EvtVector4R.cpp
	@@ -32,23 +32,24 @@

	EvtVector4R::EvtVector4R()
	{
	- v[0] = 0.0;
	- v[1] = 0.0;
	- v[2] = 0.0;
	- v[3] = 0.0;
	+ m_v[0] = 0.0;
	+ m_v[1] = 0.0;
	+ m_v[2] = 0.0;
	+ m_v[3] = 0.0;
	}

	EvtVector4R::EvtVector4R( double e, double p1, double p2, double p3 )
	{
	- v[0] = e;
	- v[1] = p1;
	- v[2] = p2;
	- v[3] = p3;
	+ m_v[0] = e;
	+ m_v[1] = p1;
	+ m_v[2] = p2;
	+ m_v[3] = p3;
	}

	double EvtVector4R::mass() const
	{
	- double m2 = v[0] * v[0] - v[1] * v[1] - v[2] * v[2] - v[3] * v[3];
	+ double m2 = m_v[0] * m_v[0] - m_v[1] * m_v[1] - m_v[2] * m_v[2] -
	+ m_v[3] * m_v[3];

	if ( m2 > 0.0 ) {
	return sqrt( m2 );
	@@ -89,20 +90,21 @@
	double ct = cos( theta );
	double ck = cos( ksi );

	- double x = ( ck * ct * cp - sk * sp ) * v[1] +
	- ( -sk * ct * cp - ck * sp ) * v[2] + st * cp * v[3];
	- double y = ( ck * ct * sp + sk * cp ) * v[1] +
	- ( -sk * ct * sp + ck * cp ) * v[2] + st * sp * v[3];
	- double z = -ck * st * v[1] + sk * st * v[2] + ct * v[3];
	+ double x = ( ck * ct * cp - sk * sp ) * m_v[1] +
	+ ( -sk * ct * cp - ck * sp ) * m_v[2] + st * cp * m_v[3];
	+ double y = ( ck * ct * sp + sk * cp ) * m_v[1] +
	+ ( -sk * ct * sp + ck * cp ) * m_v[2] + st * sp * m_v[3];
	+ double z = -ck * st * m_v[1] + sk * st * m_v[2] + ct * m_v[3];

	- v[1] = x;
	- v[2] = y;
	- v[3] = z;
	+ m_v[1] = x;
	+ m_v[2] = y;
	+ m_v[3] = z;
	}

	ostream& operator<<( ostream& s, const EvtVector4R& v )
	{
	- s << "(" << v.v[0] << "," << v.v[1] << "," << v.v[2] << "," << v.v[3] << ")";
	+ s << "(" << v.m_v[0] << "," << v.m_v[1] << "," << v.m_v[2] << ","
	+ << v.m_v[3] << ")";

	return s;
	}
	@@ -145,27 +147,30 @@
	double gby = gamma * by;
	double gbz = gamma * bz;

	- double e2 = v[0];
	- double px2 = v[1];
	- double py2 = v[2];
	- double pz2 = v[3];
	+ double e2 = m_v[0];
	+ double px2 = m_v[1];
	+ double py2 = m_v[2];
	+ double pz2 = m_v[3];

	if ( inverse ) {
	- v[0] = gamma * e2 - gbx * px2 - gby * py2 - gbz * pz2;
	+ m_v[0] = gamma * e2 - gbx * px2 - gby * py2 - gbz * pz2;

	- v[1] = -gbx * e2 + gb2 * bxx * px2 + px2 + gb2xy * py2 + gb2xz * pz2;
	+ m_v[1] = -gbx * e2 + gb2 * bxx * px2 + px2 + gb2xy * py2 +
	+ gb2xz * pz2;

	- v[2] = -gby * e2 + gb2 * byy * py2 + py2 + gb2xy * px2 + gb2yz * pz2;
	+ m_v[2] = -gby * e2 + gb2 * byy * py2 + py2 + gb2xy * px2 +
	+ gb2yz * pz2;

	- v[3] = -gbz * e2 + gb2 * bzz * pz2 + pz2 + gb2yz * py2 + gb2xz * px2;
	+ m_v[3] = -gbz * e2 + gb2 * bzz * pz2 + pz2 + gb2yz * py2 +
	+ gb2xz * px2;
	} else {
	- v[0] = gamma * e2 + gbx * px2 + gby * py2 + gbz * pz2;
	+ m_v[0] = gamma * e2 + gbx * px2 + gby * py2 + gbz * pz2;

	- v[1] = gbx * e2 + gb2 * bxx * px2 + px2 + gb2xy * py2 + gb2xz * pz2;
	+ m_v[1] = gbx * e2 + gb2 * bxx * px2 + px2 + gb2xy * py2 + gb2xz * pz2;

	- v[2] = gby * e2 + gb2 * byy * py2 + py2 + gb2xy * px2 + gb2yz * pz2;
	+ m_v[2] = gby * e2 + gb2 * byy * py2 + py2 + gb2xy * px2 + gb2yz * pz2;

	- v[3] = gbz * e2 + gb2 * bzz * pz2 + pz2 + gb2yz * py2 + gb2xz * px2;
	+ m_v[3] = gbz * e2 + gb2 * bzz * pz2 + pz2 + gb2yz * py2 + gb2xz * px2;
	}
	}
	}
	@@ -177,10 +182,10 @@

	EvtVector4R temp;

	- temp.v[0] = 0.0;
	- temp.v[1] = v[2] * p2.v[3] - v[3] * p2.v[2];
	- temp.v[2] = v[3] * p2.v[1] - v[1] * p2.v[3];
	- temp.v[3] = v[1] * p2.v[2] - v[2] * p2.v[1];
	+ temp.m_v[0] = 0.0;
	+ temp.m_v[1] = m_v[2] * p2.m_v[3] - m_v[3] * p2.m_v[2];
	+ temp.m_v[2] = m_v[3] * p2.m_v[1] - m_v[1] * p2.m_v[3];
	+ temp.m_v[3] = m_v[1] * p2.m_v[2] - m_v[2] * p2.m_v[1];

	return temp;
	}
	@@ -191,7 +196,7 @@
	{
	double temp;

	- temp = v[1] * v[1] + v[2] * v[2] + v[3] * v[3];
	+ temp = m_v[1] * m_v[1] + m_v[2] * m_v[2] + m_v[3] * m_v[3];

	temp = sqrt( temp );

	@@ -205,9 +210,9 @@

	double temp;

	- temp = v[1] * p2.v[1];
	- temp += v[2] * p2.v[2];
	- temp += v[3] * p2.v[3];
	+ temp = m_v[1] * p2.m_v[1];
	+ temp += m_v[2] * p2.m_v[2];
	+ temp += m_v[3] * p2.m_v[3];

	return temp;

	diff --git a/src/EvtGenBase/EvtVectorParticle.cpp b/src/EvtGenBase/EvtVectorParticle.cpp
	--- a/src/EvtGenBase/EvtVectorParticle.cpp
	+++ b/src/EvtGenBase/EvtVectorParticle.cpp
	@@ -33,26 +33,26 @@
	void EvtVectorParticle::init( EvtId part_n, double e, double px, double py,
	double pz )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( e, px, py, pz );
	setpart_num( part_n );

	- _eps[0].set( 0.0, 1.0, 0.0, 0.0 );
	- _eps[1].set( 0.0, 0.0, 1.0, 0.0 );
	- _eps[2].set( 0.0, 0.0, 0.0, 1.0 );
	+ m_eps[0].set( 0.0, 1.0, 0.0, 0.0 );
	+ m_eps[1].set( 0.0, 0.0, 1.0, 0.0 );
	+ m_eps[2].set( 0.0, 0.0, 0.0, 1.0 );

	setLifetime();
	}

	void EvtVectorParticle::init( EvtId part_n, const EvtVector4R& p4 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( part_n );

	- _eps[0].set( 0.0, 1.0, 0.0, 0.0 );
	- _eps[1].set( 0.0, 0.0, 1.0, 0.0 );
	- _eps[2].set( 0.0, 0.0, 0.0, 1.0 );
	+ m_eps[0].set( 0.0, 1.0, 0.0, 0.0 );
	+ m_eps[1].set( 0.0, 0.0, 1.0, 0.0 );
	+ m_eps[2].set( 0.0, 0.0, 0.0, 1.0 );
	setLifetime();
	}

	@@ -61,13 +61,13 @@
	const EvtVector4C& epsin2,
	const EvtVector4C& epsin3 )
	{
	- _validP4 = true;
	+ m_validP4 = true;
	setp( p4 );
	setpart_num( part_n );

	- _eps[0] = epsin1;
	- _eps[1] = epsin2;
	- _eps[2] = epsin3;
	+ m_eps[0] = epsin1;
	+ m_eps[1] = epsin2;
	+ m_eps[2] = epsin3;

	setLifetime();
	}
	@@ -88,9 +88,9 @@
	R.setDim( 3 );

	for ( int i = 0; i < 3; i++ ) {
	- R.set( 0, i, (eplusC)*_eps[i] );
	- R.set( 1, i, (ezeroC)*_eps[i] );
	- R.set( 2, i, (eminusC)*_eps[i] );
	+ R.set( 0, i, (eplusC)*m_eps[i] );
	+ R.set( 1, i, (ezeroC)*m_eps[i] );
	+ R.set( 2, i, (eminusC)*m_eps[i] );
	}

	return R;
	@@ -114,9 +114,9 @@
	R.setDim( 3 );

	for ( int i = 0; i < 3; i++ ) {
	- R.set( 0, i, ( eplus.conj() ) * _eps[i] );
	- R.set( 1, i, ( ezero.conj() ) * _eps[i] );
	- R.set( 2, i, ( eminus.conj() ) * _eps[i] );
	+ R.set( 0, i, ( eplus.conj() ) * m_eps[i] );
	+ R.set( 1, i, ( ezero.conj() ) * m_eps[i] );
	+ R.set( 2, i, ( eminus.conj() ) * m_eps[i] );
	}

	return R;
	diff --git a/src/EvtGenBase/EvtdFunctionSingle.cpp b/src/EvtGenBase/EvtdFunctionSingle.cpp
	--- a/src/EvtGenBase/EvtdFunctionSingle.cpp
	+++ b/src/EvtGenBase/EvtdFunctionSingle.cpp
	@@ -29,18 +29,18 @@

	EvtdFunctionSingle::EvtdFunctionSingle()
	{
	- _j = 0;
	- _m1 = 0;
	- _m2 = 0;
	- _coef = nullptr;
	- _kmin = 0;
	- _kmax = 0;
	+ m_j = 0;
	+ m_m1 = 0;
	+ m_m2 = 0;
	+ m_coef = nullptr;
	+ m_kmin = 0;
	+ m_kmax = 0;
	}

	EvtdFunctionSingle::~EvtdFunctionSingle()
	{
	- if ( _coef != nullptr )
	- delete[] _coef;
	+ if ( m_coef != nullptr )
	+ delete[] m_coef;
	}

	void EvtdFunctionSingle::init( int j, int m1, int m2 )
	@@ -48,38 +48,38 @@
	assert( abs( m2 ) >= abs( m1 ) );
	assert( m2 >= 0 );

	- _j = j;
	- _m1 = m1;
	- _m2 = m2;
	+ m_j = j;
	+ m_m1 = m1;
	+ m_m2 = m2;

	- _kmin = _m2 - _m1;
	- _kmax = _j - _m1;
	+ m_kmin = m_m2 - m_m1;
	+ m_kmax = m_j - m_m1;

	- assert( _kmin <= _kmax );
	+ assert( m_kmin <= m_kmax );

	- _coef = new double[( _kmax - _kmin ) / 2 + 1];
	+ m_coef = new double[( m_kmax - m_kmin ) / 2 + 1];

	int k;

	- for ( k = _kmin; k <= _kmax; k += 2 ) {
	+ for ( k = m_kmin; k <= m_kmax; k += 2 ) {
	int sign = 1;
	- if ( ( k - _m2 + _m1 ) % 4 != 0 )
	+ if ( ( k - m_m2 + m_m1 ) % 4 != 0 )
	sign = -sign;
	- double tmp = fact( ( _j + _m2 ) / 2 ) * fact( ( _j - _m2 ) / 2 ) *
	- fact( ( _j + _m1 ) / 2 ) * fact( ( _j - _m1 ) / 2 );
	- _coef[( k - _kmin ) / 2] =
	+ double tmp = fact( ( m_j + m_m2 ) / 2 ) * fact( ( m_j - m_m2 ) / 2 ) *
	+ fact( ( m_j + m_m1 ) / 2 ) * fact( ( m_j - m_m1 ) / 2 );
	+ m_coef[( k - m_kmin ) / 2] =
	sign * sqrt( tmp ) /
	- ( fact( ( _j + _m2 - k ) / 2 ) * fact( k / 2 ) *
	- fact( ( _j - _m1 - k ) / 2 ) * fact( ( k - _m2 + _m1 ) / 2 ) );
	+ ( fact( ( m_j + m_m2 - k ) / 2 ) * fact( k / 2 ) *
	+ fact( ( m_j - m_m1 - k ) / 2 ) * fact( ( k - m_m2 + m_m1 ) / 2 ) );
	}
	}

	double EvtdFunctionSingle::d( int j, int m1, int m2, double theta )
	{
	- assert( j == _j );
	- _unused( j );
	- assert( m1 == _m1 );
	- assert( m2 == _m2 );
	+ assert( j == m_j );
	+ UNUSED( j );
	+ assert( m1 == m_m1 );
	+ assert( m2 == m_m2 );

	double c2 = cos( 0.5 * theta );
	double s2 = sin( 0.5 * theta );
	@@ -87,9 +87,9 @@
	double d = 0.0;

	int k;
	- for ( k = _kmin; k <= _kmax; k += 2 ) {
	- d += _coef[( k - _kmin ) / 2] *
	- pow( c2, ( 2 * _j - 2 * k + m2 - m1 ) / 2 ) *
	+ for ( k = m_kmin; k <= m_kmax; k += 2 ) {
	+ d += m_coef[( k - m_kmin ) / 2] *
	+ pow( c2, ( 2 * m_j - 2 * k + m2 - m1 ) / 2 ) *
	pow( s2, ( 2 * k - m2 + m1 ) / 2 );
	}

	diff --git a/src/EvtGenExternal/EvtExternalGenFactory.cpp b/src/EvtGenExternal/EvtExternalGenFactory.cpp
	--- a/src/EvtGenExternal/EvtExternalGenFactory.cpp
	+++ b/src/EvtGenExternal/EvtExternalGenFactory.cpp
	@@ -36,18 +36,18 @@

	EvtExternalGenFactory::EvtExternalGenFactory()
	{
	- _extGenMap.clear();
	+ m_extGenMap.clear();
	}

	EvtExternalGenFactory::~EvtExternalGenFactory()
	{
	ExtGenMap::iterator iter;
	- for ( iter = _extGenMap.begin(); iter != _extGenMap.end(); ++iter ) {
	+ for ( iter = m_extGenMap.begin(); iter != m_extGenMap.end(); ++iter ) {
	EvtAbsExternalGen* theGenerator = iter->second;
	delete theGenerator;
	}

	- _extGenMap.clear();
	+ m_extGenMap.clear();
	}

	EvtExternalGenFactory* EvtExternalGenFactory::getInstance()
	@@ -67,7 +67,7 @@
	bool convertPhysCodes,
	bool useEvtGenRandom )
	{
	- int genId = EvtExternalGenFactory::PythiaGenId;
	+ GenId genId = EvtExternalGenFactory::PythiaGenId;

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Defining EvtPythiaEngine: data tables defined in " << xmlDir << endl;
	@@ -87,7 +87,7 @@

	EvtAbsExternalGen* pythiaGenerator =
	new EvtPythiaEngine( xmlDir, convertPhysCodes, useEvtGenRandom );
	- _extGenMap[genId] = pythiaGenerator;
	+ m_extGenMap[genId] = pythiaGenerator;
	}
	#else
	void EvtExternalGenFactory::definePythiaGenerator( std::string, bool, bool )
	@@ -98,12 +98,12 @@
	#ifdef EVTGEN_TAUOLA
	void EvtExternalGenFactory::defineTauolaGenerator( bool useEvtGenRandom )
	{
	- int genId = EvtExternalGenFactory::TauolaGenId;
	+ GenId genId = EvtExternalGenFactory::TauolaGenId;

	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Defining EvtTauolaEngine." << endl;

	EvtAbsExternalGen* tauolaGenerator = new EvtTauolaEngine( useEvtGenRandom );
	- _extGenMap[genId] = tauolaGenerator;
	+ m_extGenMap[genId] = tauolaGenerator;
	}
	#else
	void EvtExternalGenFactory::defineTauolaGenerator( bool )
	@@ -111,13 +111,13 @@
	}
	#endif

	-EvtAbsExternalGen* EvtExternalGenFactory::getGenerator( int genId )
	+EvtAbsExternalGen* EvtExternalGenFactory::getGenerator( GenId genId )
	{
	EvtAbsExternalGen* theGenerator( nullptr );

	ExtGenMap::iterator iter;

	- if ( ( iter = _extGenMap.find( genId ) ) != _extGenMap.end() ) {
	+ if ( ( iter = m_extGenMap.find( genId ) ) != m_extGenMap.end() ) {
	// Retrieve the external generator engine
	theGenerator = iter->second;

	@@ -133,7 +133,7 @@
	void EvtExternalGenFactory::initialiseAllGenerators()
	{
	ExtGenMap::iterator iter;
	- for ( iter = _extGenMap.begin(); iter != _extGenMap.end(); ++iter ) {
	+ for ( iter = m_extGenMap.begin(); iter != m_extGenMap.end(); ++iter ) {
	EvtAbsExternalGen* theGenerator = iter->second;
	if ( theGenerator != nullptr ) {
	theGenerator->initialise();
	diff --git a/src/EvtGenExternal/EvtPHOTOS.cpp b/src/EvtGenExternal/EvtPHOTOS.cpp
	--- a/src/EvtGenExternal/EvtPHOTOS.cpp
	+++ b/src/EvtGenExternal/EvtPHOTOS.cpp
	@@ -35,14 +35,14 @@
	using std::endl;

	// Mutex PHOTOS as it is not thread safe.
	-std::mutex EvtPHOTOS::photos_mutex;
	+std::mutex EvtPHOTOS::m_photos_mutex;

	EvtPHOTOS::EvtPHOTOS( const std::string& photonType, const bool useEvtGenRandom,
	const double infraredCutOff,
	const double maxWtInterference ) :
	m_photonType{ photonType }
	{
	- photos_mutex.lock();
	+ m_photos_mutex.lock();

	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Setting up PHOTOS." << endl;

	@@ -77,7 +77,7 @@
	Photospp::Photos::setPairEmission( false );
	#endif

	- photos_mutex.unlock();
	+ m_photos_mutex.unlock();
	}

	void EvtPHOTOS::initialise()
	@@ -149,7 +149,7 @@
	}
	}

	- photos_mutex.lock();
	+ m_photos_mutex.lock();

	/* Now pass the event to Photos for processing
	* Create a Photos event object */
	@@ -162,7 +162,7 @@
	// Run the Photos algorithm
	photosEvent.process();

	- photos_mutex.unlock();
	+ m_photos_mutex.unlock();

	// Find the number of (outgoing) photons in the event
	const int nPhotons = this->getNumberOfPhotons( theVertex );
	diff --git a/src/EvtGenExternal/EvtPythia.cpp b/src/EvtGenExternal/EvtPythia.cpp
	--- a/src/EvtGenExternal/EvtPythia.cpp
	+++ b/src/EvtGenExternal/EvtPythia.cpp
	@@ -39,12 +39,12 @@
	// Set the Pythia engine to a null pointer at first.
	// When we do the decay, we retrieve the pointer to the Pythia engine
	// and use that for all decays. All clones will use the same Pythia engine.
	- _pythiaEngine = nullptr;
	+ m_pythiaEngine = nullptr;
	}

	EvtPythia::~EvtPythia()
	{
	- _commandList.clear();
	+ m_commandList.clear();
	}

	std::string EvtPythia::getName()
	@@ -77,13 +77,13 @@
	// We check to see if the engine has been created before doing the decay.
	// This should only create the full Pythia engine once, and all clones will point to the same engine.

	- if ( !_pythiaEngine ) {
	- _pythiaEngine = EvtExternalGenFactory::getInstance()->getGenerator(
	+ if ( !m_pythiaEngine ) {
	+ m_pythiaEngine = EvtExternalGenFactory::getInstance()->getGenerator(
	EvtExternalGenFactory::PythiaGenId );
	}

	- if ( _pythiaEngine ) {
	- _pythiaEngine->doDecay( p );
	+ if ( m_pythiaEngine ) {
	+ m_pythiaEngine->doDecay( p );
	}

	this->fixPolarisations( p );
	@@ -148,5 +148,5 @@
	void EvtPythia::command( std::string cmd )
	{
	// Locally store commands in a vector
	- _commandList.push_back( cmd );
	+ m_commandList.push_back( cmd );
	}
	diff --git a/src/EvtGenExternal/EvtPythiaEngine.cpp b/src/EvtGenExternal/EvtPythiaEngine.cpp
	--- a/src/EvtGenExternal/EvtPythiaEngine.cpp
	+++ b/src/EvtGenExternal/EvtPythiaEngine.cpp
	@@ -59,54 +59,54 @@

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Creating generic Pythia generator" << endl;
	- _genericPythiaGen = std::make_unique<Pythia8::Pythia>( xmlDir );
	+ m_genericPythiaGen = std::make_unique<Pythia8::Pythia>( xmlDir );

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Creating alias Pythia generator" << endl;
	- _aliasPythiaGen = std::make_unique<Pythia8::Pythia>( xmlDir, false );
	+ m_aliasPythiaGen = std::make_unique<Pythia8::Pythia>( xmlDir, false );

	- _thePythiaGenerator = nullptr;
	- _daugPDGVector.clear();
	- _daugP4Vector.clear();
	+ m_thePythiaGenerator = nullptr;
	+ m_daugPDGVector.clear();
	+ m_daugP4Vector.clear();

	- _convertPhysCodes = convertPhysCodes;
	+ m_convertPhysCodes = convertPhysCodes;

	// Specify if we are going to use the random number generator (engine)
	// from EvtGen for Pythia 8.
	- _useEvtGenRandom = useEvtGenRandom;
	+ m_useEvtGenRandom = useEvtGenRandom;

	- _evtgenRandom = std::make_shared<EvtPythiaRandom>();
	+ m_evtgenRandom = std::make_shared<EvtPythiaRandom>();

	- _initialised = false;
	+ m_initialised = false;
	}

	EvtPythiaEngine::~EvtPythiaEngine()
	{
	- _thePythiaGenerator = nullptr;
	+ m_thePythiaGenerator = nullptr;
	this->clearDaughterVectors();
	this->clearPythiaModeMap();
	}

	void EvtPythiaEngine::clearDaughterVectors()
	{
	- _daugPDGVector.clear();
	- _daugP4Vector.clear();
	+ m_daugPDGVector.clear();
	+ m_daugP4Vector.clear();
	}

	void EvtPythiaEngine::clearPythiaModeMap()
	{
	PythiaModeMap::iterator iter;
	- for ( iter = _pythiaModeMap.begin(); iter != _pythiaModeMap.end(); ++iter ) {
	+ for ( iter = m_pythiaModeMap.begin(); iter != m_pythiaModeMap.end(); ++iter ) {
	std::vector<int> modeVector = iter->second;
	modeVector.clear();
	}

	- _pythiaModeMap.clear();
	+ m_pythiaModeMap.clear();
	}

	void EvtPythiaEngine::initialise()
	{
	- if ( _initialised ) {
	+ if ( m_initialised ) {
	return;
	}

	@@ -116,31 +116,31 @@

	// Hadron-level processes only (hadronized, string fragmentation and secondary decays).
	// We do not want to generate the full pp or e+e- event structure etc..
	- _genericPythiaGen->readString( "ProcessLevel:all = off" );
	- _aliasPythiaGen->readString( "ProcessLevel:all = off" );
	+ m_genericPythiaGen->readString( "ProcessLevel:all = off" );
	+ m_aliasPythiaGen->readString( "ProcessLevel:all = off" );

	// Turn off Pythia warnings, e.g. changes to particle properties
	- _genericPythiaGen->readString( "Print:quiet = on" );
	- _aliasPythiaGen->readString( "Print:quiet = on" );
	+ m_genericPythiaGen->readString( "Print:quiet = on" );
	+ m_aliasPythiaGen->readString( "Print:quiet = on" );

	// Apply any other physics (or special particle) requirements/cuts etc..
	this->updatePhysicsParameters();

	// Set the random number generator
	- if ( _useEvtGenRandom == true ) {
	+ if ( m_useEvtGenRandom == true ) {
	#if PYTHIA_VERSION_INTEGER < 8310
	- _genericPythiaGen->setRndmEnginePtr( _evtgenRandom.get() );
	- _aliasPythiaGen->setRndmEnginePtr( _evtgenRandom.get() );
	+ m_genericPythiaGen->setRndmEnginePtr( m_evtgenRandom.get() );
	+ m_aliasPythiaGen->setRndmEnginePtr( m_evtgenRandom.get() );
	#else
	- _genericPythiaGen->setRndmEnginePtr( _evtgenRandom );
	- _aliasPythiaGen->setRndmEnginePtr( _evtgenRandom );
	+ m_genericPythiaGen->setRndmEnginePtr( m_evtgenRandom );
	+ m_aliasPythiaGen->setRndmEnginePtr( m_evtgenRandom );
	#endif
	}

	- _genericPythiaGen->init();
	- _aliasPythiaGen->init();
	+ m_genericPythiaGen->init();
	+ m_aliasPythiaGen->init();

	- _initialised = true;
	+ m_initialised = true;
	}

	bool EvtPythiaEngine::doDecay( EvtParticle* theParticle )
	@@ -160,7 +160,7 @@
	// we wanted via the specifications made to the decay.dec file, even though event-by-event
	// the EvtGen decay channel and the Pythia decay channel may be different.

	- if ( _initialised == false ) {
	+ if ( m_initialised == false ) {
	this->initialise();
	}

	@@ -181,12 +181,12 @@
	int isAlias = particleId.isAlias();

	// Choose the generator depending if we have an aliased (parent) particle or not
	- _thePythiaGenerator = ( isAlias == 1 ? _aliasPythiaGen.get()
	- : _genericPythiaGen.get() );
	+ m_thePythiaGenerator = ( isAlias == 1 ? m_aliasPythiaGen.get()
	+ : m_genericPythiaGen.get() );

	// Need to use the reference to the Pythia8::Event object,
	// otherwise it will just return a new empty, default event object.
	- Pythia8::Event& theEvent = _thePythiaGenerator->event;
	+ Pythia8::Event& theEvent = m_thePythiaGenerator->event;
	theEvent.reset();

	// Initialise the event to be the particle rest frame
	@@ -204,7 +204,7 @@
	int iTrial( 0 );
	bool generatedEvent( false );
	for ( iTrial = 0; iTrial < 10; iTrial++ ) {
	- generatedEvent = _thePythiaGenerator->next();
	+ generatedEvent = m_thePythiaGenerator->next();
	if ( generatedEvent ) {
	break;
	}
	@@ -243,7 +243,7 @@

	void EvtPythiaEngine::storeDaughterInfo( EvtParticle* theParticle, int startInt )
	{
	- Pythia8::Event& theEvent = _thePythiaGenerator->event;
	+ Pythia8::Event& theEvent = m_thePythiaGenerator->event;

	std::vector<int> daugList = theEvent.daughterList( startInt );

	@@ -277,8 +277,8 @@
	EvtVector4R daughterP4( E, px, py, pz );

	// Now store the EvtId and 4-momentum in the internal vectors
	- _daugPDGVector.push_back( daugPDGInt );
	- _daugP4Vector.push_back( daughterP4 );
	+ m_daugPDGVector.push_back( daugPDGInt );
	+ m_daugP4Vector.push_back( daughterP4 );

	// Set the status flag for the Pythia particle to let us know
	// that we have already considered it to avoid double counting.
	@@ -302,7 +302,7 @@
	// It would be easier to just use the decay channel number that Pythia chose to use
	// for the particle decay, but this is not accessible from the Pythia interface at present.

	- int nDaughters = _daugPDGVector.size();
	+ int nDaughters = m_daugPDGVector.size();
	std::vector<EvtId> daugAliasIdVect( 0 );

	EvtId particleId = theParent->getId();
	@@ -318,7 +318,7 @@
	pythiaAliasInt = conjPartId.getAlias();
	}

	- std::vector<int> pythiaModes = _pythiaModeMap[pythiaAliasInt];
	+ std::vector<int> pythiaModes = m_pythiaModeMap[pythiaAliasInt];

	// Loop over all available Pythia decay modes and find the channel that matches
	// the daughter ids. Set each daughter id to also use the alias integer.
	@@ -349,7 +349,7 @@
	EvtId daugId = decayModel->getDaug( iModeDaug );
	int daugPDGId = EvtPDL::getStdHep( daugId );
	// Pythia has used the right PDG codes for this decay mode, even for conjugate modes
	- int pythiaPDGId = _daugPDGVector[iModeDaug];
	+ int pythiaPDGId = m_daugPDGVector[iModeDaug];

	if ( daugPDGId == pythiaPDGId ) {
	daugAliasIdVect.push_back( daugId );
	@@ -378,7 +378,7 @@
	// from the Pythia decay result
	int iPyDaug( 0 );
	for ( iPyDaug = 0; iPyDaug < nDaughters; iPyDaug++ ) {
	- int daugPDGCode = _daugPDGVector[iPyDaug];
	+ int daugPDGCode = m_daugPDGVector[iPyDaug];
	EvtId daugPyId = EvtPDL::evtIdFromStdHep( daugPDGCode );
	daugAliasIdVect.push_back( daugPyId );
	}
	@@ -396,7 +396,7 @@
	// Set the correct 4-momentum for each daughter particle.
	if ( theDaughter != nullptr ) {
	EvtId theDaugId = daugAliasIdVect[iDaug];
	- const EvtVector4R theDaugP4 = _daugP4Vector[iDaug];
	+ const EvtVector4R theDaugP4 = m_daugP4Vector[iDaug];
	theDaughter->init( theDaugId, theDaugP4 );
	}
	}
	@@ -414,9 +414,9 @@
	int iPDL;
	int nPDL = EvtPDL::entries();

	- // Reset the _addedPDGCodes map that keeps track
	+ // Reset the m_addedPDGCodes map that keeps track
	// of any new particles added to the Pythia input data stream
	- _addedPDGCodes.clear();
	+ m_addedPDGCodes.clear();

	for ( iPDL = 0; iPDL < nPDL; iPDL++ ) {
	EvtId particleId = EvtPDL::getEntry( iPDL );
	@@ -442,9 +442,9 @@
	// the original particleData information from the generator pointer.

	ParticleDataEntryPtr entry_generic =
	- _genericPythiaGen->particleData.particleDataEntryPtr( PDGCode );
	+ m_genericPythiaGen->particleData.particleDataEntryPtr( PDGCode );
	ParticleDataEntryPtr entry_alias =
	- _aliasPythiaGen->particleData.particleDataEntryPtr( PDGCode );
	+ m_aliasPythiaGen->particleData.particleDataEntryPtr( PDGCode );

	// Check that the PDG code is not zero/null and exclude other
	// special cases, e.g. those reserved for internal generator use
	@@ -483,14 +483,14 @@

	// Decide what generator to use depending on whether we have
	// an aliased particle or not
	- _thePythiaGenerator = ( isAlias == 1 ? _aliasPythiaGen.get()
	- : _genericPythiaGen.get() );
	+ m_thePythiaGenerator = ( isAlias == 1 ? m_aliasPythiaGen.get()
	+ : m_genericPythiaGen.get() );

	// Find the Pythia particle name given the standard PDG code integer
	- std::string dataName = _thePythiaGenerator->particleData.name(
	+ std::string dataName = m_thePythiaGenerator->particleData.name(
	PDGCode );
	- bool alreadyStored = ( _addedPDGCodes.find( abs( PDGCode ) ) !=
	- _addedPDGCodes.end() );
	+ bool alreadyStored = ( m_addedPDGCodes.find( abs( PDGCode ) ) !=
	+ m_addedPDGCodes.end() );

	if ( dataName == " " && !alreadyStored ) {
	// Particle and its antiparticle do not exist in the Pythia database.
	@@ -615,7 +615,7 @@

	} // Daughter list

	- _thePythiaGenerator->readString( oss.str() );
	+ m_thePythiaGenerator->readString( oss.str() );

	} // is Pythia

	@@ -636,14 +636,14 @@

	} // Loop over modes

	- _pythiaModeMap[aliasInt] = pythiaModes;
	+ m_pythiaModeMap[aliasInt] = pythiaModes;

	// Now, renormalise the decay branching fractions to sum to 1.0
	std::ostringstream rescaleStr;
	rescaleStr.setf( std::ios::scientific );
	rescaleStr << PDGCode << ":rescaleBR = 1.0";

	- _thePythiaGenerator->readString( rescaleStr.str() );
	+ m_thePythiaGenerator->readString( rescaleStr.str() );
	}

	int EvtPythiaEngine::getModeInt( EvtDecayBase* decayModel )
	@@ -659,7 +659,7 @@
	}
	}

	- if ( _convertPhysCodes ) {
	+ if ( m_convertPhysCodes ) {
	// Extra code to convert the old Pythia decay model integer MDME(ICC,2) to the new one.
	// This should be removed eventually after updating decay.dec files to use
	// the new convention.
	@@ -770,14 +770,14 @@
	<< " " << mMin << " " << mMax << " " << tau0;

	// Pass this information to Pythia
	- _thePythiaGenerator->readString( oss.str() );
	+ m_thePythiaGenerator->readString( oss.str() );

	// Also store the absolute value of the PDG entry
	// to keep track of which new particles have been added,
	// which also automatically includes the anti-particle.
	// We need to avoid creating new anti-particles when
	// they already exist when the particle was added.
	- _addedPDGCodes[absPDGCode] = 1;
	+ m_addedPDGCodes[absPDGCode] = 1;
	}

	void EvtPythiaEngine::updatePhysicsParameters()
	@@ -791,13 +791,13 @@

	// Set the multiplicity level for hadronic weak decays
	std::string multiWeakCut( "ParticleDecays:multIncreaseWeak = 2.0" );
	- _genericPythiaGen->readString( multiWeakCut );
	- _aliasPythiaGen->readString( multiWeakCut );
	+ m_genericPythiaGen->readString( multiWeakCut );
	+ m_aliasPythiaGen->readString( multiWeakCut );

	// Set the multiplicity level for all other decays
	std::string multiCut( "ParticleDecays:multIncrease = 4.5" );
	- _genericPythiaGen->readString( multiCut );
	- _aliasPythiaGen->readString( multiCut );
	+ m_genericPythiaGen->readString( multiCut );
	+ m_aliasPythiaGen->readString( multiCut );

	//Now read in any custom configuration entered in the XML
	GeneratorCommands commands =
	@@ -838,7 +838,7 @@
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Configuring generic Pythia generator: " << ( *it2 )
	<< endl;
	- _genericPythiaGen->readString( *it2 );
	+ m_genericPythiaGen->readString( *it2 );
	}
	}
	if ( generator == "ALIAS" \|\| generator == "Alias" \|\|
	@@ -849,7 +849,7 @@
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Configuring alias Pythia generator: " << ( *it2 )
	<< endl;
	- _aliasPythiaGen->readString( *it2 );
	+ m_aliasPythiaGen->readString( *it2 );
	}
	}
	}
	diff --git a/src/EvtGenExternal/EvtTauola.cpp b/src/EvtGenExternal/EvtTauola.cpp
	--- a/src/EvtGenExternal/EvtTauola.cpp
	+++ b/src/EvtGenExternal/EvtTauola.cpp
	@@ -57,12 +57,12 @@
	// This should only create the full Tauola engine once, and all clones will
	// point to the same engine.

	- if ( !_tauolaEngine ) {
	- _tauolaEngine = EvtExternalGenFactory::getInstance()->getGenerator(
	+ if ( !m_tauolaEngine ) {
	+ m_tauolaEngine = EvtExternalGenFactory::getInstance()->getGenerator(
	EvtExternalGenFactory::TauolaGenId );
	}

	- if ( _tauolaEngine ) {
	- _tauolaEngine->doDecay( p );
	+ if ( m_tauolaEngine ) {
	+ m_tauolaEngine->doDecay( p );
	}
	}
	diff --git a/src/EvtGenExternal/EvtTauolaEngine.cpp b/src/EvtGenExternal/EvtTauolaEngine.cpp
	--- a/src/EvtGenExternal/EvtTauolaEngine.cpp
	+++ b/src/EvtGenExternal/EvtTauolaEngine.cpp
	@@ -43,15 +43,15 @@
	EvtTauolaEngine::EvtTauolaEngine( bool useEvtGenRandom )
	{
	// PDG standard code integer ID for tau particle
	- _tauPDG = 15;
	+ m_tauPDG = 15;
	// Number of possible decay modes in Tauola
	- _nTauolaModes = 22;
	+ m_nTauolaModes = 22;

	EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Setting up TAUOLA." << endl;

	// These three lines are not really necessary since they are the default.
	// But they are here so that we know what the initial conditions are.
	- Tauolapp::Tauola::setDecayingParticle( _tauPDG ); // tau PDG code
	+ Tauolapp::Tauola::setDecayingParticle( m_tauPDG ); // tau PDG code
	Tauolapp::Tauola::setSameParticleDecayMode(
	Tauolapp::Tauola::All ); // all modes allowed
	Tauolapp::Tauola::setOppositeParticleDecayMode(
	@@ -76,12 +76,12 @@

	// Initialise various default parameters
	// Neutral and charged spin propagator choices
	- _neutPropType = 0;
	- _posPropType = 0;
	- _negPropType = 0;
	+ m_neutPropType = 0;
	+ m_posPropType = 0;
	+ m_negPropType = 0;

	// Set-up possible decay modes _after_ we have read the (user) decay file
	- _initialised = false;
	+ m_initialised = false;
	}

	void EvtTauolaEngine::initialise()
	@@ -92,11 +92,11 @@
	// first to get lists of particle modes and their alias definitions
	// (for creating EvtParticles with the right history information).

	- if ( _initialised == false ) {
	+ if ( m_initialised == false ) {
	this->setUpPossibleTauModes();
	this->setOtherParameters();

	- _initialised = true;
	+ m_initialised = true;
	}
	}

	@@ -120,7 +120,7 @@
	EvtId particleId = EvtPDL::getEntry( iPDL );
	int PDGId = EvtPDL::getStdHep( particleId );

	- if ( abs( PDGId ) == _tauPDG && gotAnyTauolaModes == false ) {
	+ if ( abs( PDGId ) == m_tauPDG && gotAnyTauolaModes == false ) {
	int aliasInt = particleId.getAlias();

	// Get the list of decay modes for this tau particle (alias)
	@@ -130,9 +130,9 @@
	// Vector to store tau mode branching fractions.
	// The size of this vector equals the total number of possible
	// Tauola decay modes. Initialise all BFs to zero.
	- std::vector<double> tauolaModeBFs( _nTauolaModes );
	+ std::vector<double> tauolaModeBFs( m_nTauolaModes );

	- for ( iTauMode = 0; iTauMode < _nTauolaModes; iTauMode++ ) {
	+ for ( iTauMode = 0; iTauMode < m_nTauolaModes; iTauMode++ ) {
	tauolaModeBFs[iTauMode] = 0.0;
	}

	@@ -157,7 +157,7 @@
	double BF = decayModel->getBranchingFraction();
	int modeArrayInt = this->getModeInt( decayModel ) - 1;

	- if ( modeArrayInt >= 0 && modeArrayInt < _nTauolaModes ) {
	+ if ( modeArrayInt >= 0 && modeArrayInt < m_nTauolaModes ) {
	tauolaModeBFs[modeArrayInt] = BF;
	totalTauModeBF += BF;
	}
	@@ -184,7 +184,7 @@
	<< "Setting TAUOLA BF modes using the definitions for the particle "
	<< EvtPDL::name( particleId ) << endl;

	- for ( iTauMode = 0; iTauMode < _nTauolaModes; iTauMode++ ) {
	+ for ( iTauMode = 0; iTauMode < m_nTauolaModes; iTauMode++ ) {
	tauolaModeBFs[iTauMode] /= totalTauModeBF;
	double modeBF = tauolaModeBFs[iTauMode];
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -228,20 +228,20 @@
	int iErr( 0 );
	std::string neutPropName = EvtSymTable::get( "TauolaNeutralProp", iErr );
	if ( neutPropName == "Z0" \|\| neutPropName == "Z" ) {
	- _neutPropType = Tauolapp::TauolaParticle::Z0;
	+ m_neutPropType = Tauolapp::TauolaParticle::Z0;
	} else if ( neutPropName == "Gamma" ) {
	- _neutPropType = Tauolapp::TauolaParticle::GAMMA;
	+ m_neutPropType = Tauolapp::TauolaParticle::GAMMA;
	} else if ( neutPropName == "Higgs" ) {
	- _neutPropType = Tauolapp::TauolaParticle::HIGGS;
	+ m_neutPropType = Tauolapp::TauolaParticle::HIGGS;
	} else if ( neutPropName == "PseudoHiggs" ) {
	- _neutPropType = Tauolapp::TauolaParticle::HIGGS_A;
	+ m_neutPropType = Tauolapp::TauolaParticle::HIGGS_A;
	} else if ( neutPropName == "MixedHiggs" ) {
	- _neutPropType = Tauolapp::Tauola::getHiggsScalarPseudoscalarPDG();
	+ m_neutPropType = Tauolapp::Tauola::getHiggsScalarPseudoscalarPDG();
	}

	- if ( _neutPropType != 0 ) {
	+ if ( m_neutPropType != 0 ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "TAUOLA neutral spin propagator PDG id set to " << _neutPropType
	+ << "TAUOLA neutral spin propagator PDG id set to " << m_neutPropType
	<< endl;
	}

	@@ -249,23 +249,23 @@
	// "W" (default), "Higgs" (H+/H-)
	std::string chargedPropName = EvtSymTable::get( "TauolaChargedProp", iErr );
	if ( chargedPropName == "W" ) {
	- _negPropType = Tauolapp::TauolaParticle::W_MINUS;
	- _posPropType = Tauolapp::TauolaParticle::W_PLUS;
	+ m_negPropType = Tauolapp::TauolaParticle::W_MINUS;
	+ m_posPropType = Tauolapp::TauolaParticle::W_PLUS;
	} else if ( chargedPropName == "Higgs" ) {
	- _negPropType = Tauolapp::TauolaParticle::HIGGS_MINUS;
	- _posPropType = Tauolapp::TauolaParticle::HIGGS_PLUS;
	+ m_negPropType = Tauolapp::TauolaParticle::HIGGS_MINUS;
	+ m_posPropType = Tauolapp::TauolaParticle::HIGGS_PLUS;
	}

	- if ( _negPropType != 0 ) {
	+ if ( m_negPropType != 0 ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "TAUOLA negative charge spin propagator PDG id set to "
	- << _negPropType << endl;
	+ << m_negPropType << endl;
	}

	- if ( _posPropType != 0 ) {
	+ if ( m_posPropType != 0 ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "TAUOLA positive charge spin propagator PDG id set to "
	- << _posPropType << endl;
	+ << m_posPropType << endl;
	}

	// 3) TauolaHiggsMixingAngle: Specify the mixing angle between the neutral scalar & pseudoscalar Higgs
	@@ -322,7 +322,7 @@

	bool EvtTauolaEngine::doDecay( EvtParticle* tauParticle )
	{
	- if ( _initialised == false ) {
	+ if ( m_initialised == false ) {
	this->initialise();
	}

	@@ -332,7 +332,7 @@

	// Check that we have a tau particle.
	EvtId partId = tauParticle->getId();
	- if ( abs( EvtPDL::getStdHep( partId ) ) != _tauPDG ) {
	+ if ( abs( EvtPDL::getStdHep( partId ) ) != m_tauPDG ) {
	return false;
	}

	@@ -423,7 +423,7 @@
	EvtId theId = theDaughter->getId();
	int PDGInt = EvtPDL::getStdHep( theId );

	- if ( abs( PDGInt ) == _tauPDG ) {
	+ if ( abs( PDGInt ) == m_tauPDG ) {
	// Delete any siblings for the tau particle
	if ( theDaughter->getNDaug() > 0 ) {
	theDaughter->deleteDaughters( false );
	@@ -440,16 +440,16 @@

	// For the parent particle, artifically set the PDG to a boson with the same 4-momentum
	// so that spin correlations are calculated inside Tauola.
	- // This leaves the original parent _EvtParticle_ unchanged
	+ // This leaves the original parent m_EvtParticle_ unchanged
	if ( nTaus > 0 && hepMCParent ) {
	int parCharge = EvtPDL::chg3( origParentId ) /
	3; // (3*particle charge)/3 = particle charge
	- if ( parCharge == 0 && _neutPropType != 0 ) {
	- hepMCParent->set_pdg_id( _neutPropType );
	- } else if ( parCharge == -1 && _negPropType != 0 ) {
	- hepMCParent->set_pdg_id( _negPropType );
	- } else if ( parCharge == 1 && _posPropType != 0 ) {
	- hepMCParent->set_pdg_id( _posPropType );
	+ if ( parCharge == 0 && m_neutPropType != 0 ) {
	+ hepMCParent->set_pdg_id( m_neutPropType );
	+ } else if ( parCharge == -1 && m_negPropType != 0 ) {
	+ hepMCParent->set_pdg_id( m_negPropType );
	+ } else if ( parCharge == 1 && m_posPropType != 0 ) {
	+ hepMCParent->set_pdg_id( m_posPropType );
	}
	}

	@@ -489,7 +489,7 @@
	HepMC::GenParticle* aParticle = ( *eventIter );
	#endif

	- if ( aParticle && abs( aParticle->pdg_id() ) == _tauPDG ) {
	+ if ( aParticle && abs( aParticle->pdg_id() ) == m_tauPDG ) {
	// Find out what EvtParticle corresponds to the HepMC particle.
	// We need this to create and attach EvtParticle daughters.
	EvtParticle* tauEvtParticle = tauMap[aParticle];
	diff --git a/src/EvtGenModels/EvtBBScalar.cpp b/src/EvtGenModels/EvtBBScalar.cpp
	--- a/src/EvtGenModels/EvtBBScalar.cpp
	+++ b/src/EvtGenModels/EvtBBScalar.cpp
	@@ -31,43 +31,44 @@
	using namespace std;

	const float pi = 3.14159;
	-const EvtComplex EvtBBScalar::I = EvtComplex( 0, 1 );
	-const EvtComplex EvtBBScalar::V_ub = EvtComplex( 3.67e-3 * cos( 60 / 180 * pi ),
	- 3.67e-3 * cos( 60 / 180 * pi ) );
	-const EvtComplex EvtBBScalar::V_us_star = EvtComplex( 0.22, 0 );
	-const EvtComplex EvtBBScalar::a1 = EvtComplex( 1.05, 0 );
	-const EvtComplex EvtBBScalar::V_tb = EvtComplex( 0.99915, 0 );
	-const EvtComplex EvtBBScalar::V_ts_star =
	+const EvtComplex EvtBBScalar::m_I = EvtComplex( 0, 1 );
	+const EvtComplex EvtBBScalar::m_V_ub =
	+ EvtComplex( 3.67e-3 * cos( 60 / 180 * pi ), 3.67e-3 * cos( 60 / 180 * pi ) );
	+const EvtComplex EvtBBScalar::m_V_us_star = EvtComplex( 0.22, 0 );
	+const EvtComplex EvtBBScalar::m_a1 = EvtComplex( 1.05, 0 );
	+const EvtComplex EvtBBScalar::m_V_tb = EvtComplex( 0.99915, 0 );
	+const EvtComplex EvtBBScalar::m_V_ts_star =
	EvtComplex( -0.04029 - 0.000813 * cos( 60 / 180 * pi ),
	-0.000813 * cos( 60 / 180 * pi ) );
	-const EvtComplex EvtBBScalar::a4 = EvtComplex( -387.3e-4, -121e-4 );
	-const EvtComplex EvtBBScalar::a6 = EvtComplex( -555.3e-4, -121e-4 );
	-const double EvtBBScalar::x[] = { 420.96, -10485.50, 100639.97, -433916.61,
	- 613780.15 };
	-const double EvtBBScalar::y[] = { 292.62, -735.73 };
	-const double EvtBBScalar::m_s = 0.120;
	-const double EvtBBScalar::m_u = 0.029 * 0.120;
	-const double EvtBBScalar::m_b = 4.88;
	-
	-EvtBBScalar::EvtBBScalar() : EvtDecayAmp(), _massRatio( 0 ), _baryonMassSum( 0 )
	+const EvtComplex EvtBBScalar::m_a4 = EvtComplex( -387.3e-4, -121e-4 );
	+const EvtComplex EvtBBScalar::m_a6 = EvtComplex( -555.3e-4, -121e-4 );
	+const double EvtBBScalar::m_x[] = { 420.96, -10485.50, 100639.97, -433916.61,
	+ 613780.15 };
	+const double EvtBBScalar::m_y[] = { 292.62, -735.73 };
	+const double EvtBBScalar::m_ms = 0.120;
	+const double EvtBBScalar::m_mu = 0.029 * 0.120;
	+const double EvtBBScalar::m_mb = 4.88;
	+
	+EvtBBScalar::EvtBBScalar() :
	+ EvtDecayAmp(), m_massRatio( 0 ), m_baryonMassSum( 0 )
	{
	FormFactor dummy;
	- dummy.value = 0.36;
	- dummy.sigma1 = 0.43;
	- dummy.sigma2 = 0.0;
	- dummy.mV = 5.42;
	- _f1Map.insert( make_pair( string( "K" ), dummy ) );
	- dummy.sigma1 = 0.70;
	- dummy.sigma2 = 0.27;
	- _f0Map.insert( make_pair( string( "K" ), dummy ) );
	- dummy.value = 0.29;
	- dummy.sigma1 = 0.48;
	- dummy.sigma2 = 0.0;
	- dummy.mV = 5.32;
	- _f1Map.insert( make_pair( string( "pi" ), dummy ) );
	- dummy.sigma1 = 0.76;
	- dummy.sigma2 = 0.28;
	- _f0Map.insert( make_pair( string( "pi" ), dummy ) );
	+ dummy.m_value = 0.36;
	+ dummy.m_sigma1 = 0.43;
	+ dummy.m_sigma2 = 0.0;
	+ dummy.m_mV = 5.42;
	+ m_f1Map.insert( make_pair( string( "K" ), dummy ) );
	+ dummy.m_sigma1 = 0.70;
	+ dummy.m_sigma2 = 0.27;
	+ m_f0Map.insert( make_pair( string( "K" ), dummy ) );
	+ dummy.m_value = 0.29;
	+ dummy.m_sigma1 = 0.48;
	+ dummy.m_sigma2 = 0.0;
	+ dummy.m_mV = 5.32;
	+ m_f1Map.insert( make_pair( string( "pi" ), dummy ) );
	+ dummy.m_sigma1 = 0.76;
	+ dummy.m_sigma2 = 0.28;
	+ m_f0Map.insert( make_pair( string( "pi" ), dummy ) );
	}

	std::string EvtBBScalar::getName()
	@@ -85,25 +86,25 @@
	int baryonId = EvtPDL::getStdHep( baryon );
	if ( EvtPDL::getStdHep( EvtPDL::getId( "Lambda0" ) ) == baryonId or
	EvtPDL::getStdHep( EvtPDL::getId( "anti-Lambda0" ) ) == baryonId ) {
	- _baryonCombination.set( Lambda );
	+ m_baryonCombination.set( Lambda );
	} else if ( EvtPDL::getStdHep( EvtPDL::getId( "p+" ) ) == baryonId or
	EvtPDL::getStdHep( EvtPDL::getId( "anti-p-" ) ) == baryonId ) {
	- _baryonCombination.set( Proton );
	+ m_baryonCombination.set( Proton );
	} else if ( EvtPDL::getStdHep( EvtPDL::getId( "n0" ) ) == baryonId or
	EvtPDL::getStdHep( EvtPDL::getId( "anti-n0" ) ) == baryonId ) {
	- _baryonCombination.set( Neutron );
	+ m_baryonCombination.set( Neutron );
	} else if ( EvtPDL::getStdHep( EvtPDL::getId( "Sigma0" ) ) == baryonId or
	EvtPDL::getStdHep( EvtPDL::getId( "anti-Sigma0" ) ) == baryonId ) {
	- _baryonCombination.set( Sigma0 );
	+ m_baryonCombination.set( Sigma0 );
	} else if ( EvtPDL::getStdHep( EvtPDL::getId( "Sigma-" ) ) == baryonId or
	EvtPDL::getStdHep( EvtPDL::getId( "anti-Sigma+" ) ) == baryonId ) {
	- _baryonCombination.set( Sigma_minus );
	+ m_baryonCombination.set( Sigma_minus );
	} else if ( EvtPDL::getStdHep( EvtPDL::getId( "Xi0" ) ) == baryonId or
	EvtPDL::getStdHep( EvtPDL::getId( "anti-Xi0" ) ) == baryonId ) {
	- _baryonCombination.set( Xi0 );
	+ m_baryonCombination.set( Xi0 );
	} else if ( EvtPDL::getStdHep( EvtPDL::getId( "Xi-" ) ) == baryonId or
	EvtPDL::getStdHep( EvtPDL::getId( "anti-Xi+" ) ) == baryonId ) {
	- _baryonCombination.set( Xi_minus );
	+ m_baryonCombination.set( Xi_minus );
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "EvtBBScalar::init: Don't know what to do with this type as the first or second baryon\n";
	@@ -114,22 +115,23 @@
	double EvtBBScalar::baryonF1F2( double t ) const
	{
	// check for known form factors for combination of baryons
	- if ( _baryonCombination.test( Lambda ) and _baryonCombination.test( Proton ) ) {
	+ if ( m_baryonCombination.test( Lambda ) and
	+ m_baryonCombination.test( Proton ) ) {
	return -sqrt( 1.5 ) * G_p( t );
	- } else if ( _baryonCombination.test( Sigma0 ) and
	- _baryonCombination.test( Proton ) ) {
	+ } else if ( m_baryonCombination.test( Sigma0 ) and
	+ m_baryonCombination.test( Proton ) ) {
	return -sqrt( 0.5 ) * ( G_p( t ) + 2 * G_n( t ) );
	- } else if ( _baryonCombination.test( Sigma_minus ) and
	- _baryonCombination.test( Neutron ) ) {
	+ } else if ( m_baryonCombination.test( Sigma_minus ) and
	+ m_baryonCombination.test( Neutron ) ) {
	return -G_p( t ) - 2 * G_n( t );
	- } else if ( _baryonCombination.test( Xi0 ) and
	- _baryonCombination.test( Sigma_minus ) ) {
	+ } else if ( m_baryonCombination.test( Xi0 ) and
	+ m_baryonCombination.test( Sigma_minus ) ) {
	return G_p( t ) - G_n( t );
	- } else if ( _baryonCombination.test( Xi_minus ) and
	- _baryonCombination.test( Sigma0 ) ) {
	+ } else if ( m_baryonCombination.test( Xi_minus ) and
	+ m_baryonCombination.test( Sigma0 ) ) {
	return sqrt( 0.5 ) * ( G_p( t ) - G_n( t ) );
	- } else if ( _baryonCombination.test( Xi_minus ) and
	- _baryonCombination.test( Lambda ) ) {
	+ } else if ( m_baryonCombination.test( Xi_minus ) and
	+ m_baryonCombination.test( Lambda ) ) {
	return sqrt( 1.5 ) * ( G_p( t ) + G_n( t ) );
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -151,35 +153,36 @@

	double EvtBBScalar::G_p( double t ) const
	{
	- const vector<double> v_x( x, x + 5 );
	+ const vector<double> v_x( m_x, m_x + 5 );
	return formFactorFit( t, v_x );
	}

	double EvtBBScalar::G_n( double t ) const
	{
	- const vector<double> v_y( y, y + 2 );
	+ const vector<double> v_y( m_y, m_y + 2 );
	return -formFactorFit( t, v_y );
	}

	double EvtBBScalar::baryon_gA( double t ) const
	{
	// check for known form factors for combination of baryons
	- if ( _baryonCombination.test( Lambda ) and _baryonCombination.test( Proton ) ) {
	+ if ( m_baryonCombination.test( Lambda ) and
	+ m_baryonCombination.test( Proton ) ) {
	return -1 / sqrt( 6. ) * ( D_A( t ) + 3 * F_A( t ) );
	- } else if ( _baryonCombination.test( Sigma0 ) and
	- _baryonCombination.test( Proton ) ) {
	+ } else if ( m_baryonCombination.test( Sigma0 ) and
	+ m_baryonCombination.test( Proton ) ) {
	return 1 / sqrt( 2. ) * ( D_A( t ) - F_A( t ) );
	- } else if ( _baryonCombination.test( Sigma_minus ) and
	- _baryonCombination.test( Neutron ) ) {
	+ } else if ( m_baryonCombination.test( Sigma_minus ) and
	+ m_baryonCombination.test( Neutron ) ) {
	return D_A( t ) - F_A( t );
	- } else if ( _baryonCombination.test( Xi0 ) and
	- _baryonCombination.test( Sigma_minus ) ) {
	+ } else if ( m_baryonCombination.test( Xi0 ) and
	+ m_baryonCombination.test( Sigma_minus ) ) {
	return D_A( t ) + F_A( t );
	- } else if ( _baryonCombination.test( Xi_minus ) and
	- _baryonCombination.test( Sigma0 ) ) {
	+ } else if ( m_baryonCombination.test( Xi_minus ) and
	+ m_baryonCombination.test( Sigma0 ) ) {
	return 1 / sqrt( 2. ) * ( D_A( t ) + F_A( t ) );
	- } else if ( _baryonCombination.test( Xi_minus ) and
	- _baryonCombination.test( Lambda ) ) {
	+ } else if ( m_baryonCombination.test( Xi_minus ) and
	+ m_baryonCombination.test( Lambda ) ) {
	return -1 / sqrt( 6. ) * ( D_A( t ) - 3 * F_A( t ) );
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -191,22 +194,23 @@
	double EvtBBScalar::baryon_gP( double t ) const
	{
	// check for known form factors for combination of baryons
	- if ( _baryonCombination.test( Lambda ) and _baryonCombination.test( Proton ) ) {
	+ if ( m_baryonCombination.test( Lambda ) and
	+ m_baryonCombination.test( Proton ) ) {
	return -1 / sqrt( 6. ) * ( D_P( t ) + 3 * F_P( t ) );
	- } else if ( _baryonCombination.test( Sigma0 ) and
	- _baryonCombination.test( Proton ) ) {
	+ } else if ( m_baryonCombination.test( Sigma0 ) and
	+ m_baryonCombination.test( Proton ) ) {
	return 1 / sqrt( 2. ) * ( D_P( t ) - F_P( t ) );
	- } else if ( _baryonCombination.test( Sigma_minus ) and
	- _baryonCombination.test( Neutron ) ) {
	+ } else if ( m_baryonCombination.test( Sigma_minus ) and
	+ m_baryonCombination.test( Neutron ) ) {
	return D_P( t ) - F_P( t );
	- } else if ( _baryonCombination.test( Xi0 ) and
	- _baryonCombination.test( Sigma_minus ) ) {
	+ } else if ( m_baryonCombination.test( Xi0 ) and
	+ m_baryonCombination.test( Sigma_minus ) ) {
	return D_P( t ) + F_P( t );
	- } else if ( _baryonCombination.test( Xi_minus ) and
	- _baryonCombination.test( Sigma0 ) ) {
	+ } else if ( m_baryonCombination.test( Xi_minus ) and
	+ m_baryonCombination.test( Sigma0 ) ) {
	return 1 / sqrt( 2. ) * ( D_P( t ) + F_P( t ) );
	- } else if ( _baryonCombination.test( Xi_minus ) and
	- _baryonCombination.test( Lambda ) ) {
	+ } else if ( m_baryonCombination.test( Xi_minus ) and
	+ m_baryonCombination.test( Lambda ) ) {
	return -1 / sqrt( 6. ) * ( D_P( t ) - 3 * F_P( t ) );
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -218,22 +222,23 @@
	double EvtBBScalar::baryon_fS( double t ) const
	{
	// check for known form factors for combination of baryons
	- if ( _baryonCombination.test( Lambda ) and _baryonCombination.test( Proton ) ) {
	+ if ( m_baryonCombination.test( Lambda ) and
	+ m_baryonCombination.test( Proton ) ) {
	return -1 / sqrt( 6. ) * ( D_S( t ) + 3 * F_S( t ) );
	- } else if ( _baryonCombination.test( Sigma0 ) and
	- _baryonCombination.test( Proton ) ) {
	+ } else if ( m_baryonCombination.test( Sigma0 ) and
	+ m_baryonCombination.test( Proton ) ) {
	return 1 / sqrt( 2. ) * ( D_S( t ) - F_S( t ) );
	- } else if ( _baryonCombination.test( Sigma_minus ) and
	- _baryonCombination.test( Neutron ) ) {
	+ } else if ( m_baryonCombination.test( Sigma_minus ) and
	+ m_baryonCombination.test( Neutron ) ) {
	return D_S( t ) - F_S( t );
	- } else if ( _baryonCombination.test( Xi0 ) and
	- _baryonCombination.test( Sigma_minus ) ) {
	+ } else if ( m_baryonCombination.test( Xi0 ) and
	+ m_baryonCombination.test( Sigma_minus ) ) {
	return D_S( t ) + F_S( t );
	- } else if ( _baryonCombination.test( Xi_minus ) and
	- _baryonCombination.test( Sigma0 ) ) {
	+ } else if ( m_baryonCombination.test( Xi_minus ) and
	+ m_baryonCombination.test( Sigma0 ) ) {
	return 1 / sqrt( 2. ) * ( D_S( t ) + F_S( t ) );
	- } else if ( _baryonCombination.test( Xi_minus ) and
	- _baryonCombination.test( Lambda ) ) {
	+ } else if ( m_baryonCombination.test( Xi_minus ) and
	+ m_baryonCombination.test( Lambda ) ) {
	return -1 / sqrt( 6. ) * ( D_S( t ) - 3 * F_S( t ) );
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -244,46 +249,46 @@

	double EvtBBScalar::D_A( double t ) const
	{
	- const double d_tilde[] = { x[0] - 1.5 * y[0], -478 };
	+ const double d_tilde[] = { m_x[0] - 1.5 * m_y[0], -478 };
	const vector<double> v_d_tilde( d_tilde, d_tilde + 2 );
	return formFactorFit( t, v_d_tilde );
	}

	double EvtBBScalar::F_A( double t ) const
	{
	- const double f_tilde[] = { 2. / 3 * x[0] + 0.5 * y[0], -478 };
	+ const double f_tilde[] = { 2. / 3 * m_x[0] + 0.5 * m_y[0], -478 };
	const vector<double> v_f_tilde( f_tilde, f_tilde + 2 );
	return formFactorFit( t, v_f_tilde );
	}

	double EvtBBScalar::D_P( double t ) const
	{
	- const double d_bar[] = { 1.5 * y[0] * _massRatio, /-952/ 0 };
	+ const double d_bar[] = { 1.5 * m_y[0] * m_massRatio, /-952/ 0 };
	const vector<double> v_d_bar( d_bar, d_bar + 2 );
	return formFactorFit( t, v_d_bar );
	}

	double EvtBBScalar::F_P( double t ) const
	{
	- const double f_bar[] = { ( x[0] - 0.5 * y[0] ) * _massRatio, /-952/ 0 };
	+ const double f_bar[] = { ( m_x[0] - 0.5 * m_y[0] ) * m_massRatio, /-952/ 0 };
	const vector<double> v_f_bar( f_bar, f_bar + 2 );
	return formFactorFit( t, v_f_bar );
	}

	double EvtBBScalar::D_S( double t ) const
	{
	- return -1.5 * _massRatio * G_n( t );
	+ return -1.5 * m_massRatio * G_n( t );
	}

	double EvtBBScalar::F_S( double t ) const
	{
	- return ( G_p( t ) + 0.5 * G_n( t ) ) * _massRatio;
	+ return ( G_p( t ) + 0.5 * G_n( t ) ) * m_massRatio;
	}

	double EvtBBScalar::baryon_hA( double t ) const
	{
	- return ( 1 / _massRatio * baryon_gP( t ) - baryon_gA( t ) ) *
	- pow( _baryonMassSum, 2 ) / t;
	+ return ( 1 / m_massRatio * baryon_gP( t ) - baryon_gA( t ) ) *
	+ pow( m_baryonMassSum, 2 ) / t;
	}

	void EvtBBScalar::init()
	@@ -305,12 +310,12 @@
	if ( scalarId == EvtPDL::getStdHep( EvtPDL::getId( "pi+" ) ) or
	scalarId == EvtPDL::getStdHep( EvtPDL::getId( "pi-" ) ) or
	scalarId == EvtPDL::getStdHep( EvtPDL::getId( "pi0" ) ) ) {
	- _scalarType = "pi";
	+ m_scalarType = "pi";
	} else if ( scalarId == EvtPDL::getStdHep( EvtPDL::getId( "K+" ) ) or
	scalarId == EvtPDL::getStdHep( EvtPDL::getId( "K-" ) ) or
	scalarId == EvtPDL::getStdHep( EvtPDL::getId( "K0" ) ) or
	scalarId == EvtPDL::getStdHep( EvtPDL::getId( "anti-K0" ) ) ) {
	- _scalarType = "K";
	+ m_scalarType = "K";
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "EvtBBScalar::init: Can only deal with Kaons or pions as the third particle\n"
	@@ -324,10 +329,10 @@
	double mass2 = EvtPDL::getMass( baryon2 );
	// This whole model deals only with baryons that differ in s-u
	if ( mass1 > mass2 )
	- _massRatio = ( mass1 - mass2 ) / ( m_s - m_u );
	+ m_massRatio = ( mass1 - mass2 ) / ( m_ms - m_mu );
	else
	- _massRatio = ( mass2 - mass1 ) / ( m_s - m_u );
	- _baryonMassSum = mass1 + mass2;
	+ m_massRatio = ( mass2 - mass1 ) / ( m_ms - m_mu );
	+ m_baryonMassSum = mass1 + mass2;
	}

	// initialize phasespace and calculate the amplitude
	@@ -354,10 +359,10 @@
	EvtComplex amplitude;
	for ( int index = 0; index < 4; ++index ) {
	amplitude += theAmplitudePartA.get( index ) *
	- ( const_B * amp_B( theLambda, lambdaPol, theAntiP,
	- antiP_Pol, index ) +
	- const_C * amp_C( theLambda, lambdaPol, theAntiP,
	- antiP_Pol, index ) );
	+ ( m_const_B * amp_B( theLambda, lambdaPol,
	+ theAntiP, antiP_Pol, index ) +
	+ m_const_C * amp_C( theLambda, lambdaPol,
	+ theAntiP, antiP_Pol, index ) );
	}
	vertex( i, j, amplitude );
	}
	@@ -373,24 +378,25 @@
	// Form factor f1 for B-pi transition
	double EvtBBScalar::B_pi_f1( double t ) const
	{
	- FormFactor f = _f1Map[_scalarType];
	- double mv2 = f.mV * f.mV;
	- return f.value / ( ( 1 - t / mv2 ) * ( 1 - f.sigma1 * t / mv2 +
	- f.sigma2 * t * t / mv2 / mv2 ) );
	+ FormFactor f = m_f1Map[m_scalarType];
	+ double mv2 = f.m_mV * f.m_mV;
	+ return f.m_value / ( ( 1 - t / mv2 ) * ( 1 - f.m_sigma1 * t / mv2 +
	+ f.m_sigma2 * t * t / mv2 / mv2 ) );
	}

	// Form factor f0 for B-pi transition
	double EvtBBScalar::B_pi_f0( double t ) const
	{
	- FormFactor f = _f0Map[_scalarType];
	- double mv2 = f.mV * f.mV;
	- return f.value / ( 1 - f.sigma1 * t / mv2 + f.sigma2 * t * t / mv2 / mv2 );
	+ FormFactor f = m_f0Map[m_scalarType];
	+ double mv2 = f.m_mV * f.m_mV;
	+ return f.m_value /
	+ ( 1 - f.m_sigma1 * t / mv2 + f.m_sigma2 * t * t / mv2 / mv2 );
	}

	// constants of the B and C parts of the amplitude
	-const EvtComplex EvtBBScalar::const_B = V_ub * V_us_star * a1 -
	- V_tb * V_ts_star * a4;
	-const EvtComplex EvtBBScalar::const_C = 2 * a6 * V_tb * V_ts_star;
	+const EvtComplex EvtBBScalar::m_const_B = m_V_ub * m_V_us_star * m_a1 -
	+ m_V_tb * m_V_ts_star * m_a4;
	+const EvtComplex EvtBBScalar::m_const_C = 2 * m_a6 * m_V_tb * m_V_ts_star;

	// part A of the amplitude, see hep-ph/0204185
	const EvtVector4C EvtBBScalar::amp_A( const EvtVector4R& p4B,
	@@ -478,7 +484,7 @@
	baryonSumP4.set( mu, dummy );
	}
	double t = ( baryon1->getP4Lab() + baryon2->getP4Lab() ).mass2();
	- return baryonSumP4.get( index ) / ( m_b - m_u ) *
	+ return baryonSumP4.get( index ) / ( m_mb - m_mu ) *
	( amp_C_scalarPart( b1Pol, b2Pol, t ) +
	amp_C_pseudoscalarPart( b1Pol, b2Pol, t ) );
	}
	diff --git a/src/EvtGenModels/EvtBCSFF.cpp b/src/EvtGenModels/EvtBCSFF.cpp
	--- a/src/EvtGenModels/EvtBCSFF.cpp
	+++ b/src/EvtGenModels/EvtBCSFF.cpp
	@@ -34,10 +34,10 @@

	EvtBCSFF::EvtBCSFF( int idS, int fit )
	{
	- idScalar = idS;
	- whichfit = fit;
	- MBc = EvtPDL::getMeanMass( EvtPDL::getId( "B_c+" ) );
	- MD0 = EvtPDL::getMeanMass( EvtPDL::getId( "D0" ) );
	+ m_idScalar = idS;
	+ m_whichfit = fit;
	+ m_MBc = EvtPDL::getMeanMass( EvtPDL::getId( "B_c+" ) );
	+ m_MD0 = EvtPDL::getMeanMass( EvtPDL::getId( "D0" ) );
	return;
	}

	@@ -46,15 +46,15 @@
	{
	double q2 = t;

	- if ( whichfit == 0 ) {
	+ if ( m_whichfit == 0 ) {
	*fpf = 1;
	*f0f = 0;
	return;
	}

	- if ( idScalar == EvtPDL::getId( "chi_c0" ).getId() ) { // Bc -> chi_c0
	- if ( whichfit == 3 ) { // FF from Wang et al 10.1103/PhysRevD.79.114018
	- double ratio = q2 / ( MBc * MBc );
	+ if ( m_idScalar == EvtPDL::getId( "chi_c0" ).getId() ) { // Bc -> chi_c0
	+ if ( m_whichfit == 3 ) { // FF from Wang et al 10.1103/PhysRevD.79.114018
	+ double ratio = q2 / ( m_MBc * m_MBc );

	double fpf_0 = 0.47;
	double fpf_c1 = 2.03;
	@@ -73,10 +73,10 @@
	<< "Must choose 0 (fpf = 1) or 3 (Wang).\n";
	::abort();
	}
	- } else if ( idScalar == EvtPDL::getId( "D0" ).getId() \|\|
	- idScalar == EvtPDL::getId( "anti-D0" ).getId() ) { // Bc -> D0
	- if ( whichfit == 1 ) { // FF from Kiselev:2002vz, tables III, IV
	- double q2invmass = q2 / ( MBc * MBc - MD0 * MD0 );
	+ } else if ( m_idScalar == EvtPDL::getId( "D0" ).getId() \|\|
	+ m_idScalar == EvtPDL::getId( "anti-D0" ).getId() ) { // Bc -> D0
	+ if ( m_whichfit == 1 ) { // FF from Kiselev:2002vz, tables III, IV
	+ double q2invmass = q2 / ( m_MBc * m_MBc - m_MD0 * m_MD0 );
	double den = 1 - q2 / ( 5.0 * 5.0 );
	if ( fabs( den ) < 1e-10 ) {
	*fpf = 0;
	@@ -87,8 +87,8 @@
	*fpf = fPlus;
	f0f = q2invmass fMinus + fPlus;
	}
	- } else if ( whichfit == 2 ) { // FF from Ebert:2003cn, Fig 9
	- double ratio = q2 / MBc / MBc;
	+ } else if ( m_whichfit == 2 ) { // FF from Ebert:2003cn, Fig 9
	+ double ratio = q2 / m_MBc / m_MBc;
	double const fPlus_0 = 0.143, fPlus_a = 0.7, fPlus_b = 2.13;
	double const f0_0 = 0.136, f0_a = 1.63, f0_b = -0.139;
	fpf = fPlus_0 / ( 1 - fPlus_a ratio - fPlus_b * ratio * ratio );
	diff --git a/src/EvtGenModels/EvtBCTFF.cpp b/src/EvtGenModels/EvtBCTFF.cpp
	--- a/src/EvtGenModels/EvtBCTFF.cpp
	+++ b/src/EvtGenModels/EvtBCTFF.cpp
	@@ -34,9 +34,9 @@

	EvtBCTFF::EvtBCTFF( int idT, int fit )
	{
	- idTensor = idT;
	- whichfit = fit;
	- MBc = EvtPDL::getMeanMass( EvtPDL::getId( "B_c+" ) );
	+ m_idTensor = idT;
	+ m_whichfit = fit;
	+ m_MBc = EvtPDL::getMeanMass( EvtPDL::getId( "B_c+" ) );
	return;
	}

	@@ -60,7 +60,7 @@
	{
	double q2 = t;

	- if ( whichfit == 0 ) {
	+ if ( m_whichfit == 0 ) {
	*hf = 0;
	*kf = 0;
	*bpf = 0;
	@@ -68,9 +68,9 @@
	return;
	}

	- if ( idTensor == EvtPDL::getId( "chi_c2" ).getId() ) { // Bc -> chi_c1
	- if ( whichfit == 3 ) { // FF from Wang et al 10.1103/PhysRevD.79.114018
	- double ratio = q2 / ( MBc * MBc );
	+ if ( m_idTensor == EvtPDL::getId( "chi_c2" ).getId() ) { // Bc -> chi_c1
	+ if ( m_whichfit == 3 ) { // FF from Wang et al 10.1103/PhysRevD.79.114018
	+ double ratio = q2 / ( m_MBc * m_MBc );

	double hf_0 = 0.022;
	double hf_c1 = 2.58;
	diff --git a/src/EvtGenModels/EvtBCVFF.cpp b/src/EvtGenModels/EvtBCVFF.cpp
	--- a/src/EvtGenModels/EvtBCVFF.cpp
	+++ b/src/EvtGenModels/EvtBCVFF.cpp
	@@ -34,14 +34,14 @@

	EvtBCVFF::EvtBCVFF( int idV, int fit )
	{
	- idVector = idV;
	- whichfit = fit;
	- MBc = EvtPDL::getMeanMass( EvtPDL::getId( "B_c+" ) );
	- MD0 = EvtPDL::getMeanMass( EvtPDL::getId( "D*0" ) );
	- Mpsi = EvtPDL::getMeanMass( EvtPDL::getId( "J/psi" ) );
	- Mpsi2S = EvtPDL::getMeanMass( EvtPDL::getId( "psi(2S)" ) );
	- kappa = Mpsi / Mpsi2S;
	- Mchi = EvtPDL::getMeanMass( EvtPDL::getId( "chi_c1" ) );
	+ m_idVector = idV;
	+ m_whichfit = fit;
	+ m_MBc = EvtPDL::getMeanMass( EvtPDL::getId( "B_c+" ) );
	+ m_MD0 = EvtPDL::getMeanMass( EvtPDL::getId( "D*0" ) );
	+ m_Mpsi = EvtPDL::getMeanMass( EvtPDL::getId( "J/psi" ) );
	+ m_Mpsi2S = EvtPDL::getMeanMass( EvtPDL::getId( "psi(2S)" ) );
	+ m_kappa = m_Mpsi / m_Mpsi2S;
	+ m_Mchi = EvtPDL::getMeanMass( EvtPDL::getId( "chi_c1" ) );
	return;
	}

	@@ -50,7 +50,7 @@
	{
	double q2 = t;

	- if ( whichfit == 0 ) {
	+ if ( m_whichfit == 0 ) {
	*vf = 0;
	*a0f = 0;
	*a1f = 1;
	@@ -58,19 +58,20 @@
	return;
	}

	- if ( idVector == EvtPDL::getId( "J/psi" ).getId() ) { // Bc -> J/psi
	- if ( whichfit == 1 ) { // SR form factor set from [Kiselev, hep-ph/0211021]
	+ if ( m_idVector == EvtPDL::getId( "J/psi" ).getId() ) { // Bc -> J/psi
	+ if ( m_whichfit ==
	+ 1 ) { // SR form factor set from [Kiselev, hep-ph/0211021]
	double Mpole2 = 4.5 * 4.5, den = 1. / ( 1. - q2 / Mpole2 );
	double FV = 0.11 * den, FAp = -0.074 * den, FA0 = 5.9 * den,
	FAm = 0.12 * den;
	- vf = ( MBc + Mpsi ) FV;
	- a2f = -( MBc + Mpsi ) FAp;
	- *a1f = FA0 / ( MBc + Mpsi );
	- a0f = ( q2 FAm + ( MBc + Mpsi ) * ( *a1f ) -
	- ( MBc - Mpsi ) * ( *a2f ) ) /
	- ( 2 * Mpsi );
	+ vf = ( m_MBc + m_Mpsi ) FV;
	+ a2f = -( m_MBc + m_Mpsi ) FAp;
	+ *a1f = FA0 / ( m_MBc + m_Mpsi );
	+ a0f = ( q2 FAm + ( m_MBc + m_Mpsi ) * ( *a1f ) -
	+ ( m_MBc - m_Mpsi ) * ( *a2f ) ) /
	+ ( 2 * m_Mpsi );
	return;
	- } else if ( whichfit ==
	+ } else if ( m_whichfit ==
	2 ) { // form factor set from [Ebert, hep-ph/0306306]
	vf = ( 0.49077824756158533 - 0.0012925655191347828 q2 ) /
	( 1 - 0.06292520325875656 * q2 );
	@@ -87,21 +88,22 @@
	<< "Must choose 0 (a1f = 1), 1 (Kiselev), or 2 (Ebert).\n";
	::abort();
	}
	- } else if ( idVector ==
	+ } else if ( m_idVector ==
	EvtPDL::getId( "psi(2S)" ).getId() ) { // Bc -> psi((2S)
	- if ( whichfit == 1 ) {
	+ if ( m_whichfit == 1 ) {
	double Mpole2 = 4.5 * 4.5, den = 1. / ( 1. - q2 / Mpole2 );
	- double FV = 0.11 * den * kappa / 3.1,
	- FAp = -0.074 * den * kappa / 4.9,
	- FA0 = 5.9 * den * kappa / 3.5, FAm = 0.12 * den * kappa / 2.3;
	- vf = ( MBc + Mpsi2S ) FV;
	- a2f = -( MBc + Mpsi2S ) FAp;
	- *a1f = FA0 / ( MBc + Mpsi2S );
	- a0f = ( q2 FAm + ( MBc + Mpsi2S ) * ( *a1f ) -
	- ( MBc - Mpsi2S ) * ( *a2f ) ) /
	- ( 2 * Mpsi2S );
	+ double FV = 0.11 * den * m_kappa / 3.1,
	+ FAp = -0.074 * den * m_kappa / 4.9,
	+ FA0 = 5.9 * den * m_kappa / 3.5,
	+ FAm = 0.12 * den * m_kappa / 2.3;
	+ vf = ( m_MBc + m_Mpsi2S ) FV;
	+ a2f = -( m_MBc + m_Mpsi2S ) FAp;
	+ *a1f = FA0 / ( m_MBc + m_Mpsi2S );
	+ a0f = ( q2 FAm + ( m_MBc + m_Mpsi2S ) * ( *a1f ) -
	+ ( m_MBc - m_Mpsi2S ) * ( *a2f ) ) /
	+ ( 2 * m_Mpsi2S );
	return;
	- } else if ( whichfit == 2 ) {
	+ } else if ( m_whichfit == 2 ) {
	vf = ( 0.24177223968739653 - 0.053589051007278135 q2 ) /
	( 1 - 0.0977848994260899 * q2 );
	a0f = ( 0.23996026570086615 - 0.03530198514007337 q2 ) /
	@@ -117,11 +119,11 @@
	<< "Must choose 0 (a1f = 1), 1 (Kiselev), or 2 (Ebert).\n";
	::abort();
	}
	- } else if ( idVector == EvtPDL::getId( "chi_c1" ).getId() ) { // Bc -> chi_c1
	- if ( whichfit == 3 ) { // FF from Wang et al 10.1103/PhysRevD.79.114018
	- double SoverD = ( MBc + Mchi ) / ( MBc - Mchi );
	- double DoverS = ( MBc - Mchi ) / ( MBc + Mchi );
	- double ratio = q2 / ( MBc * MBc );
	+ } else if ( m_idVector == EvtPDL::getId( "chi_c1" ).getId() ) { // Bc -> chi_c1
	+ if ( m_whichfit == 3 ) { // FF from Wang et al 10.1103/PhysRevD.79.114018
	+ double SoverD = ( m_MBc + m_Mchi ) / ( m_MBc - m_Mchi );
	+ double DoverS = ( m_MBc - m_Mchi ) / ( m_MBc + m_Mchi );
	+ double ratio = q2 / ( m_MBc * m_MBc );

	double vf_0 = SoverD * 0.36;
	double vf_c1 = 1.98;
	@@ -149,9 +151,9 @@
	<< "Must choose 0 (a1f = 1) or 3 (Wang).\n";
	::abort();
	}
	- } else if ( idVector == EvtPDL::getId( "D*0" ).getId() \|\|
	- idVector == EvtPDL::getId( "anti-D*0" ).getId() ) {
	- if ( whichfit == 1 ) {
	+ } else if ( m_idVector == EvtPDL::getId( "D*0" ).getId() \|\|
	+ m_idVector == EvtPDL::getId( "anti-D*0" ).getId() ) {
	+ if ( m_whichfit == 1 ) {
	// SR form factor set from Kiselev, hep-ph/0211021
	double Mpole2 = 6.2 * 6.2, den = ( 1. - q2 / Mpole2 );
	if ( fabs( den ) < 1e-10 ) {
	@@ -162,17 +164,17 @@
	} else {
	double FV = 0.20 / den, FAp = -0.062 / den, FA0 = 3.6,
	FAm = 0.11 / den;
	- vf = ( MBc + MD0 ) FV;
	- a2f = -( MBc + MD0 ) FAp;
	- *a1f = FA0 / ( MBc + MD0 );
	- a0f = ( q2 FAm + ( MBc + MD0 ) * ( *a1f ) -
	- ( MBc - MD0 ) * ( *a2f ) ) /
	- ( 2 * MD0 );
	+ vf = ( m_MBc + m_MD0 ) FV;
	+ a2f = -( m_MBc + m_MD0 ) FAp;
	+ *a1f = FA0 / ( m_MBc + m_MD0 );
	+ a0f = ( q2 FAm + ( m_MBc + m_MD0 ) * ( *a1f ) -
	+ ( m_MBc - m_MD0 ) * ( *a2f ) ) /
	+ ( 2 * m_MD0 );
	}
	return;
	- } else if ( whichfit == 2 ) {
	+ } else if ( m_whichfit == 2 ) {
	// form factors from Ebert, hep-ph/0306306
	- double ratio = q2 / MBc / MBc;
	+ double ratio = q2 / m_MBc / m_MBc;
	double const fV_0 = 0.202, fV_a = 1.38, fV_b = 1.31;
	double const fA2_0 = 0.22, fA2_a = 2.44, fA2_b = -1.21;
	double const fA0_0 = 0.144, fA0_a = 1.18, fA0_b = 1.39;
	diff --git a/src/EvtGenModels/EvtBCVFF2.cpp b/src/EvtGenModels/EvtBCVFF2.cpp
	--- a/src/EvtGenModels/EvtBCVFF2.cpp
	+++ b/src/EvtGenModels/EvtBCVFF2.cpp
	@@ -24,9 +24,8 @@

	EvtBCVFF2::EvtBCVFF2( int idV, int fit )
	{
	- idVector = idV;
	- whichfit = fit;
	- //cout<<"==== EvtBCVFF2:: idVector="<<idVector<<" whichfit="<<whichfit<<endl;
	+ m_idVector = idV;
	+ m_whichfit = fit;
	return;
	}

	@@ -35,7 +34,7 @@
	{
	double q2 = t;

	- if ( whichfit == 0 ) {
	+ if ( m_whichfit == 0 ) {
	*vf = 0;
	*a0f = 0;
	*a1f = 1;
	@@ -44,8 +43,9 @@
	return;
	};

	- if ( idVector == EvtPDL::getId( "J/psi" ).getId() ) { // Bc -> J/psi
	- if ( whichfit == 1 ) { // SR form factor set from [Kiselev, hep-ph/0211021]
	+ if ( m_idVector == EvtPDL::getId( "J/psi" ).getId() ) { // Bc -> J/psi
	+ if ( m_whichfit ==
	+ 1 ) { // SR form factor set from [Kiselev, hep-ph/0211021]
	double Mbc = 6.277, Mpsi = 3.0967; // Experimental values
	double Mpole2 = 4.5 * 4.5, den = 1. / ( 1. - q2 / Mpole2 );
	double FV = 0.11 * den, FAp = -0.071 * den, FA0 = 5.9 * den,
	@@ -57,7 +57,7 @@
	( Mbc - Mpsi ) * ( *a2f ) ) /
	( 2 * Mpsi );
	return;
	- } else if ( whichfit ==
	+ } else if ( m_whichfit ==
	2 ) { // form factor set from [Ebert, hep-ph/0306306]
	vf = ( 0.49077824756158533 - 0.0012925655191347828 q2 ) /
	( 1 - 0.06292520325875656 * q2 );
	@@ -70,9 +70,9 @@
	( 1 - 0.04885587273651653 * q2 );
	return;
	};
	- } else if ( idVector ==
	+ } else if ( m_idVector ==
	EvtPDL::getId( "psi(2S)" ).getId() ) { // Bc -> psi((2S)
	- if ( whichfit == 1 ) {
	+ if ( m_whichfit == 1 ) {
	////cout<<"BC2:: psi2S, Kiselev, q2="<<q2<<endl;
	double Mbc = 6.277, Mpsi = 3.0967, Mpsi2S = 3.686,
	kappa = Mpsi / Mpsi2S; // Experimental values
	@@ -87,7 +87,7 @@
	( Mbc - Mpsi2S ) * ( *a2f ) ) /
	( 2 * Mpsi2S );
	return;
	- } else if ( whichfit == 2 ) {
	+ } else if ( m_whichfit == 2 ) {
	////cout<<"BC2:: psi2S, Ebert, q2="<<q2<<endl;
	vf = ( 0.24177223968739653 - 0.053589051007278135 q2 ) /
	( 1 - 0.0977848994260899 * q2 );
	diff --git a/src/EvtGenModels/EvtBLLNuL.cpp b/src/EvtGenModels/EvtBLLNuL.cpp
	--- a/src/EvtGenModels/EvtBLLNuL.cpp
	+++ b/src/EvtGenModels/EvtBLLNuL.cpp
	@@ -26,7 +26,7 @@
	#include "EvtGenBase/EvtReport.hh"
	#include "EvtGenBase/EvtSpinType.hh"

	-EvtBLLNuL::EvtBLLNuL() : calcAmp_()
	+EvtBLLNuL::EvtBLLNuL() : m_calcAmp()
	{
	}

	@@ -122,7 +122,7 @@

	// Define the amplitude qSq and kSq cut-offs, also
	// specifying if the decay mode has flavour symmetry
	- calcAmp_.setParameters( qSqMin, kSqMin, symmetry );
	+ m_calcAmp.setParameters( qSqMin, kSqMin, symmetry );
	}

	void EvtBLLNuL::initProbMax()
	@@ -144,5 +144,5 @@
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );

	- calcAmp_.CalcAmp( p, _amp2 );
	+ m_calcAmp.CalcAmp( p, m_amp2 );
	}
	diff --git a/src/EvtGenModels/EvtBLLNuLAmp.cpp b/src/EvtGenModels/EvtBLLNuLAmp.cpp
	--- a/src/EvtGenModels/EvtBLLNuLAmp.cpp
	+++ b/src/EvtGenModels/EvtBLLNuLAmp.cpp
	@@ -31,26 +31,26 @@
	#include <cmath>

	EvtBLLNuLAmp::EvtBLLNuLAmp( double Vub ) :
	- qSqMin_( 0.0 ),
	- kSqMin_( 0.0 ),
	- symmetry_( false ),
	- BpId_( EvtPDL::getId( "B+" ) ),
	- BnId_( EvtPDL::getId( "B-" ) ),
	- coupling_( 0.0 ),
	- sqrt2_( sqrt( 2.0 ) ),
	- fBu_( 0.191 ), // leptonic constant (GeV)
	- Bstar_( EvtBLLNuLAmp::ResPole( 5.32, 0.00658, 0.183 / 3.0 ) ),
	- Upsilon_( EvtBLLNuLAmp::ResPole( 9.64, 0.0, 0.0 ) ),
	- resPoles_(),
	- nPoles_( 0 ),
	- zero_( EvtComplex( 0.0, 0.0 ) ),
	- unitI_( EvtComplex( 0.0, 1.0 ) )
	+ m_qSqMin( 0.0 ),
	+ m_kSqMin( 0.0 ),
	+ m_symmetry( false ),
	+ m_BpId( EvtPDL::getId( "B+" ) ),
	+ m_BnId( EvtPDL::getId( "B-" ) ),
	+ m_coupling( 0.0 ),
	+ m_sqrt2( sqrt( 2.0 ) ),
	+ m_fBu( 0.191 ), // leptonic constant (GeV)
	+ m_Bstar( EvtBLLNuLAmp::ResPole( 5.32, 0.00658, 0.183 / 3.0 ) ),
	+ m_Upsilon( EvtBLLNuLAmp::ResPole( 9.64, 0.0, 0.0 ) ),
	+ m_resPoles(),
	+ m_nPoles( 0 ),
	+ m_zero( EvtComplex( 0.0, 0.0 ) ),
	+ m_unitI( EvtComplex( 0.0, 1.0 ) )
	{
	double GF = 1.166371e-5; // GeV^{-2}
	double alphaEM = 1.0 / 137.0;

	// Normalisation constant, multiplied by 1e4 to increase probability scale
	- coupling_ = 400.0 * GF * EvtConst::pi * alphaEM * Vub * 1e4 / sqrt2_;
	+ m_coupling = 400.0 * GF * EvtConst::pi * alphaEM * Vub * 1e4 / m_sqrt2;

	// Define VMD resonance poles using PDG 2016 values with constants from
	// D.Melikhov, N.Nikitin and K.Toms, Phys. Atom. Nucl. 68, 1842 (2005)
	@@ -58,37 +58,37 @@
	// Rho and omega resonances
	EvtBLLNuLAmp::ResPole rho = EvtBLLNuLAmp::ResPole( 0.77526, 0.1491,
	1.0 / 5.04 );
	- resPoles_.push_back( rho );
	+ m_resPoles.push_back( rho );

	EvtBLLNuLAmp::ResPole omega = EvtBLLNuLAmp::ResPole( 0.78265, 0.00849,
	1.0 / 17.1 );
	- resPoles_.push_back( omega );
	+ m_resPoles.push_back( omega );

	- nPoles_ = resPoles_.size();
	+ m_nPoles = m_resPoles.size();
	}

	EvtBLLNuLAmp::EvtBLLNuLAmp( double qSqMin, double kSqMin, bool symmetry,
	double Vub ) :
	- qSqMin_( qSqMin ),
	- kSqMin_( kSqMin ),
	- symmetry_( symmetry ),
	- BpId_( EvtPDL::getId( "B+" ) ),
	- BnId_( EvtPDL::getId( "B-" ) ),
	- coupling_( 0.0 ),
	- sqrt2_( sqrt( 2.0 ) ),
	- fBu_( 0.191 ), // leptonic constant (GeV)
	- Bstar_( EvtBLLNuLAmp::ResPole( 5.32, 0.00658, 0.183 / 3.0 ) ),
	- Upsilon_( EvtBLLNuLAmp::ResPole( 9.64, 0.0, 0.0 ) ),
	- resPoles_(),
	- nPoles_( 0 ),
	- zero_( EvtComplex( 0.0, 0.0 ) ),
	- unitI_( EvtComplex( 0.0, 1.0 ) )
	+ m_qSqMin( qSqMin ),
	+ m_kSqMin( kSqMin ),
	+ m_symmetry( symmetry ),
	+ m_BpId( EvtPDL::getId( "B+" ) ),
	+ m_BnId( EvtPDL::getId( "B-" ) ),
	+ m_coupling( 0.0 ),
	+ m_sqrt2( sqrt( 2.0 ) ),
	+ m_fBu( 0.191 ), // leptonic constant (GeV)
	+ m_Bstar( EvtBLLNuLAmp::ResPole( 5.32, 0.00658, 0.183 / 3.0 ) ),
	+ m_Upsilon( EvtBLLNuLAmp::ResPole( 9.64, 0.0, 0.0 ) ),
	+ m_resPoles(),
	+ m_nPoles( 0 ),
	+ m_zero( EvtComplex( 0.0, 0.0 ) ),
	+ m_unitI( EvtComplex( 0.0, 1.0 ) )
	{
	double GF = 1.166371e-5; // GeV^{-2}
	double alphaEM = 1.0 / 137.0;

	// Normalisation constant, multiplied by 1e4 to increase probability scale
	- coupling_ = 400.0 * GF * EvtConst::pi * alphaEM * Vub * 1e4 / sqrt2_;
	+ m_coupling = 400.0 * GF * EvtConst::pi * alphaEM * Vub * 1e4 / m_sqrt2;

	// Define VMD resonance poles using PDG 2016 values with constants from
	// D.Melikhov, N.Nikitin and K.Toms, Phys. Atom. Nucl. 68, 1842 (2005)
	@@ -96,35 +96,35 @@
	// Rho and omega resonances
	EvtBLLNuLAmp::ResPole rho = EvtBLLNuLAmp::ResPole( 0.77526, 0.1491,
	1.0 / 5.04 );
	- resPoles_.push_back( rho );
	+ m_resPoles.push_back( rho );

	EvtBLLNuLAmp::ResPole omega = EvtBLLNuLAmp::ResPole( 0.78265, 0.00849,
	1.0 / 17.1 );
	- resPoles_.push_back( omega );
	+ m_resPoles.push_back( omega );

	- nPoles_ = resPoles_.size();
	+ m_nPoles = m_resPoles.size();
	}

	// Storing resonance pole information
	EvtBLLNuLAmp::ResPole::ResPole( double mass, double width, double coupling ) :
	- m0_( mass ),
	- m0Sq_( mass * mass ),
	- w0_( width ),
	- c_( coupling ),
	- I_( EvtComplex( 0.0, 1.0 ) ),
	- Imw_( I_ * mass * width )
	+ m_m0( mass ),
	+ m_m0Sq( mass * mass ),
	+ m_w0( width ),
	+ m_c( coupling ),
	+ m_I( EvtComplex( 0.0, 1.0 ) ),
	+ m_Imw( m_I * mass * width )
	{
	}

	EvtComplex EvtBLLNuLAmp::ResPole::propagator( double qSq, int numForm ) const
	{
	// Numerator term: mass-squared (default) or mass
	- double num( m0Sq_ );
	+ double num( m_m0Sq );
	if ( numForm == 1 ) {
	- num = m0_;
	+ num = m_m0;
	}

	- EvtComplex result = num * c_ / ( ( qSq - m0Sq_ ) + Imw_ );
	+ EvtComplex result = num * m_c / ( ( qSq - m_m0Sq ) + m_Imw );
	return result;
	}

	@@ -166,7 +166,7 @@

	// Check if we are above mass thresholds
	bool threshold( true );
	- if ( q12Sq < qSqMin_ \|\| k34Sq < kSqMin_ ) {
	+ if ( q12Sq < m_qSqMin \|\| k34Sq < m_kSqMin ) {
	threshold = false;
	}

	@@ -174,13 +174,13 @@
	// 2nd and 3rd charged leptons: p2 <-> p4
	EvtVector4R q14, k23;
	double q14Sq( 0.0 ), k23Sq( 0.0 );
	- if ( symmetry_ ) {
	+ if ( m_symmetry ) {
	q14 = p1 + p4;
	k23 = p2 + p3;
	q14Sq = q14.mass2();
	k23Sq = k23.mass2();

	- if ( q14Sq < qSqMin_ \|\| k23Sq < kSqMin_ ) {
	+ if ( q14Sq < m_qSqMin \|\| k23Sq < m_kSqMin ) {
	threshold = false;
	}
	}
	@@ -189,7 +189,7 @@
	EvtId parId = parent->getId();
	// B+ or B- decays
	int sign( 1 );
	- if ( parId == BnId_ ) {
	+ if ( parId == m_BnId ) {
	sign = -1;
	}

	@@ -198,7 +198,7 @@

	// When we need to include the symmetric terms
	EvtTensor4C THadronB;
	- if ( symmetry_ ) {
	+ if ( m_symmetry ) {
	THadronB = getHadronTensor( q14, k23, q14Sq, k23Sq, MB, sign );
	}

	@@ -220,7 +220,7 @@
	L2A = EvtLeptonVCurrent( lepB->spParent( i2 ),
	lepA->spParent( i1 ) );

	- if ( symmetry_ ) {
	+ if ( m_symmetry ) {
	// Swapping the 2nd and 3rd charged leptons
	L1B = EvtLeptonVACurrent( lepB->spParent( i2 ),
	neu->spParentNeutrino() );
	@@ -232,7 +232,7 @@
	L2A = EvtLeptonVCurrent( lepA->spParent( i1 ),
	lepB->spParent( i2 ) );

	- if ( symmetry_ ) {
	+ if ( m_symmetry ) {
	// Swapping the 2nd and 3rd charged leptons
	L1B = EvtLeptonVACurrent( neu->spParentNeutrino(),
	lepB->spParent( i2 ) );
	@@ -252,7 +252,7 @@
	L1A = EvtLeptonVACurrent( lepC->spParent( i4 ),
	neu->spParentNeutrino() );

	- if ( symmetry_ ) {
	+ if ( m_symmetry ) {
	// Swapping the 2nd and 3rd charged leptons
	L2B = EvtLeptonVCurrent( lepC->spParent( i4 ),
	lepA->spParent( i1 ) );
	@@ -264,7 +264,7 @@
	L1A = EvtLeptonVACurrent( neu->spParentNeutrino(),
	lepC->spParent( i4 ) );

	- if ( symmetry_ ) {
	+ if ( m_symmetry ) {
	// Swapping the 2nd and 3rd charged leptons
	L2B = EvtLeptonVCurrent( lepA->spParent( i1 ),
	lepC->spParent( i4 ) );
	@@ -273,14 +273,14 @@

	if ( threshold == false ) {
	// Below kinematic thresholds
	- amp.vertex( leptonSpins, zero_ );
	+ amp.vertex( leptonSpins, m_zero );

	} else {
	// Decay amplitude calculation: L_1^{\mu} Tfi_{\mu}
	EvtComplex decAmp = L1A * THL2A;

	// If we also need to swap the 2nd and 3rd charged leptons
	- if ( symmetry_ ) {
	+ if ( m_symmetry ) {
	// Hadronic current production term. L2B depends on i4 so we need
	// it here instead of inside the i2 loop as was the case for THL2A
	EvtVector4C THL2B = THadronB.cont2( L2B );
	@@ -316,21 +316,22 @@
	std::vector<EvtComplex> VMDAmps = getVMDTerms( qSq, kSq, MB );

	EvtComplex FF_ekq = BstarAmp + VMDAmps[0];
	- EvtComplex FF_g = VMDAmps[1] - fBu_;
	+ EvtComplex FF_g = VMDAmps[1] - m_fBu;
	EvtComplex FF_qk = VMDAmps[2];

	// Full hadronic tensor
	EvtTensor4C THadron = sign * 2.0 * FF_ekq * epskq +
	- unitI_ * ( 2.0 * FF_qk * qk - FF_g * EvtTensor4C::g() );
	+ m_unitI *
	+ ( 2.0 * FF_qk * qk - FF_g * EvtTensor4C::g() );

	// Kinematic cuts
	double coeffcut( 0.0 );
	- if ( qSq > qSqMin_ && kSq > kSqMin_ ) {
	+ if ( qSq > m_qSqMin && kSq > m_kSqMin ) {
	coeffcut = 1.0 / qSq;
	}

	// Normalisation constant
	- THadron = coeffcut coupling_;
	+ THadron = coeffcut m_coupling;

	return THadron;
	}
	@@ -342,8 +343,8 @@
	EvtComplex VMD1( 0.0, 0.0 ), VMD2( 0.0, 0.0 ), VMD3( 0.0, 0.0 );

	// Loop over the VMD poles
	- for ( int iPole = 0; iPole < nPoles_; iPole++ ) {
	- auto pole = resPoles_[iPole];
	+ for ( int iPole = 0; iPole < m_nPoles; iPole++ ) {
	+ auto pole = m_resPoles[iPole];

	// Propagator term, common for all factors
	EvtComplex prop = pole.propagator( qSq );
	@@ -373,8 +374,8 @@

	EvtComplex EvtBLLNuLAmp::getBStarTerm( double qSq, double kSq, double MB ) const
	{
	- EvtComplex amplitude = Bstar_.propagator( kSq, 1 ) * FF_B2Bstar( qSq ) /
	- ( MB + Bstar_.getMass() );
	+ EvtComplex amplitude = m_Bstar.propagator( kSq, 1 ) * FF_B2Bstar( qSq ) /
	+ ( MB + m_Bstar.getMass() );
	return amplitude;
	}

	@@ -382,7 +383,7 @@
	{
	// Electromagnetic FF for B -> B* transition, when gamma is emitted from the b quark
	// D.Melikhov, private communication
	- double y = qSq / Upsilon_.getMassSq();
	+ double y = qSq / m_Upsilon.getMassSq();
	double denom = ( 1.0 - y ) * ( 1.0 - 0.81 * y );

	double V( 0.0 );
	@@ -396,8 +397,8 @@
	double EvtBLLNuLAmp::FF_V( double kSq ) const
	{
	// D. Melikhov and B. Stech, PRD 62, 014006 (2000) Table XV
	- double y = kSq / Bstar_.getMassSq();
	- double denom = sqrt2_ * ( 1.0 - y ) * ( 1.0 - 0.59 * y );
	+ double y = kSq / m_Bstar.getMassSq();
	+ double denom = m_sqrt2 * ( 1.0 - y ) * ( 1.0 - 0.59 * y );

	double V( 0.0 );
	if ( fabs( denom ) > 1e-10 ) {
	@@ -410,8 +411,8 @@
	double EvtBLLNuLAmp::FF_A1( double kSq ) const
	{
	// D. Melikhov and B. Stech, PRD 62, 014006 (2000) Table XV
	- double y = kSq / Bstar_.getMassSq();
	- double denom = ( ( 0.1 * y - 0.73 ) * y + 1.0 ) * sqrt2_;
	+ double y = kSq / m_Bstar.getMassSq();
	+ double denom = ( ( 0.1 * y - 0.73 ) * y + 1.0 ) * m_sqrt2;

	double A1( 0.0 );
	if ( fabs( denom ) > 1e-10 ) {
	@@ -424,8 +425,8 @@
	double EvtBLLNuLAmp::FF_A2( double kSq ) const
	{
	// D. Melikhov and B. Stech, PRD 62, 014006 (2000) Table XV
	- double y = kSq / Bstar_.getMassSq();
	- double denom = ( ( 0.5 * y - 1.4 ) * y + 1.0 ) * sqrt2_;
	+ double y = kSq / m_Bstar.getMassSq();
	+ double denom = ( ( 0.5 * y - 1.4 ) * y + 1.0 ) * m_sqrt2;

	double A2( 0.0 );
	if ( fabs( denom ) > 1e-10 ) {
	diff --git a/src/EvtGenModels/EvtBTo3hCP.cpp b/src/EvtGenModels/EvtBTo3hCP.cpp
	--- a/src/EvtGenModels/EvtBTo3hCP.cpp
	+++ b/src/EvtGenModels/EvtBTo3hCP.cpp
	@@ -48,16 +48,19 @@

	void EvtBTo3hCP::setConstants( double balpha, double bbeta )
	{
	- alphaCP = balpha;
	- double calpha = cos( alphaCP );
	- double salpha = sin( alphaCP );
	- betaCP = bbeta;
	- double cbeta = cos( betaCP );
	- double sbeta = sin( betaCP );
	-
	- MA2 = square( M_B ) + square( M_pip ) + square( M_pi0 ) + square( M_pi0 );
	- MB2 = square( M_B ) + square( M_pip ) + square( M_pim ) + square( M_pi0 );
	- MC2 = square( M_B ) + square( M_Kp ) + square( M_pim ) + square( M_pi0 );
	+ m_alphaCP = balpha;
	+ double calpha = cos( m_alphaCP );
	+ double salpha = sin( m_alphaCP );
	+ m_betaCP = bbeta;
	+ double cbeta = cos( m_betaCP );
	+ double sbeta = sin( m_betaCP );
	+
	+ m_MA2 = square( m_M_B ) + square( m_M_pip ) + square( m_M_pi0 ) +
	+ square( m_M_pi0 );
	+ m_MB2 = square( m_M_B ) + square( m_M_pip ) + square( m_M_pim ) +
	+ square( m_M_pi0 );
	+ m_MC2 = square( m_M_B ) + square( m_M_Kp ) + square( m_M_pim ) +
	+ square( m_M_pi0 );

	double StrongPhase = 0;
	EvtComplex StrongExp( cos( StrongPhase ), sin( StrongPhase ) );
	@@ -100,33 +103,33 @@
	Mat_Tpm = StrongExp * Mat_Tpm;
	Nat_Tpm = StrongExp * Nat_Tpm;

	- Mat_S1 = Mat_Tp0 + 2. * Mat_P1;
	- Mat_S2 = Mat_T0p - 2. * Mat_P1;
	- Mat_S3 = Mat_Tpm + Mat_P1 + Mat_P0;
	- Mat_S4 = Mat_Tmp - Mat_P1 + Mat_P0;
	- Mat_S5 = -Mat_Tpm - Mat_Tmp + Mat_Tp0 + Mat_T0p - 2. * Mat_P0;
	+ m_Mat_S1 = Mat_Tp0 + 2. * Mat_P1;
	+ m_Mat_S2 = Mat_T0p - 2. * Mat_P1;
	+ m_Mat_S3 = Mat_Tpm + Mat_P1 + Mat_P0;
	+ m_Mat_S4 = Mat_Tmp - Mat_P1 + Mat_P0;
	+ m_Mat_S5 = -Mat_Tpm - Mat_Tmp + Mat_Tp0 + Mat_T0p - 2. * Mat_P0;

	- Nat_S1 = Nat_Tp0 + 2. * Nat_P1;
	- Nat_S2 = Nat_T0p - 2. * Nat_P1;
	- Nat_S3 = Nat_Tpm + Nat_P1 + Nat_P0;
	- Nat_S4 = Nat_Tmp - Nat_P1 + Nat_P0;
	- Nat_S5 = -Nat_Tpm - Nat_Tmp + Nat_Tp0 + Nat_T0p - 2. * Nat_P0;
	+ m_Nat_S1 = Nat_Tp0 + 2. * Nat_P1;
	+ m_Nat_S2 = Nat_T0p - 2. * Nat_P1;
	+ m_Nat_S3 = Nat_Tpm + Nat_P1 + Nat_P0;
	+ m_Nat_S4 = Nat_Tmp - Nat_P1 + Nat_P0;
	+ m_Nat_S5 = -Nat_Tpm - Nat_Tmp + Nat_Tp0 + Nat_T0p - 2. * Nat_P0;

	// B0 -->-- K*+ pi- Amplitudes (Trees + Penguins)
	- MatKstarp = EvtComplex( calpha, -salpha ) * EvtComplex( 0.220, 0. ) +
	- EvtComplex( cbeta, sbeta ) * EvtComplex( -1.200, 0. );
	+ m_MatKstarp = EvtComplex( calpha, -salpha ) * EvtComplex( 0.220, 0. ) +
	+ EvtComplex( cbeta, sbeta ) * EvtComplex( -1.200, 0. );
	// B0 -->-- K*0 pi0 Amplitudes (Trees + Penguins)
	- MatKstar0 = EvtComplex( calpha, -salpha ) * EvtComplex( 0.015, 0. ) +
	- EvtComplex( cbeta, sbeta ) * EvtComplex( 0.850, 0. );
	+ m_MatKstar0 = EvtComplex( calpha, -salpha ) * EvtComplex( 0.015, 0. ) +
	+ EvtComplex( cbeta, sbeta ) * EvtComplex( 0.850, 0. );
	// B0 -->-- K+ rho- Amplitudes (Trees + Penguins)
	- MatKrho = EvtComplex( calpha, -salpha ) * EvtComplex( 0.130, 0. ) +
	- EvtComplex( cbeta, sbeta ) * EvtComplex( 0.160, 0. );
	+ m_MatKrho = EvtComplex( calpha, -salpha ) * EvtComplex( 0.130, 0. ) +
	+ EvtComplex( cbeta, sbeta ) * EvtComplex( 0.160, 0. );
	// B0bar -->-- K*+ pi- Amplitudes (Trees + Penguins)
	- NatKstarp = EvtComplex( 0., 0. );
	+ m_NatKstarp = EvtComplex( 0., 0. );
	// B0bar -->-- K*0 pi0 Amplitudes (Trees + Penguins)
	- NatKstar0 = EvtComplex( 0., 0. );
	+ m_NatKstar0 = EvtComplex( 0., 0. );
	// B0bar -->-- K+ rho- Amplitudes (Trees + Penguins)
	- NatKrho = EvtComplex( 0., 0. );
	+ m_NatKrho = EvtComplex( 0., 0. );
	}

	void EvtBTo3hCP::Evt3pi( double alpha, int iset, EvtVector4R& p_pi_plus,
	@@ -143,9 +146,9 @@
	setConstants( alpha, 0.362 );

	if ( iset == 0 ) {
	- p_pi_plus.set( M_pip, 0, 0, 0 );
	- p_p2.set( M_pi0, 0, 0, 0 );
	- p_pi_minus.set( M_pim, 0, 0, 0 );
	+ p_pi_plus.set( m_M_pip, 0, 0, 0 );
	+ p_p2.set( m_M_pi0, 0, 0, 0 );
	+ p_pi_minus.set( m_M_pim, 0, 0, 0 );

	do {
	firstStep( p_pi_plus, p_p2, p_pi_minus, 1 );
	@@ -163,13 +166,13 @@
	}
	} else // iset > 0
	{
	- factor_max = 0;
	+ m_factor_max = 0;

	int endLoop = iset;
	for ( int i = 0; i < endLoop; ++i ) {
	- p_pi_plus.set( M_pip, 0, 0, 0 );
	- p_p2.set( M_pi0, 0, 0, 0 );
	- p_pi_minus.set( M_pim, 0, 0, 0 );
	+ p_pi_plus.set( m_M_pip, 0, 0, 0 );
	+ p_p2.set( m_M_pi0, 0, 0, 0 );
	+ p_pi_minus.set( m_M_pim, 0, 0, 0 );

	firstStep( p_pi_plus, p_p2, p_pi_minus, 1 );
	ierr = compute3pi( p_pi_plus, p_p2, p_pi_minus, Real_B0, Imag_B0,
	@@ -184,16 +187,16 @@
	R2 = ( 2.0 * Ainter ) / ( AB0 + AB0bar );
	factor = ( 1.0 + sqrt( square( R1 ) + square( R2 ) ) ) *
	( AB0 + AB0bar ) / 2.0;
	- if ( factor > factor_max )
	- factor_max = factor;
	+ if ( factor > m_factor_max )
	+ m_factor_max = factor;
	}
	- factor_max = 1.0 / std::sqrt( factor_max );
	+ m_factor_max = 1.0 / std::sqrt( m_factor_max );
	}

	- Real_B0 *= factor_max;
	- Imag_B0 *= factor_max;
	- Real_B0bar *= factor_max;
	- Imag_B0bar *= factor_max;
	+ Real_B0 *= m_factor_max;
	+ Imag_B0 *= m_factor_max;
	+ Real_B0bar *= m_factor_max;
	+ Imag_B0bar *= m_factor_max;

	if ( iset < 0 ) {
	return;
	@@ -218,9 +221,9 @@
	setConstants( alpha, 0.362 );

	if ( iset == 0 ) {
	- p_p1.set( M_pim, 0, 0, 0 );
	- p_p2.set( M_pip, 0, 0, 0 );
	- p_p3.set( M_pip, 0, 0, 0 );
	+ p_p1.set( m_M_pim, 0, 0, 0 );
	+ p_p2.set( m_M_pip, 0, 0, 0 );
	+ p_p3.set( m_M_pip, 0, 0, 0 );

	do {
	firstStep( p_p1, p_p2, p_p3, 2 );
	@@ -237,13 +240,13 @@
	}
	} else // iset > 0
	{
	- factor_max = 0;
	+ m_factor_max = 0;

	int endLoop = iset;
	for ( int i = 0; i < endLoop; ++i ) {
	- p_p1.set( M_pim, 0, 0, 0 );
	- p_p2.set( M_pip, 0, 0, 0 );
	- p_p3.set( M_pip, 0, 0, 0 );
	+ p_p1.set( m_M_pim, 0, 0, 0 );
	+ p_p2.set( m_M_pip, 0, 0, 0 );
	+ p_p3.set( m_M_pip, 0, 0, 0 );

	firstStep( p_p1, p_p2, p_p3, 2 );
	ierr = compute3piMPP( p_p1, p_p2, p_p3, Real_B0, Imag_B0,
	@@ -253,18 +256,18 @@
	}
	ABp = square( Real_B0 ) + square( Imag_B0 );
	ABm = square( Real_B0bar ) + square( Imag_B0bar );
	- if ( ABp > factor_max )
	- factor_max = ABp;
	- if ( ABm > factor_max )
	- factor_max = ABm;
	+ if ( ABp > m_factor_max )
	+ m_factor_max = ABp;
	+ if ( ABm > m_factor_max )
	+ m_factor_max = ABm;
	}
	- factor_max = 1.0 / std::sqrt( factor_max );
	+ m_factor_max = 1.0 / std::sqrt( m_factor_max );
	}

	- Real_B0 *= factor_max;
	- Imag_B0 *= factor_max;
	- Real_B0bar *= factor_max;
	- Imag_B0bar *= factor_max;
	+ Real_B0 *= m_factor_max;
	+ Imag_B0 *= m_factor_max;
	+ Real_B0bar *= m_factor_max;
	+ Imag_B0bar *= m_factor_max;

	if ( iset < 0 ) {
	return;
	@@ -289,9 +292,9 @@
	setConstants( alpha, 0.362 );

	if ( iset == 0 ) {
	- p_p1.set( M_pip, 0, 0, 0 );
	- p_p2.set( M_pi0, 0, 0, 0 );
	- p_p3.set( M_pi0, 0, 0, 0 );
	+ p_p1.set( m_M_pip, 0, 0, 0 );
	+ p_p2.set( m_M_pi0, 0, 0, 0 );
	+ p_p3.set( m_M_pi0, 0, 0, 0 );

	do {
	firstStep( p_p1, p_p2, p_p3, 3 );
	@@ -310,13 +313,13 @@
	}
	} else // iset > 0
	{
	- factor_max = 0;
	+ m_factor_max = 0;

	int endLoop = iset;
	for ( int i = 0; i < endLoop; ++i ) {
	- p_p1.set( M_pip, 0, 0, 0 );
	- p_p2.set( M_pi0, 0, 0, 0 );
	- p_p3.set( M_pi0, 0, 0, 0 );
	+ p_p1.set( m_M_pip, 0, 0, 0 );
	+ p_p2.set( m_M_pi0, 0, 0, 0 );
	+ p_p3.set( m_M_pi0, 0, 0, 0 );

	firstStep( p_p1, p_p2, p_p3, 3 );
	ierr = compute3piP00( p_p1, p_p2, p_p3, Real_B0, Imag_B0,
	@@ -326,18 +329,18 @@
	}
	ABp = square( Real_B0 ) + square( Imag_B0 );
	ABm = square( Real_B0bar ) + square( Imag_B0bar );
	- if ( ABp > factor_max )
	- factor_max = ABp;
	- if ( ABm > factor_max )
	- factor_max = ABm;
	+ if ( ABp > m_factor_max )
	+ m_factor_max = ABp;
	+ if ( ABm > m_factor_max )
	+ m_factor_max = ABm;
	}
	- factor_max = 1.0 / std::sqrt( factor_max );
	+ m_factor_max = 1.0 / std::sqrt( m_factor_max );
	}

	- Real_B0 *= factor_max;
	- Imag_B0 *= factor_max;
	- Real_B0bar *= factor_max;
	- Imag_B0bar *= factor_max;
	+ Real_B0 *= m_factor_max;
	+ Imag_B0 *= m_factor_max;
	+ Real_B0bar *= m_factor_max;
	+ Imag_B0bar *= m_factor_max;

	if ( iset < 0 ) {
	return;
	@@ -364,9 +367,9 @@
	setConstants( alpha, beta );

	if ( iset == 0 ) {
	- p_K_plus.set( M_Kp, 0, 0, 0 );
	- p_pi_minus.set( M_pim, 0, 0, 0 );
	- p_p3.set( M_pi0, 0, 0, 0 );
	+ p_K_plus.set( m_M_Kp, 0, 0, 0 );
	+ p_pi_minus.set( m_M_pim, 0, 0, 0 );
	+ p_p3.set( m_M_pi0, 0, 0, 0 );

	do {
	firstStep( p_K_plus, p_pi_minus, p_p3, 0 );
	@@ -384,13 +387,13 @@
	}
	} else // iset > 0
	{
	- factor_max = 0;
	+ m_factor_max = 0;

	int endLoop = iset;
	for ( int i = 0; i < endLoop; ++i ) {
	- p_K_plus.set( M_Kp, 0, 0, 0 );
	- p_pi_minus.set( M_pim, 0, 0, 0 );
	- p_p3.set( M_pi0, 0, 0, 0 );
	+ p_K_plus.set( m_M_Kp, 0, 0, 0 );
	+ p_pi_minus.set( m_M_pim, 0, 0, 0 );
	+ p_p3.set( m_M_pi0, 0, 0, 0 );
	firstStep( p_K_plus, p_pi_minus, p_p3, 0 );
	ierr = computeKpipi( p_K_plus, p_pi_minus, p_p3, Real_B0, Imag_B0,
	Real_B0bar, Imag_B0bar, iset );
	@@ -400,20 +403,20 @@
	ABp = square( Real_B0 ) + square( Imag_B0 );
	ABm = square( Real_B0bar ) + square( Imag_B0bar );

	- if ( ABp > factor_max ) {
	- factor_max = ABp;
	+ if ( ABp > m_factor_max ) {
	+ m_factor_max = ABp;
	}
	- if ( ABm > factor_max ) {
	- factor_max = ABm;
	+ if ( ABm > m_factor_max ) {
	+ m_factor_max = ABm;
	}
	}
	- factor_max = 1.0 / std::sqrt( factor_max );
	+ m_factor_max = 1.0 / std::sqrt( m_factor_max );
	}

	- Real_B0 *= factor_max;
	- Imag_B0 *= factor_max;
	- Real_B0bar *= factor_max;
	- Imag_B0bar *= factor_max;
	+ Real_B0 *= m_factor_max;
	+ Imag_B0 *= m_factor_max;
	+ Real_B0bar *= m_factor_max;
	+ Imag_B0bar *= m_factor_max;

	if ( iset < 0 ) {
	return;
	@@ -434,9 +437,9 @@
	const double m3sq = p3.mass2();
	double min_m12, min_m13, min_m23;

	- double max_m12 = square( M_B );
	- double max_m13 = square( M_B );
	- double max_m23 = square( M_B );
	+ double max_m12 = square( m_M_B );
	+ double max_m13 = square( m_M_B );
	+ double max_m23 = square( m_M_B );

	if ( mode == 0 ) {
	min_m12 = m1sq + m2sq + 2 * sqrt( m1sq * m2sq );
	@@ -464,16 +467,16 @@
	do {
	switch ( mode ) {
	case 0:
	- generateSqMasses_Kpipi( m12, m13, m23, MC2, m1sq, m2sq, m3sq );
	+ generateSqMasses_Kpipi( m12, m13, m23, m_MC2, m1sq, m2sq, m3sq );
	break;
	case 1:
	- generateSqMasses_3pi( m12, m13, m23, MB2, m1sq, m2sq, m3sq );
	+ generateSqMasses_3pi( m12, m13, m23, m_MB2, m1sq, m2sq, m3sq );
	break;
	case 2:
	- generateSqMasses_3piMPP( m12, m13, m23, MB2, m1sq, m2sq, m3sq );
	+ generateSqMasses_3piMPP( m12, m13, m23, m_MB2, m1sq, m2sq, m3sq );
	break;
	case 3:
	- generateSqMasses_3piP00( m12, m13, m23, MA2, m1sq, m2sq, m3sq );
	+ generateSqMasses_3piP00( m12, m13, m23, m_MA2, m1sq, m2sq, m3sq );
	break;
	default:
	break;
	@@ -487,9 +490,9 @@
	continue;

	// Now check the cosines of the angles
	- E1 = ( square( M_B ) + m1sq - m23 ) / ( 2. * M_B );
	- E2 = ( square( M_B ) + m2sq - m13 ) / ( 2. * M_B );
	- E3 = ( square( M_B ) + m3sq - m12 ) / ( 2. * M_B );
	+ E1 = ( square( m_M_B ) + m1sq - m23 ) / ( 2. * m_M_B );
	+ E2 = ( square( m_M_B ) + m2sq - m13 ) / ( 2. * m_M_B );
	+ E3 = ( square( m_M_B ) + m3sq - m12 ) / ( 2. * m_M_B );
	p1mom = square( E1 ) - m1sq;
	p2mom = square( E2 ) - m2sq;
	p3mom = square( E3 ) - m3sq;
	@@ -527,17 +530,17 @@
	if ( p3.get( 0 ) < p3.d3mag() ) {
	std::cout << "Unphysical p3 generated: " << p3 << std::endl;
	}
	- double testMB2 = MB2;
	+ double testMB2 = m_MB2;
	switch ( mode ) {
	case 0:
	- testMB2 = MC2;
	+ testMB2 = m_MC2;
	break;
	case 1:
	case 2:
	- testMB2 = MB2;
	+ testMB2 = m_MB2;
	break;
	case 3:
	- testMB2 = MA2;
	+ testMB2 = m_MA2;
	break;
	}

	@@ -566,13 +569,13 @@
	*/
	static bool phaseSpace = false;

	- double max_m12 = square( M_B );
	+ double max_m12 = square( m_M_B );
	double min_m12 = m1sq + m2sq + 2 * sqrt( m1sq * m2sq );

	- double max_m13 = square( M_B );
	+ double max_m13 = square( m_M_B );
	double min_m13 = m1sq + m3sq + 2 * sqrt( m1sq * m3sq );

	- double max_m23 = square( M_B );
	+ double max_m23 = square( m_M_B );
	double min_m23 = m2sq + m3sq + 2 * sqrt( m2sq * m3sq );

	double z = 3. * EvtRandom::Flat();
	@@ -581,9 +584,9 @@
	if ( phaseSpace ) {
	m13 = EvtRandom::Flat() * ( max_m13 - min_m13 ) + min_m13;
	} else {
	- double y = EvtRandom::Flat() * pi - pi / 2;
	+ double y = EvtRandom::Flat() * m_pi - m_pi / 2;
	double x = std::tan( y );
	- double mass = x * Gam_Kstarp / 2. + Mass_Kstarp;
	+ double mass = x * m_Gam_Kstarp / 2. + m_Mass_Kstarp;
	m13 = square( mass );
	}
	m12 = EvtRandom::Flat() * ( max_m12 - min_m12 ) + min_m12;
	@@ -593,9 +596,9 @@
	if ( phaseSpace ) {
	m12 = EvtRandom::Flat() * ( max_m12 - min_m12 ) + min_m12;
	} else {
	- double y = EvtRandom::Flat() * pi - pi / 2;
	+ double y = EvtRandom::Flat() * m_pi - m_pi / 2;
	double x = std::tan( y );
	- double mass = x * Gam_Kstar0 / 2. + Mass_Kstar0;
	+ double mass = x * m_Gam_Kstar0 / 2. + m_Mass_Kstar0;
	m12 = square( mass );
	}
	m13 = EvtRandom::Flat() * ( max_m13 - min_m13 ) + min_m13;
	@@ -605,9 +608,9 @@
	if ( phaseSpace ) {
	m23 = EvtRandom::Flat() * ( max_m23 - min_m23 ) + min_m23;
	} else {
	- double y = EvtRandom::Flat() * pi - pi / 2;
	+ double y = EvtRandom::Flat() * m_pi - m_pi / 2;
	double x = std::tan( y );
	- double mass = x * Gam_rho / 2. + Mass_rho;
	+ double mass = x * m_Gam_rho / 2. + m_Mass_rho;
	m23 = square( mass );
	}
	m13 = EvtRandom::Flat() * ( max_m13 - min_m13 ) + min_m13;
	@@ -634,20 +637,20 @@
	*/
	static bool phaseSpace = false;

	- double max_m12 = square( M_B );
	+ double max_m12 = square( m_M_B );
	double min_m12 = m1sq + m2sq;

	- double max_m13 = square( M_B );
	+ double max_m13 = square( m_M_B );
	double min_m13 = m1sq + m3sq;

	- double max_m23 = square( M_B );
	+ double max_m23 = square( m_M_B );
	double min_m23 = m2sq + m3sq;
	double mass = 0;

	if ( !phaseSpace ) {
	- double y = EvtRandom::Flat() * pi - pi / 2;
	+ double y = EvtRandom::Flat() * m_pi - m_pi / 2;
	double x = std::tan( y );
	- mass = x * Gam_rho / 2. + Mass_rho;
	+ mass = x * m_Gam_rho / 2. + m_Mass_rho;
	}

	double z = 3. * EvtRandom::Flat();
	@@ -697,18 +700,18 @@
	*/
	static bool phaseSpace = false;

	- double max_m12 = square( M_B );
	+ double max_m12 = square( m_M_B );
	double min_m12 = m1sq + m2sq;

	- double max_m13 = square( M_B );
	+ double max_m13 = square( m_M_B );
	double min_m13 = m1sq + m3sq;

	double mass = 0;

	if ( !phaseSpace ) {
	- double y = EvtRandom::Flat() * pi - pi / 2;
	+ double y = EvtRandom::Flat() * m_pi - m_pi / 2;
	double x = std::tan( y );
	- mass = x * Gam_rho / 2. + Mass_rho;
	+ mass = x * m_Gam_rho / 2. + m_Mass_rho;
	}

	double z = EvtRandom::Flat();
	@@ -750,18 +753,18 @@
	*/
	static bool phaseSpace = false;

	- double max_m12 = square( M_B );
	+ double max_m12 = square( m_M_B );
	double min_m12 = m1sq + m2sq;

	- double max_m13 = square( M_B );
	+ double max_m13 = square( m_M_B );
	double min_m13 = m1sq + m3sq;

	double mass = 0;

	if ( !phaseSpace ) {
	- double y = EvtRandom::Flat() * pi - pi / 2;
	+ double y = EvtRandom::Flat() * m_pi - m_pi / 2;
	double x = std::tan( y );
	- mass = x * Gam_rho / 2. + Mass_rho;
	+ mass = x * m_Gam_rho / 2. + m_Mass_rho;
	}

	double z = EvtRandom::Flat();
	@@ -793,12 +796,12 @@
	double m13 = ( p1 + p3 ).mass();
	double m23 = ( p2 + p3 ).mass();

	- double W12 = 1. /
	- ( ( square( Mass_rho - m12 ) + square( Gam_rho / 2. ) ) * m12 );
	- double W13 = 1. /
	- ( ( square( Mass_rho - m13 ) + square( Gam_rho / 2. ) ) * m13 );
	- double W23 = 1. /
	- ( ( square( Mass_rho - m23 ) + square( Gam_rho / 2. ) ) * m23 );
	+ double W12 =
	+ 1. / ( ( square( m_Mass_rho - m12 ) + square( m_Gam_rho / 2. ) ) * m12 );
	+ double W13 =
	+ 1. / ( ( square( m_Mass_rho - m13 ) + square( m_Gam_rho / 2. ) ) * m13 );
	+ double W23 =
	+ 1. / ( ( square( m_Mass_rho - m23 ) + square( m_Gam_rho / 2. ) ) * m23 );

	double Wtot = 1.;
	if ( iset >= 0 ) {
	@@ -809,15 +812,15 @@
	EvtComplex Mat_rhom = BreitWigner( p2, p3, p1, ierr );
	EvtComplex Mat_rho0 = BreitWigner( p1, p3, p2, ierr );

	- EvtComplex Mat_1 = Mat_S3 * Mat_rhop;
	- EvtComplex Mat_2 = Mat_S4 * Mat_rhom;
	- EvtComplex Mat_3 = Mat_S5 * Mat_rho0 * 0.5;
	+ EvtComplex Mat_1 = m_Mat_S3 * Mat_rhop;
	+ EvtComplex Mat_2 = m_Mat_S4 * Mat_rhom;
	+ EvtComplex Mat_3 = m_Mat_S5 * Mat_rho0 * 0.5;

	EvtComplex MatBp = ( Mat_1 + Mat_2 + Mat_3 ) * Wtot;

	- Mat_1 = Nat_S3 * Mat_rhom;
	- Mat_2 = Nat_S4 * Mat_rhop;
	- Mat_3 = Nat_S5 * Mat_rho0 * 0.5;
	+ Mat_1 = m_Nat_S3 * Mat_rhom;
	+ Mat_2 = m_Nat_S4 * Mat_rhop;
	+ Mat_3 = m_Nat_S5 * Mat_rho0 * 0.5;

	EvtComplex MatBm = ( Mat_1 + Mat_2 + Mat_3 ) * Wtot;

	@@ -839,10 +842,10 @@
	double m12 = ( p1 + p2 ).mass();
	double m13 = ( p1 + p3 ).mass();

	- double W12 = 1. /
	- ( ( square( Mass_rho - m12 ) + square( Gam_rho / 2. ) ) * m12 );
	- double W13 = 1. /
	- ( ( square( Mass_rho - m13 ) + square( Gam_rho / 2. ) ) * m13 );
	+ double W12 =
	+ 1. / ( ( square( m_Mass_rho - m12 ) + square( m_Gam_rho / 2. ) ) * m12 );
	+ double W13 =
	+ 1. / ( ( square( m_Mass_rho - m13 ) + square( m_Gam_rho / 2. ) ) * m13 );

	double Wtot = 1.;
	if ( iset >= 0 ) {
	@@ -852,8 +855,8 @@
	EvtComplex Mat_rhop = BreitWigner( p1, p2, p3, ierr ) +
	BreitWigner( p1, p3, p2, ierr );

	- EvtComplex MatBp = Mat_S2 * Mat_rhop * Wtot * ASHQ;
	- EvtComplex MatBm = Nat_S2 * Mat_rhop * Wtot * ASHQ;
	+ EvtComplex MatBp = m_Mat_S2 * Mat_rhop * Wtot * ASHQ;
	+ EvtComplex MatBm = m_Nat_S2 * Mat_rhop * Wtot * ASHQ;

	real_B0 = real( MatBp );
	imag_B0 = imag( MatBp );
	@@ -873,10 +876,10 @@
	double m12 = ( p1 + p2 ).mass();
	double m13 = ( p1 + p3 ).mass();

	- double W12 = 1. /
	- ( ( square( Mass_rho - m12 ) + square( Gam_rho / 2. ) ) * m12 );
	- double W13 = 1. /
	- ( ( square( Mass_rho - m13 ) + square( Gam_rho / 2. ) ) * m13 );
	+ double W12 =
	+ 1. / ( ( square( m_Mass_rho - m12 ) + square( m_Gam_rho / 2. ) ) * m12 );
	+ double W13 =
	+ 1. / ( ( square( m_Mass_rho - m13 ) + square( m_Gam_rho / 2. ) ) * m13 );

	double Wtot = 1.;
	if ( iset >= 0 ) {
	@@ -886,8 +889,8 @@
	EvtComplex Mat_rhop = BreitWigner( p1, p2, p3, ierr ) +
	BreitWigner( p1, p3, p2, ierr );

	- EvtComplex MatBp = Mat_S1 * Mat_rhop * Wtot * ASHQ;
	- EvtComplex MatBm = Nat_S1 * Mat_rhop * Wtot * ASHQ;
	+ EvtComplex MatBp = m_Mat_S1 * Mat_rhop * Wtot * ASHQ;
	+ EvtComplex MatBm = m_Nat_S1 * Mat_rhop * Wtot * ASHQ;

	real_B0 = real( MatBp );
	imag_B0 = imag( MatBp );
	@@ -908,24 +911,24 @@
	double m13 = ( p1 + p3 ).mass();
	double m23 = ( p2 + p3 ).mass();

	- double W12 = 1. /
	- ( ( square( Mass_Kstar0 - m12 ) + square( Gam_Kstar0 / 2. ) ) *
	- m12 );
	- double W13 = 1. /
	- ( ( square( Mass_Kstarp - m13 ) + square( Gam_Kstarp / 2. ) ) *
	- m13 );
	- double W23 = 1. /
	- ( ( square( Mass_rho - m23 ) + square( Gam_rho / 2. ) ) * m23 );
	+ double W12 =
	+ 1. / ( ( square( m_Mass_Kstar0 - m12 ) + square( m_Gam_Kstar0 / 2. ) ) *
	+ m12 );
	+ double W13 =
	+ 1. / ( ( square( m_Mass_Kstarp - m13 ) + square( m_Gam_Kstarp / 2. ) ) *
	+ m13 );
	+ double W23 =
	+ 1. / ( ( square( m_Mass_rho - m23 ) + square( m_Gam_rho / 2. ) ) * m23 );

	double Wtot = 1.;
	if ( iset >= 0 ) {
	Wtot = 1. / sqrt( W12 + W13 + W23 );
	}

	- EvtComplex BW13 = BreitWigner( p1, p3, p2, ierr, Mass_Kstarp, Gam_Kstarp );
	+ EvtComplex BW13 = BreitWigner( p1, p3, p2, ierr, m_Mass_Kstarp, m_Gam_Kstarp );
	if ( ierr != 0 )
	return ierr;
	- EvtComplex BW12 = BreitWigner( p1, p2, p3, ierr, Mass_Kstar0, Gam_Kstar0 );
	+ EvtComplex BW12 = BreitWigner( p1, p2, p3, ierr, m_Mass_Kstar0, m_Gam_Kstar0 );
	if ( ierr != 0 )
	return ierr;
	/*
	@@ -937,8 +940,9 @@
	return ierr;

	// Build up amplitudes
	- EvtComplex MatB0 = MatKstarp * BW13 + MatKstar0 * BW12 + MatKrho * BW23;
	- EvtComplex MatB0bar = NatKstarp * BW13 + NatKstar0 * BW12 + NatKrho * BW23;
	+ EvtComplex MatB0 = m_MatKstarp * BW13 + m_MatKstar0 * BW12 + m_MatKrho * BW23;
	+ EvtComplex MatB0bar = m_NatKstarp * BW13 + m_NatKstar0 * BW12 +
	+ m_NatKrho * BW23;

	real_B0 = real( MatB0 ) * Wtot;
	imag_B0 = imag( MatB0 ) * Wtot;
	@@ -951,8 +955,8 @@
	void EvtBTo3hCP::rotation( EvtVector4R& p, int newRot )
	{
	if ( newRot ) {
	- double phi2 = EvtRandom::Flat() * 2. * pi;
	- double phi3 = EvtRandom::Flat() * 2. * pi;
	+ double phi2 = EvtRandom::Flat() * 2. * m_pi;
	+ double phi3 = EvtRandom::Flat() * 2. * m_pi;

	double c1 = 2. * EvtRandom::Flat() - 1.;
	double c2 = cos( phi2 );
	@@ -962,15 +966,15 @@
	double s2 = sin( phi2 );
	double s3 = sin( phi3 );

	- rotMatrix[0][0] = c1;
	- rotMatrix[0][1] = s1 * c3;
	- rotMatrix[0][2] = s1 * s3;
	- rotMatrix[1][0] = -s1 * c2;
	- rotMatrix[1][1] = c1 * c2 * c3 - s2 * s3;
	- rotMatrix[1][2] = c1 * c2 * s3 + s2 * c3;
	- rotMatrix[2][0] = s1 * s2;
	- rotMatrix[2][1] = -c1 * s2 * c3 - c2 * s3;
	- rotMatrix[2][2] = -c1 * s2 * s3 + c2 * c3;
	+ m_rotMatrix[0][0] = c1;
	+ m_rotMatrix[0][1] = s1 * c3;
	+ m_rotMatrix[0][2] = s1 * s3;
	+ m_rotMatrix[1][0] = -s1 * c2;
	+ m_rotMatrix[1][1] = c1 * c2 * c3 - s2 * s3;
	+ m_rotMatrix[1][2] = c1 * c2 * s3 + s2 * c3;
	+ m_rotMatrix[2][0] = s1 * s2;
	+ m_rotMatrix[2][1] = -c1 * s2 * c3 - c2 * s3;
	+ m_rotMatrix[2][2] = -c1 * s2 * s3 + c2 * c3;
	}

	double mom[3];
	@@ -980,7 +984,7 @@
	}
	for ( int i = 0; i < 3; ++i ) {
	for ( int j = 0; j < 3; ++j ) {
	- p.set( i + 1, p.get( i + 1 ) + rotMatrix[i][j] * mom[j] );
	+ p.set( i + 1, p.get( i + 1 ) + m_rotMatrix[i][j] * mom[j] );
	}
	}
	}
	@@ -992,7 +996,7 @@

	double cosThetaRot = EvtRandom::Flat() * 2. - 1.;
	double sinThetaRot = sqrt( 1. - square( cosThetaRot ) );
	- double PhiRot = EvtRandom::Flat() * 2. * pi;
	+ double PhiRot = EvtRandom::Flat() * 2. * m_pi;

	pgamma1.set( 1, EGammaCmsPi0 * sinThetaRot * cos( PhiRot ) );
	pgamma1.set( 2, EGammaCmsPi0 * sinThetaRot * sin( PhiRot ) );
	@@ -1051,11 +1055,11 @@
	double m12_2 = square( m12 );
	result = coscms * EvtCRhoF_W( m12_2 );
	} else {
	- double factor = 2 * ( square( Mass_rho - m12 ) +
	- square( 0.5 * Gam_rho ) );
	- factor = coscms * Gam_rho / factor;
	- double numReal = ( Mass_rho - m12 ) * factor;
	- double numImg = 0.5 * Gam_rho * factor;
	+ double factor = 2 * ( square( m_Mass_rho - m12 ) +
	+ square( 0.5 * m_Gam_rho ) );
	+ factor = coscms * m_Gam_rho / factor;
	+ double numReal = ( m_Mass_rho - m12 ) * factor;
	+ double numImg = 0.5 * m_Gam_rho * factor;
	result = EvtComplex( numReal, numImg );
	}
	} else {
	@@ -1177,15 +1181,14 @@

	double EvtBTo3hCP::d( double AmRho2 )
	{
	- const double lpi = 3.141593;
	const double AmPi = 0.13956995;
	const double AmPi2 = square( AmPi );
	double AmRho = sqrt( AmRho2 );
	double k_AmRho2 = k( AmRho2 );
	- double result = 3. / lpi * AmPi2 / square( k_AmRho2 ) *
	+ double result = 3. / m_pi * AmPi2 / square( k_AmRho2 ) *
	log( ( AmRho + 2. * k_AmRho2 ) / ( 2. * AmPi ) ) +
	- AmRho / ( 2. * pi * k_AmRho2 ) -
	- AmPi2 * AmRho / ( pi * ( square( k_AmRho2 ) * k_AmRho2 ) );
	+ AmRho / ( 2. * m_pi * k_AmRho2 ) -
	+ AmPi2 * AmRho / ( m_pi * ( square( k_AmRho2 ) * k_AmRho2 ) );
	return result;
	}

	@@ -1207,17 +1210,15 @@

	double EvtBTo3hCP::h( double s )
	{
	- const double pi = 3.141593;
	const double AmPi = 0.13956995;
	double sqrts = sqrt( s );
	double k_s = k( s );
	- return 2. / pi * ( k_s / sqrts ) *
	+ return 2. / m_pi * ( k_s / sqrts ) *
	log( ( sqrts + 2. * k_s ) / ( 2. * AmPi ) );
	}

	double EvtBTo3hCP::dh_ds( double s )
	{
	- const double pi = 3.141593;
	return h( s ) * ( 1. / ( 8. * square( k( s ) ) ) - 1. / ( 2 * s ) ) +
	- 1. / ( 2. * pi * s );
	+ 1. / ( 2. * m_pi * s );
	}
	diff --git a/src/EvtGenModels/EvtBTo3piCP.cpp b/src/EvtGenModels/EvtBTo3piCP.cpp
	--- a/src/EvtGenModels/EvtBTo3piCP.cpp
	+++ b/src/EvtGenModels/EvtBTo3piCP.cpp
	@@ -67,8 +67,8 @@

	double realA, imgA, realbarA, imgbarA;

	- generator.Evt3pi( alpha, iset, p4piplus, p4piminus, p4gamm1, p4gamm2, realA,
	- imgA, realbarA, imgbarA );
	+ m_generator.Evt3pi( alpha, iset, p4piplus, p4piminus, p4gamm1, p4gamm2,
	+ realA, imgA, realbarA, imgbarA );

	setProbMax( 1.5 );
	}
	@@ -105,8 +105,8 @@

	double realA, imgA, realbarA, imgbarA;

	- generator.Evt3pi( alpha, iset, p4[0], p4[1], p4gamm1, p4gamm2, realA, imgA,
	- realbarA, imgbarA );
	+ m_generator.Evt3pi( alpha, iset, p4[0], p4[1], p4gamm1, p4gamm2, realA,
	+ imgA, realbarA, imgbarA );

	p4[2] = p4gamm1 + p4gamm2;

	diff --git a/src/EvtGenModels/EvtBToDDalitzCPK.cpp b/src/EvtGenModels/EvtBToDDalitzCPK.cpp
	--- a/src/EvtGenModels/EvtBToDDalitzCPK.cpp
	+++ b/src/EvtGenModels/EvtBToDDalitzCPK.cpp
	@@ -71,7 +71,7 @@
	static EvtId D0 = EvtPDL::getId( "D0" );
	static EvtId D0B = EvtPDL::getId( "anti-D0" );

	- _flag = 0;
	+ m_flag = 0;

	EvtId parent = getParentId();
	EvtId d1 = getDaug( 0 );
	@@ -79,21 +79,21 @@

	if ( ( ( parent == BP ) \|\| ( parent == BM ) ) &&
	( ( d1 == D0 ) \|\| ( d1 == D0B ) ) && ( ( d2 == KP ) \|\| ( d2 == KM ) ) ) {
	- _flag = 1;
	+ m_flag = 1;
	// PHSP Decay
	} else if ( ( ( parent == BP ) \|\| ( parent == BM ) ) &&
	( ( d1 == KP ) \|\| ( d1 == KM ) ) &&
	( ( d2 == D0 ) \|\| ( d2 == D0B ) ) ) {
	- _flag = 1;
	+ m_flag = 1;
	// also PHSP decay
	} else if ( ( ( parent == B0 ) \|\| ( parent == B0B ) ) &&
	( ( d1 == KS ) \|\| ( d1 == KSB ) ) &&
	( ( d2 == D0 ) \|\| ( d2 == D0B ) ) ) {
	- _flag = 2;
	+ m_flag = 2;
	// SVS Decay
	}

	- if ( _flag == 0 ) {
	+ if ( m_flag == 0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "EvtBToDDalitzCPK : Invalid mode." << std::endl;
	assert( 0 );
	@@ -104,10 +104,10 @@
	//=============================================================================
	void EvtBToDDalitzCPK::initProbMax()
	{
	- if ( _flag == 1 ) {
	+ if ( m_flag == 1 ) {
	// PHSP
	setProbMax( 0. );
	- } else if ( _flag == 2 ) {
	+ } else if ( m_flag == 2 ) {
	// SVS
	setProbMax( 1.0 );
	}
	@@ -117,11 +117,11 @@
	//=============================================================================
	void EvtBToDDalitzCPK::decay( EvtParticle* p )
	{
	- if ( _flag == 1 ) {
	+ if ( m_flag == 1 ) {
	// PHSP
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	vertex( 0. );
	- } else if ( _flag == 2 ) {
	+ } else if ( m_flag == 2 ) {
	// SVS
	p->initializePhaseSpace( getNDaug(), getDaugs() );

	@@ -130,10 +130,10 @@
	double massv = v->mass();
	EvtVector4R momv = v->getP4();
	EvtVector4R moms = p->getDaug( 1 )->getP4();
	- double m_parent = p->mass();
	+ double parentMass = p->mass();
	EvtVector4R p4_parent = momv + moms;

	- double norm = massv / ( momv.d3mag() * m_parent );
	+ double norm = massv / ( momv.d3mag() * parentMass );
	p4_parent = norm * p4_parent;
	vertex( 0, p4_parent * ( v->epsParent( 0 ) ) );
	vertex( 1, p4_parent * ( v->epsParent( 1 ) ) );
	diff --git a/src/EvtGenModels/EvtBToDiBaryonlnupQCD.cpp b/src/EvtGenModels/EvtBToDiBaryonlnupQCD.cpp
	--- a/src/EvtGenModels/EvtBToDiBaryonlnupQCD.cpp
	+++ b/src/EvtGenModels/EvtBToDiBaryonlnupQCD.cpp
	@@ -44,7 +44,7 @@
	{
	p->initializePhaseSpace( getNDaug(), getDaugs(), true );

	- calcAmp_->CalcAmp( p, _amp2 );
	+ m_calcAmp->CalcAmp( p, m_amp2 );
	}

	void EvtBToDiBaryonlnupQCD::init()
	@@ -109,7 +109,7 @@
	}

	// Form factor model
	- ffModel_ = std::make_unique<EvtBToDiBaryonlnupQCDFF>( DPars );
	+ m_ffModel = std::make_unique<EvtBToDiBaryonlnupQCDFF>( DPars );

	// Set amplitude calculation pointer.
	// Accomodate for spin 1/2 (DIRAC) or 3/2 (RARITASCHWINGER) baryons
	@@ -122,7 +122,7 @@
	baryon2Type == EvtSpinType::DIRAC ) \|\|
	( baryon1Type == EvtSpinType::DIRAC &&
	baryon2Type == EvtSpinType::DIRAC ) ) {
	- calcAmp_ = std::make_unique<EvtSLDiBaryonAmp>( *ffModel_ );
	+ m_calcAmp = std::make_unique<EvtSLDiBaryonAmp>( *m_ffModel );

	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	diff --git a/src/EvtGenModels/EvtBToDiBaryonlnupQCDFF.cpp b/src/EvtGenModels/EvtBToDiBaryonlnupQCDFF.cpp
	--- a/src/EvtGenModels/EvtBToDiBaryonlnupQCDFF.cpp
	+++ b/src/EvtGenModels/EvtBToDiBaryonlnupQCDFF.cpp
	@@ -23,40 +23,40 @@
	#include "EvtGenBase/EvtParticle.hh"
	#include "EvtGenBase/EvtPatches.hh"

	-EvtBToDiBaryonlnupQCDFF::EvtBToDiBaryonlnupQCDFF() : DPars(), nDPars( 0 )
	+EvtBToDiBaryonlnupQCDFF::EvtBToDiBaryonlnupQCDFF() : m_DPars(), m_nDPars( 0 )
	{
	}

	EvtBToDiBaryonlnupQCDFF::EvtBToDiBaryonlnupQCDFF( std::vector<double>& DParameters ) :
	- DPars( DParameters ), nDPars( DParameters.size() )
	+ m_DPars( DParameters ), m_nDPars( DParameters.size() )
	{
	}

	void EvtBToDiBaryonlnupQCDFF::getFF( EvtParticle*, double dibaryonMass,
	EvtBToDiBaryonlnupQCDFF::FormFactors& FF ) const
	{
	- if ( nDPars == 6 && dibaryonMass > 0.0 ) {
	+ if ( m_nDPars == 6 && dibaryonMass > 0.0 ) {
	// 5/3*[1/M^2]^3
	double t = 5.0 / ( 3.0 * pow( dibaryonMass, 6.0 ) );

	- double Dp = DPars[0];
	- double Dpb = DPars[1];
	- double D2 = DPars[2];
	- double D3 = DPars[3];
	- double D4 = DPars[4];
	- double D5 = DPars[5];
	+ double Dp = m_DPars[0];
	+ double Dpb = m_DPars[1];
	+ double D2 = m_DPars[2];
	+ double D3 = m_DPars[3];
	+ double D4 = m_DPars[4];
	+ double D5 = m_DPars[5];

	- FF.F1 = ( Dp + 0.2 * Dpb ) * t;
	- FF.F2 = -D2 * t;
	- FF.F3 = -D3 * t;
	- FF.F4 = -D4 * t;
	- FF.F5 = -D5 * t;
	+ FF.m_F1 = ( Dp + 0.2 * Dpb ) * t;
	+ FF.m_F2 = -D2 * t;
	+ FF.m_F3 = -D3 * t;
	+ FF.m_F4 = -D4 * t;
	+ FF.m_F5 = -D5 * t;

	- FF.G1 = ( Dp - 0.2 * Dpb ) * t;
	- FF.G2 = -FF.F2;
	- FF.G3 = -FF.F3;
	- FF.G4 = -FF.F4;
	- FF.G5 = -FF.F5;
	+ FF.m_G1 = ( Dp - 0.2 * Dpb ) * t;
	+ FF.m_G2 = -FF.m_F2;
	+ FF.m_G3 = -FF.m_F3;
	+ FF.m_G4 = -FF.m_F4;
	+ FF.m_G5 = -FF.m_F5;
	}
	}

	diff --git a/src/EvtGenModels/EvtBToKpipiCP.cpp b/src/EvtGenModels/EvtBToKpipiCP.cpp
	--- a/src/EvtGenModels/EvtBToKpipiCP.cpp
	+++ b/src/EvtGenModels/EvtBToKpipiCP.cpp
	@@ -63,8 +63,8 @@

	double realA, imgA, realbarA, imgbarA;

	- generator.EvtKpipi( alpha, beta, iset, p4Kplus, p4piminus, p4gamm1, p4gamm2,
	- realA, imgA, realbarA, imgbarA );
	+ m_generator.EvtKpipi( alpha, beta, iset, p4Kplus, p4piminus, p4gamm1,
	+ p4gamm2, realA, imgA, realbarA, imgbarA );
	}

	void EvtBToKpipiCP::initProbMax()
	@@ -103,8 +103,8 @@

	double realA, imgA, realbarA, imgbarA;

	- generator.EvtKpipi( alpha, beta, iset, p4[0], p4[1], p4gamm1, p4gamm2,
	- realA, imgA, realbarA, imgbarA );
	+ m_generator.EvtKpipi( alpha, beta, iset, p4[0], p4[1], p4gamm1, p4gamm2,
	+ realA, imgA, realbarA, imgbarA );

	p4[2] = p4gamm1 + p4gamm2;

	diff --git a/src/EvtGenModels/EvtBToPlnuBK.cpp b/src/EvtGenModels/EvtBToPlnuBK.cpp
	--- a/src/EvtGenModels/EvtBToPlnuBK.cpp
	+++ b/src/EvtGenModels/EvtBToPlnuBK.cpp
	@@ -55,8 +55,8 @@
	lnum = getDaug( 1 );
	nunum = getDaug( 2 );

	- double mymaxprob = calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	- BKmodel.get() );
	+ double mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	+ m_BKmodel.get() );

	setProbMax( mymaxprob );
	}
	@@ -75,8 +75,8 @@
	EvtSpinType::spintype d1type = EvtPDL::getSpinType( getDaug( 0 ) );
	if ( d1type == EvtSpinType::SCALAR ) {
	checkNArg( 2 );
	- BKmodel = std::make_unique<EvtBToPlnuBKFF>( getArg( 0 ), getArg( 1 ) );
	- calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	+ m_BKmodel = std::make_unique<EvtBToPlnuBKFF>( getArg( 0 ), getArg( 1 ) );
	+ m_calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "BK model handles only scalar meson daughters. Sorry." << endl;
	@@ -87,5 +87,5 @@
	void EvtBToPlnuBK::decay( EvtParticle* p )
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- calcamp->CalcAmp( p, _amp2, BKmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_BKmodel.get() );
	}
	diff --git a/src/EvtGenModels/EvtBToPlnuBKFF.cpp b/src/EvtGenModels/EvtBToPlnuBKFF.cpp
	--- a/src/EvtGenModels/EvtBToPlnuBKFF.cpp
	+++ b/src/EvtGenModels/EvtBToPlnuBKFF.cpp
	@@ -31,8 +31,8 @@

	EvtBToPlnuBKFF::EvtBToPlnuBKFF( double alpha, double beta )
	{
	- _alpha = alpha;
	- _beta = beta;
	+ m_alpha = alpha;
	+ m_beta = beta;

	return;
	}
	@@ -50,8 +50,8 @@

	//Compute BK parametrization (t==q2)
	double fplus = 1.0 /
	- ( ( 1.0 - t / mBstar2 ) * ( 1.0 - _alpha * t / mBstar2 ) );
	- double fzero = 1.0 / ( 1.0 - t / ( mBstar2 * _beta ) );
	+ ( ( 1.0 - t / mBstar2 ) * ( 1.0 - m_alpha * t / mBstar2 ) );
	+ double fzero = 1.0 / ( 1.0 - t / ( mBstar2 * m_beta ) );

	*fp = fplus;
	*f0 = fzero;
	diff --git a/src/EvtGenModels/EvtBToVlnuBall.cpp b/src/EvtGenModels/EvtBToVlnuBall.cpp
	--- a/src/EvtGenModels/EvtBToVlnuBall.cpp
	+++ b/src/EvtGenModels/EvtBToVlnuBall.cpp
	@@ -48,7 +48,7 @@
	void EvtBToVlnuBall::decay( EvtParticle* p )
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- _calcamp->CalcAmp( p, _amp2, _Ballmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_Ballmodel.get() );
	}

	void EvtBToVlnuBall::initProbMax()
	@@ -60,8 +60,8 @@
	lnum = getDaug( 1 );
	nunum = getDaug( 2 );

	- double mymaxprob = _calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	- _Ballmodel.get() );
	+ double mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	+ m_Ballmodel.get() );

	setProbMax( mymaxprob );
	}
	@@ -80,10 +80,10 @@
	EvtSpinType::spintype d1type = EvtPDL::getSpinType( getDaug( 0 ) );
	if ( d1type == EvtSpinType::VECTOR ) {
	checkNArg( 8 ); // the number of arguments needed for the Ball model
	- _Ballmodel = std::make_unique<EvtBToVlnuBallFF>(
	+ m_Ballmodel = std::make_unique<EvtBToVlnuBallFF>(
	getArg( 0 ), getArg( 1 ), getArg( 2 ), getArg( 3 ), getArg( 4 ),
	getArg( 5 ), getArg( 6 ), getArg( 7 ) );
	- _calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Ball model handles only vector meson daughters. Sorry." << endl;
	diff --git a/src/EvtGenModels/EvtBToVlnuBallFF.cpp b/src/EvtGenModels/EvtBToVlnuBallFF.cpp
	--- a/src/EvtGenModels/EvtBToVlnuBallFF.cpp
	+++ b/src/EvtGenModels/EvtBToVlnuBallFF.cpp
	@@ -33,14 +33,14 @@
	double r2_A2, double mfit2_A2, double r1_V,
	double r2_V, double mfit2_V )
	{
	- _r2_A1 = r2_A1;
	- _mfit2_A1 = mfit2_A1;
	- _r1_A2 = r1_A2;
	- _r2_A2 = r2_A2;
	- _mfit2_A2 = mfit2_A2;
	- _r1_V = r1_V;
	- _r2_V = r2_V;
	- _mfit2_V = mfit2_V;
	+ m_r2_A1 = r2_A1;
	+ m_mfit2_A1 = mfit2_A1;
	+ m_r1_A2 = r1_A2;
	+ m_r2_A2 = r2_A2;
	+ m_mfit2_A2 = mfit2_A2;
	+ m_r1_V = r1_V;
	+ m_r2_V = r2_V;
	+ m_mfit2_V = mfit2_V;

	return;
	}
	@@ -60,10 +60,11 @@
	mBstar = EvtPDL::getMeanMass( EvtPDL::getId( "B*+" ) );

	double q2 = t;
	- *a1f = _r2_A1 / ( 1. - q2 / _mfit2_A1 );
	- *a2f = _r1_A2 / ( 1. - q2 / _mfit2_A2 ) +
	- _r2_A2 / pow( 1. - q2 / _mfit2_A2, 2. );
	- *vf = _r1_V / ( 1. - q2 / mBstar / mBstar ) + _r2_V / ( 1. - q2 / _mfit2_V );
	+ *a1f = m_r2_A1 / ( 1. - q2 / m_mfit2_A1 );
	+ *a2f = m_r1_A2 / ( 1. - q2 / m_mfit2_A2 ) +
	+ m_r2_A2 / pow( 1. - q2 / m_mfit2_A2, 2. );
	+ *vf = m_r1_V / ( 1. - q2 / mBstar / mBstar ) +
	+ m_r2_V / ( 1. - q2 / m_mfit2_V );
	*a0f = 0.0;

	return;
	diff --git a/src/EvtGenModels/EvtBToXElNu.cpp b/src/EvtGenModels/EvtBToXElNu.cpp
	--- a/src/EvtGenModels/EvtBToXElNu.cpp
	+++ b/src/EvtGenModels/EvtBToXElNu.cpp
	@@ -48,7 +48,7 @@
	void EvtBToXElNu::decay( EvtParticle* p )
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- m_calcamp->CalcAmp( p, _amp2, m_ffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_ffmodel.get() );
	}

	void EvtBToXElNu::initProbMax()
	diff --git a/src/EvtGenModels/EvtBaryonPCR.cpp b/src/EvtGenModels/EvtBaryonPCR.cpp
	--- a/src/EvtGenModels/EvtBaryonPCR.cpp
	+++ b/src/EvtGenModels/EvtBaryonPCR.cpp
	@@ -66,7 +66,7 @@
	EvtComplex r10( getArg( 2 ), 0.0 );
	EvtComplex r11( getArg( 3 ), 0.0 );

	- calcamp->CalcAmp( p, _amp2, baryonpcrffmodel.get(), r00, r01, r10, r11 );
	+ m_calcamp->CalcAmp( p, m_amp2, m_baryonpcrffmodel.get(), r00, r01, r10, r11 );
	}

	void EvtBaryonPCR::initProbMax()
	@@ -166,11 +166,11 @@
	::abort();
	}

	- baryonpcrffmodel = std::make_unique<EvtBaryonPCRFF>();
	+ m_baryonpcrffmodel = std::make_unique<EvtBaryonPCRFF>();

	if ( baryontype == EvtSpinType::DIRAC \|\|
	baryontype == EvtSpinType::RARITASCHWINGER ) {
	- calcamp = std::make_unique<EvtSemiLeptonicBaryonAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicBaryonAmp>();
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Wrong baryon spin type in EvtBaryonPCR.cc "
	diff --git a/src/EvtGenModels/EvtBcBsNPi.cpp b/src/EvtGenModels/EvtBcBsNPi.cpp
	--- a/src/EvtGenModels/EvtBcBsNPi.cpp
	+++ b/src/EvtGenModels/EvtBcBsNPi.cpp
	@@ -25,20 +25,20 @@

	EvtBcBsNPi::EvtBcBsNPi()
	{
	- _beta = -0.108;
	- _mRho = 0.775;
	- _gammaRho = 0.149;
	- _mRhopr = 1.364;
	- _gammaRhopr = 0.400;
	- _mA1 = 1.23;
	- _gammaA1 = 0.4;
	+ m_beta = -0.108;
	+ m_mRho = 0.775;
	+ m_gammaRho = 0.149;
	+ m_mRhopr = 1.364;
	+ m_gammaRhopr = 0.400;
	+ m_mA1 = 1.23;
	+ m_gammaA1 = 0.4;
	// Fp_N=1.3; Fp_c1=0.30; Fp_c2=0.069;
	- Fp_N = 3 * 1.3;
	- Fp_c1 = 0.30;
	- Fp_c2 = 0.069;
	- Fm_N = 0.0;
	- Fm_c1 = 0.0;
	- Fm_c2 = 0.0;
	+ m_Fp_N = 3 * 1.3;
	+ m_Fp_c1 = 0.30;
	+ m_Fp_c2 = 0.069;
	+ m_Fm_N = 0.0;
	+ m_Fm_c1 = 0.0;
	+ m_Fm_c2 = 0.0;
	}

	std::string EvtBcBsNPi::getName()
	diff --git a/src/EvtGenModels/EvtBcBsStarNPi.cpp b/src/EvtGenModels/EvtBcBsStarNPi.cpp
	--- a/src/EvtGenModels/EvtBcBsStarNPi.cpp
	+++ b/src/EvtGenModels/EvtBcBsStarNPi.cpp
	@@ -25,26 +25,26 @@

	EvtBcBsStarNPi::EvtBcBsStarNPi()
	{
	- _beta = -0.108;
	- _mRho = 0.775;
	- _gammaRho = 0.149;
	- _mRhopr = 1.364;
	- _gammaRhopr = 0.400;
	- _mA1 = 1.23;
	- _gammaA1 = 0.4;
	+ m_beta = -0.108;
	+ m_mRho = 0.775;
	+ m_gammaRho = 0.149;
	+ m_mRhopr = 1.364;
	+ m_gammaRhopr = 0.400;
	+ m_mA1 = 1.23;
	+ m_gammaA1 = 0.4;

	- FA0_N = 8.1;
	- FA0_c1 = 0.30;
	- FA0_c2 = 0.069;
	- FAm_N = 0.0;
	- FAm_c1 = 0.0;
	- FAm_c2 = 0.0;
	- FAp_N = 0.15;
	- FAp_c1 = 0.30;
	- FAp_c2 = 0.069;
	- FV_N = 1.08;
	- FV_c1 = 0.30;
	- FV_c2 = 0.069;
	+ m_FA0_N = 8.1;
	+ m_FA0_c1 = 0.30;
	+ m_FA0_c2 = 0.069;
	+ m_FAm_N = 0.0;
	+ m_FAm_c1 = 0.0;
	+ m_FAm_c2 = 0.0;
	+ m_FAp_N = 0.15;
	+ m_FAp_c1 = 0.30;
	+ m_FAp_c2 = 0.069;
	+ m_FV_N = 1.08;
	+ m_FV_c1 = 0.30;
	+ m_FV_c2 = 0.069;
	}

	std::string EvtBcBsStarNPi::getName()
	diff --git a/src/EvtGenModels/EvtBcPsiNPi.cpp b/src/EvtGenModels/EvtBcPsiNPi.cpp
	--- a/src/EvtGenModels/EvtBcPsiNPi.cpp
	+++ b/src/EvtGenModels/EvtBcPsiNPi.cpp
	@@ -25,26 +25,26 @@

	EvtBcPsiNPi::EvtBcPsiNPi()
	{
	- _beta = -0.108;
	- _mRho = 0.775;
	- _gammaRho = 0.149;
	- _mRhopr = 1.364;
	- _gammaRhopr = 0.400;
	- _mA1 = 1.23;
	- _gammaA1 = 0.4;
	+ m_beta = -0.108;
	+ m_mRho = 0.775;
	+ m_gammaRho = 0.149;
	+ m_mRhopr = 1.364;
	+ m_gammaRhopr = 0.400;
	+ m_mA1 = 1.23;
	+ m_gammaA1 = 0.4;

	- FA0_N = 5.9;
	- FA0_c1 = 0.049;
	- FA0_c2 = 0.0015;
	- FAm_N = 0.0;
	- FAm_c1 = 0.0;
	- FAm_c2 = 0.0;
	- FAp_N = -0.074;
	- FAp_c1 = 0.049;
	- FAp_c2 = 0.0015;
	- FV_N = 0.11;
	- FV_c1 = 0.049;
	- FV_c2 = 0.0015;
	+ m_FA0_N = 5.9;
	+ m_FA0_c1 = 0.049;
	+ m_FA0_c2 = 0.0015;
	+ m_FAm_N = 0.0;
	+ m_FAm_c1 = 0.0;
	+ m_FAm_c2 = 0.0;
	+ m_FAp_N = -0.074;
	+ m_FAp_c1 = 0.049;
	+ m_FAp_c2 = 0.0015;
	+ m_FV_N = 0.11;
	+ m_FV_c1 = 0.049;
	+ m_FV_c2 = 0.0015;
	}

	std::string EvtBcPsiNPi::getName()
	diff --git a/src/EvtGenModels/EvtBcSMuNu.cpp b/src/EvtGenModels/EvtBcSMuNu.cpp
	--- a/src/EvtGenModels/EvtBcSMuNu.cpp
	+++ b/src/EvtGenModels/EvtBcSMuNu.cpp
	@@ -48,7 +48,7 @@
	void EvtBcSMuNu::decay( EvtParticle* p )
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- calcamp->CalcAmp( p, _amp2, ffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_ffmodel.get() );
	}

	void EvtBcSMuNu::init()
	@@ -65,12 +65,12 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::NEUTRINO );

	- idScalar = getDaug( 0 ).getId();
	- whichfit = int( getArg( 0 ) + 0.1 );
	+ m_idScalar = getDaug( 0 ).getId();
	+ m_whichfit = int( getArg( 0 ) + 0.1 );

	- ffmodel = std::make_unique<EvtBCSFF>( idScalar, whichfit );
	+ m_ffmodel = std::make_unique<EvtBCSFF>( m_idScalar, m_whichfit );

	- calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	}

	void EvtBcSMuNu::initProbMax()
	@@ -81,8 +81,8 @@
	EvtId nuId = getDaug( 2 );

	int nQ2Bins = 200;
	- double maxProb = calcamp->CalcMaxProb( parId, mesonId, lepId, nuId,
	- ffmodel.get(), nQ2Bins );
	+ double maxProb = m_calcamp->CalcMaxProb( parId, mesonId, lepId, nuId,
	+ m_ffmodel.get(), nQ2Bins );

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtBcSMuNu" )
	diff --git a/src/EvtGenModels/EvtBcTMuNu.cpp b/src/EvtGenModels/EvtBcTMuNu.cpp
	--- a/src/EvtGenModels/EvtBcTMuNu.cpp
	+++ b/src/EvtGenModels/EvtBcTMuNu.cpp
	@@ -48,7 +48,7 @@
	void EvtBcTMuNu::decay( EvtParticle* p )
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- calcamp->CalcAmp( p, _amp2, ffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_ffmodel.get() );
	}

	void EvtBcTMuNu::init()
	@@ -65,12 +65,12 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::NEUTRINO );

	- idTensor = getDaug( 0 ).getId();
	- whichfit = int( getArg( 0 ) + 0.1 );
	+ m_idTensor = getDaug( 0 ).getId();
	+ m_whichfit = int( getArg( 0 ) + 0.1 );

	- ffmodel = std::make_unique<EvtBCTFF>( idTensor, whichfit );
	+ m_ffmodel = std::make_unique<EvtBCTFF>( m_idTensor, m_whichfit );

	- calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	}

	void EvtBcTMuNu::initProbMax()
	@@ -81,8 +81,8 @@
	EvtId nuId = getDaug( 2 );

	int nQ2Bins = 200;
	- double maxProb = calcamp->CalcMaxProb( parId, mesonId, lepId, nuId,
	- ffmodel.get(), nQ2Bins );
	+ double maxProb = m_calcamp->CalcMaxProb( parId, mesonId, lepId, nuId,
	+ m_ffmodel.get(), nQ2Bins );

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtBcTMuNu" )
	diff --git a/src/EvtGenModels/EvtBcToNPi.cpp b/src/EvtGenModels/EvtBcToNPi.cpp
	--- a/src/EvtGenModels/EvtBcToNPi.cpp
	+++ b/src/EvtGenModels/EvtBcToNPi.cpp
	@@ -34,8 +34,8 @@

	EvtBcToNPi::EvtBcToNPi( bool printAuthorInfo )
	{
	- nCall = 0;
	- maxAmp2 = 0;
	+ m_nCall = 0;
	+ m_maxAmp2 = 0;
	if ( printAuthorInfo == true ) {
	this->printAuthorInfo();
	}
	@@ -61,41 +61,41 @@
	checkSpinDaughter( i, EvtSpinType::SCALAR );
	};

	- _beta = -0.108;
	- _mRho = 0.775;
	- _gammaRho = 0.149;
	- _mRhopr = 1.364;
	- _gammaRhopr = 0.400;
	- _mA1 = 1.23;
	- _gammaA1 = 0.4;
	+ m_beta = -0.108;
	+ m_mRho = 0.775;
	+ m_gammaRho = 0.149;
	+ m_mRhopr = 1.364;
	+ m_gammaRhopr = 0.400;
	+ m_mA1 = 1.23;
	+ m_gammaA1 = 0.4;

	// read arguments
	if ( EvtPDL::getSpinType( getDaug( 0 ) ) == EvtSpinType::VECTOR ) {
	checkNArg( 10 );
	int n = 0;
	- _maxProb = getArg( n++ );
	- FA0_N = getArg( n++ );
	- FA0_c1 = getArg( n++ );
	- FA0_c2 = getArg( n++ );
	- FAp_N = getArg( n++ );
	- FAp_c1 = getArg( n++ );
	- FAp_c2 = getArg( n++ );
	- FV_N = getArg( n++ );
	- FV_c1 = getArg( n++ );
	- FV_c2 = getArg( n++ );
	- FAm_N = 0;
	- FAm_c1 = 0;
	- FAm_c2 = 0;
	+ m_maxProb = getArg( n++ );
	+ m_FA0_N = getArg( n++ );
	+ m_FA0_c1 = getArg( n++ );
	+ m_FA0_c2 = getArg( n++ );
	+ m_FAp_N = getArg( n++ );
	+ m_FAp_c1 = getArg( n++ );
	+ m_FAp_c2 = getArg( n++ );
	+ m_FV_N = getArg( n++ );
	+ m_FV_c1 = getArg( n++ );
	+ m_FV_c2 = getArg( n++ );
	+ m_FAm_N = 0;
	+ m_FAm_c1 = 0;
	+ m_FAm_c2 = 0;
	} else if ( EvtPDL::getSpinType( getDaug( 0 ) ) == EvtSpinType::SCALAR ) {
	checkNArg( 4 );
	int n = 0;
	- _maxProb = getArg( n++ );
	- Fp_N = getArg( n++ );
	- Fp_c1 = getArg( n++ );
	- Fp_c2 = getArg( n++ );
	- Fm_N = 0;
	- Fm_c1 = 0;
	- Fm_c2 = 0;
	+ m_maxProb = getArg( n++ );
	+ m_Fp_N = getArg( n++ );
	+ m_Fp_c1 = getArg( n++ );
	+ m_Fp_c2 = getArg( n++ );
	+ m_Fm_N = 0;
	+ m_Fm_c1 = 0;
	+ m_Fm_c2 = 0;
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Have not yet implemented this final state in BCPSINPI model"
	@@ -121,21 +121,21 @@
	}
	}

	-double EvtBcToNPi::_ee( double M, double m1, double m2 )
	+double EvtBcToNPi::energy1( double M, double m1, double m2 )
	{
	return ( M * M + m1 * m1 - m2 * m2 ) / ( 2 * M );
	}

	-double EvtBcToNPi::_pp( double M, double m1, double m2 )
	+double EvtBcToNPi::mom1( double M, double m1, double m2 )
	{
	- double __ee = _ee( M, m1, m2 );
	- return sqrt( __ee * __ee - m1 * m1 );
	+ double e1 = energy1( M, m1, m2 );
	+ return sqrt( e1 * e1 - m1 * m1 );
	}

	void EvtBcToNPi::initProbMax()
	{
	- if ( _maxProb > 0. )
	- setProbMax( _maxProb );
	+ if ( m_maxProb > 0. )
	+ setProbMax( m_maxProb );
	else {
	EvtId id = getParentId();
	EvtScalarParticle* p = new EvtScalarParticle();
	@@ -149,26 +149,26 @@
	double M = EvtPDL::getMass( id ),
	m1 = EvtPDL::getMass( getDaug( 0 ) ),
	m2 = EvtPDL::getMass( getDaug( 1 ) );
	- double __pp = _pp( M, m1, m2 );
	+ double p1 = mom1( M, m1, m2 );
	p->getDaug( 0 )->setP4(
	- EvtVector4R( _ee( M, m1, m2 ), 0., 0., __pp ) );
	+ EvtVector4R( energy1( M, m1, m2 ), 0., 0., p1 ) );
	p->getDaug( 1 )->setP4(
	- EvtVector4R( _ee( M, m2, m1 ), 0., 0., -__pp ) );
	+ EvtVector4R( energy1( M, m2, m1 ), 0., 0., -p1 ) );
	} else if ( getNDaug() == 3 ) {
	double M = EvtPDL::getMass( id ),
	m1 = EvtPDL::getMass( getDaug( 0 ) ),
	m2 = EvtPDL::getMass( getDaug( 1 ) ),
	m3 = EvtPDL::getMass( getDaug( 2 ) );
	- double __ppRho = _pp( M, m1, _mRho ), __ppPi = _pp( _mRho, m2, m3 );
	+ double pRho = mom1( M, m1, m_mRho ), pPi = mom1( m_mRho, m2, m3 );
	p->getDaug( 0 )->setP4(
	- EvtVector4R( _ee( M, m1, _mRho ), 0., 0., __ppRho ) );
	- EvtVector4R _pRho( _ee( M, _mRho, m1 ), 0., 0., -__ppRho );
	- EvtVector4R _p2( _ee( _mRho, m2, m3 ), 0., 0., __ppPi );
	- _p2.applyBoostTo( _pRho );
	- EvtVector4R _p3( _ee( _mRho, m2, m3 ), 0., 0., -__ppPi );
	- _p3.applyBoostTo( _pRho );
	- p->getDaug( 1 )->setP4( _p2 );
	- p->getDaug( 2 )->setP4( _p3 );
	+ EvtVector4R( energy1( M, m1, m_mRho ), 0., 0., pRho ) );
	+ EvtVector4R p4Rho( energy1( M, m_mRho, m1 ), 0., 0., -pRho );
	+ EvtVector4R p4_2( energy1( m_mRho, m2, m3 ), 0., 0., pPi );
	+ p4_2.applyBoostTo( p4Rho );
	+ EvtVector4R p4_3( energy1( m_mRho, m2, m3 ), 0., 0., -pPi );
	+ p4_3.applyBoostTo( p4Rho );
	+ p->getDaug( 1 )->setP4( p4_2 );
	+ p->getDaug( 2 )->setP4( p4_3 );

	} else if ( getNDaug() == 4 ) {
	double M = EvtPDL::getMass( id ),
	@@ -176,31 +176,31 @@
	m2 = EvtPDL::getMass( getDaug( 1 ) ),
	m3 = EvtPDL::getMass( getDaug( 2 ) ),
	m4 = EvtPDL::getMass( getDaug( 3 ) );
	- if ( M < m1 + _mA1 )
	+ if ( M < m1 + m_mA1 )
	return;
	- double __ppA1 = _pp( M, m1, _mA1 ), __ppRho = _pp( _mA1, _mRho, m4 ),
	- __ppPi = _pp( _mRho, m2, m3 );
	+ double pA1 = mom1( M, m1, m_mA1 ), pRho = mom1( m_mA1, m_mRho, m4 ),
	+ pPi = mom1( m_mRho, m2, m3 );
	p->getDaug( 0 )->setP4(
	- EvtVector4R( _ee( M, m1, _mRho ), 0., 0., __ppA1 ) );
	- EvtVector4R _pA1( _ee( M, _mA1, m1 ), 0., 0., -__ppA1 );
	- EvtVector4R _pRho( _ee( _mA1, _mRho, m4 ), 0, 0, __ppRho );
	- _pRho.applyBoostTo( _pA1 );
	- EvtVector4R _p4( _ee( _mA1, m4, _mRho ), 0, 0, -__ppRho );
	- _p4.applyBoostTo( _pA1 );
	- p->getDaug( 3 )->setP4( _p4 );
	- EvtVector4R _p2( _ee( _mRho, m2, m3 ), 0, 0, __ppPi );
	- _p2.applyBoostTo( _pRho );
	- p->getDaug( 1 )->setP4( _p2 );
	- EvtVector4R _p3( _ee( _mRho, m2, m3 ), 0, 0, -__ppPi );
	- _p2.applyBoostTo( _pRho );
	- p->getDaug( 2 )->setP4( _p3 );
	+ EvtVector4R( energy1( M, m1, m_mRho ), 0., 0., pA1 ) );
	+ EvtVector4R p4A1( energy1( M, m_mA1, m1 ), 0., 0., -pA1 );
	+ EvtVector4R p4Rho( energy1( m_mA1, m_mRho, m4 ), 0, 0, pRho );
	+ p4Rho.applyBoostTo( p4A1 );
	+ EvtVector4R p4_4( energy1( m_mA1, m4, m_mRho ), 0, 0, -pRho );
	+ p4_4.applyBoostTo( p4A1 );
	+ p->getDaug( 3 )->setP4( p4_4 );
	+ EvtVector4R p4_2( energy1( m_mRho, m2, m3 ), 0, 0, pPi );
	+ p4_2.applyBoostTo( p4Rho );
	+ p->getDaug( 1 )->setP4( p4_2 );
	+ EvtVector4R p4_3( energy1( m_mRho, m2, m3 ), 0, 0, -pPi );
	+ p4_2.applyBoostTo( p4Rho );
	+ p->getDaug( 2 )->setP4( p4_3 );
	};

	- _amp2.init( p->getId(), getNDaug(), getDaugs() );
	+ m_amp2.init( p->getId(), getNDaug(), getDaugs() );

	decay( p );

	- EvtSpinDensity rho = _amp2.getSpinDensity();
	+ EvtSpinDensity rho = m_amp2.getSpinDensity();

	double prob = p->getSpinDensityForward().normalizedProb( rho );

	@@ -211,7 +211,7 @@

	void EvtBcToNPi::decay( EvtParticle* root_particle )
	{
	- ++nCall;
	+ ++m_nCall;

	EvtIdSet thePis{ "pi+", "pi-", "pi0" };
	EvtComplex I = EvtComplex( 0.0, 1.0 );
	@@ -263,10 +263,10 @@
	EvtVector4R p3 = root_particle->getDaug( diffPi )->getP4();

	EvtComplex BA1;
	- double GA1 = _gammaA1 * pi3G( Q2, samePi1 ) /
	- pi3G( _mA1 * _mA1, samePi1 );
	- EvtComplex denBA1( _mA1 * _mA1 - Q.mass2(), -1. * _mA1 * GA1 );
	- BA1 = _mA1 * _mA1 / denBA1;
	+ double GA1 = m_gammaA1 * pi3G( Q2, samePi1 ) /
	+ pi3G( m_mA1 * m_mA1, samePi1 );
	+ EvtComplex denBA1( m_mA1 * m_mA1 - Q.mass2(), -1. * m_mA1 * GA1 );
	+ BA1 = m_mA1 * m_mA1 / denBA1;

	hardCur = BA1 * ( ( p1 - p3 ) -
	( Q * ( Q * ( p1 - p3 ) ) / Q2 ) * Fpi( p2, p3 ) +
	@@ -288,13 +288,13 @@
	::abort();
	};

	- EvtTensor4C H;
	double amp2 = 0.;
	if ( root_particle->getDaug( 0 )->getSpinType() == EvtSpinType::VECTOR ) {
	- double FA0 = FA0_N * exp( FA0_c1 * Q2 + FA0_c2 * Q2 * Q2 );
	- double FAp = FAp_N * exp( FAp_c1 * Q2 + FAp_c2 * Q2 * Q2 );
	- double FAm = FAm_N * exp( FAm_c1 * Q2 + FAm_c2 * Q2 * Q2 );
	- double FV = FV_N * exp( FV_c1 * Q2 + FV_c2 * Q2 * Q2 );
	+ EvtTensor4C H;
	+ double FA0 = m_FA0_N * exp( m_FA0_c1 * Q2 + m_FA0_c2 * Q2 * Q2 );
	+ double FAp = m_FAp_N * exp( m_FAp_c1 * Q2 + m_FAp_c2 * Q2 * Q2 );
	+ double FAm = m_FAm_N * exp( m_FAm_c1 * Q2 + m_FAm_c2 * Q2 * Q2 );
	+ double FV = m_FV_N * exp( m_FV_c1 * Q2 + m_FV_c2 * Q2 * Q2 );
	H = -FA0 * EvtTensor4C::g() -
	FAp * EvtGenFunctions::directProd( p, p + k ) +
	FAm * EvtGenFunctions::directProd( p, p - k ) +
	@@ -311,15 +311,15 @@
	}
	} else if ( root_particle->getDaug( 0 )->getSpinType() ==
	EvtSpinType::SCALAR ) {
	- double Fp = Fp_N * exp( Fp_c1 * Q2 + Fp_c2 * Q2 * Q2 );
	- double Fm = Fm_N * exp( Fm_c1 * Q2 + Fm_c2 * Q2 * Q2 );
	+ double Fp = m_Fp_N * exp( m_Fp_c1 * Q2 + m_Fp_c2 * Q2 * Q2 );
	+ double Fm = m_Fm_N * exp( m_Fm_c1 * Q2 + m_Fm_c2 * Q2 * Q2 );
	EvtVector4C H = Fp * ( p + k ) + Fm * ( p - k );
	EvtComplex amp = H * hardCur;
	vertex( amp );
	amp2 += pow( abs( amp ), 2 );
	};
	- if ( amp2 > maxAmp2 )
	- maxAmp2 = amp2;
	+ if ( amp2 > m_maxAmp2 )
	+ m_maxAmp2 = amp2;

	return;
	}
	@@ -333,35 +333,35 @@
	double mQ2 = Q * Q;

	// momenta in the rho->pipi decay
	- double dRho = _mRho * _mRho - m1 * m1 - m2 * m2;
	- double pPiRho = ( 1.0 / _mRho ) *
	+ double dRho = m_mRho * m_mRho - m1 * m1 - m2 * m2;
	+ double pPiRho = ( 1.0 / m_mRho ) *
	sqrt( ( dRho * dRho ) / 4.0 - m1 * m1 * m2 * m2 );

	- double dRhopr = _mRhopr * _mRhopr - m1 * m1 - m2 * m2;
	- double pPiRhopr = ( 1.0 / _mRhopr ) *
	+ double dRhopr = m_mRhopr * m_mRhopr - m1 * m1 - m2 * m2;
	+ double pPiRhopr = ( 1.0 / m_mRhopr ) *
	sqrt( ( dRhopr * dRhopr ) / 4.0 - m1 * m1 * m2 * m2 );

	double dQ = mQ2 - m1 * m1 - m2 * m2;
	double pPiQ = ( 1.0 / sqrt( mQ2 ) ) *
	sqrt( ( dQ * dQ ) / 4.0 - m1 * m1 * m2 * m2 );

	- double gammaRho = _gammaRho * _mRho / sqrt( mQ2 ) *
	+ double gammaRho = m_gammaRho * m_mRho / sqrt( mQ2 ) *
	pow( ( pPiQ / pPiRho ), 3 );
	- EvtComplex BRhoDem( _mRho * _mRho - mQ2, -1.0 * _mRho * gammaRho );
	- EvtComplex BRho = _mRho * _mRho / BRhoDem;
	+ EvtComplex BRhoDem( m_mRho * m_mRho - mQ2, -1.0 * m_mRho * gammaRho );
	+ EvtComplex BRho = m_mRho * m_mRho / BRhoDem;

	- double gammaRhopr = _gammaRhopr * _mRhopr / sqrt( mQ2 ) *
	+ double gammaRhopr = m_gammaRhopr * m_mRhopr / sqrt( mQ2 ) *
	pow( ( pPiQ / pPiRhopr ), 3 );
	- EvtComplex BRhoprDem( _mRhopr * _mRhopr - mQ2, -1.0 * _mRho * gammaRhopr );
	- EvtComplex BRhopr = _mRhopr * _mRhopr / BRhoprDem;
	+ EvtComplex BRhoprDem( m_mRhopr * m_mRhopr - mQ2, -1.0 * m_mRho * gammaRhopr );
	+ EvtComplex BRhopr = m_mRhopr * m_mRhopr / BRhoprDem;

	- return ( BRho + _beta * BRhopr ) / ( 1 + _beta );
	+ return ( BRho + m_beta * BRhopr ) / ( 1 + m_beta );
	}

	double EvtBcToNPi::pi3G( double m2, int dupD )
	{
	double mPi = EvtPDL::getMeanMass( getDaug( dupD ) );
	- if ( m2 > ( _mRho + mPi ) ) {
	+ if ( m2 > ( m_mRho + mPi ) ) {
	return m2 * ( 1.623 + 10.38 / m2 - 9.32 / ( m2 * m2 ) +
	0.65 / ( m2 * m2 * m2 ) );
	} else {
	diff --git a/src/EvtGenModels/EvtBcVMuNu.cpp b/src/EvtGenModels/EvtBcVMuNu.cpp
	--- a/src/EvtGenModels/EvtBcVMuNu.cpp
	+++ b/src/EvtGenModels/EvtBcVMuNu.cpp
	@@ -48,7 +48,7 @@
	void EvtBcVMuNu::decay( EvtParticle* p )
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- calcamp->CalcAmp( p, _amp2, ffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_ffmodel.get() );
	}

	void EvtBcVMuNu::init()
	@@ -65,12 +65,12 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::NEUTRINO );

	- idVector = getDaug( 0 ).getId();
	- whichfit = int( getArg( 0 ) + 0.1 );
	+ m_idVector = getDaug( 0 ).getId();
	+ m_whichfit = int( getArg( 0 ) + 0.1 );

	- ffmodel = std::make_unique<EvtBCVFF>( idVector, whichfit );
	+ m_ffmodel = std::make_unique<EvtBCVFF>( m_idVector, m_whichfit );

	- calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	}

	void EvtBcVMuNu::initProbMax()
	@@ -81,8 +81,8 @@
	EvtId nuId = getDaug( 2 );

	int nQ2Bins = 200;
	- double maxProb = calcamp->CalcMaxProb( parId, mesonId, lepId, nuId,
	- ffmodel.get(), nQ2Bins );
	+ double maxProb = m_calcamp->CalcMaxProb( parId, mesonId, lepId, nuId,
	+ m_ffmodel.get(), nQ2Bins );

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtBcVMuNu" )
	diff --git a/src/EvtGenModels/EvtBcVNpi.cpp b/src/EvtGenModels/EvtBcVNpi.cpp
	--- a/src/EvtGenModels/EvtBcVNpi.cpp
	+++ b/src/EvtGenModels/EvtBcVNpi.cpp
	@@ -74,51 +74,51 @@
	// for(int i=0; i<getNDaug(); i++)
	// cout<<"BcVNpi::init \t\t daughter "<<i<<" : "<<getDaug(i).getId()<<" "<<EvtPDL::name(getDaug(i)).c_str()<<endl;

	- idVector = getDaug( 0 ).getId();
	- whichfit = int( getArg( 0 ) + 0.1 );
	- // cout<<"BcVNpi: whichfit ="<<whichfit<<" idVector="<<idVector<<endl;
	- ffmodel = std::make_unique<EvtBCVFF>( idVector, whichfit );
	+ m_idVector = getDaug( 0 ).getId();
	+ m_whichfit = int( getArg( 0 ) + 0.1 );
	+ // cout<<"BcVNpi: m_whichfit ="<<m_whichfit<<" m_idVector="<<m_idVector<<endl;
	+ m_ffmodel = std::make_unique<EvtBCVFF>( m_idVector, m_whichfit );

	- wcurr = std::make_unique<EvtWnPi>();
	+ m_wcurr = std::make_unique<EvtWnPi>();

	- nCall = 0;
	+ m_nCall = 0;
	}

	//======================================================
	void EvtBcVNpi::initProbMax()
	{
	// cout<<"BcVNpi::initProbMax()"<<endl;
	- if ( idVector == EvtPDL::getId( "J/psi" ).getId() && whichfit == 1 &&
	+ if ( m_idVector == EvtPDL::getId( "J/psi" ).getId() && m_whichfit == 1 &&
	getNDaug() == 6 )
	setProbMax( 720000. );
	- else if ( idVector == EvtPDL::getId( "J/psi" ).getId() && whichfit == 2 &&
	- getNDaug() == 6 )
	+ else if ( m_idVector == EvtPDL::getId( "J/psi" ).getId() &&
	+ m_whichfit == 2 && getNDaug() == 6 )
	setProbMax( 471817. );
	- else if ( idVector == EvtPDL::getId( "J/psi" ).getId() && whichfit == 1 &&
	- getNDaug() == 4 )
	+ else if ( m_idVector == EvtPDL::getId( "J/psi" ).getId() &&
	+ m_whichfit == 1 && getNDaug() == 4 )
	setProbMax( 42000. );
	- else if ( idVector == EvtPDL::getId( "J/psi" ).getId() && whichfit == 2 &&
	- getNDaug() == 4 )
	+ else if ( m_idVector == EvtPDL::getId( "J/psi" ).getId() &&
	+ m_whichfit == 2 && getNDaug() == 4 )
	setProbMax( 16000. );

	- else if ( idVector == EvtPDL::getId( "psi(2S)" ).getId() && whichfit == 1 &&
	- getNDaug() == 4 )
	+ else if ( m_idVector == EvtPDL::getId( "psi(2S)" ).getId() &&
	+ m_whichfit == 1 && getNDaug() == 4 )
	setProbMax( 1200. );
	- else if ( idVector == EvtPDL::getId( "psi(2S)" ).getId() && whichfit == 2 &&
	- getNDaug() == 4 )
	+ else if ( m_idVector == EvtPDL::getId( "psi(2S)" ).getId() &&
	+ m_whichfit == 2 && getNDaug() == 4 )
	setProbMax( 2600. );
	- else if ( idVector == EvtPDL::getId( "psi(2S)" ).getId() && whichfit == 1 &&
	- getNDaug() == 6 )
	+ else if ( m_idVector == EvtPDL::getId( "psi(2S)" ).getId() &&
	+ m_whichfit == 1 && getNDaug() == 6 )
	setProbMax( 40000. );
	- else if ( idVector == EvtPDL::getId( "psi(2S)" ).getId() && whichfit == 2 &&
	- getNDaug() == 6 )
	+ else if ( m_idVector == EvtPDL::getId( "psi(2S)" ).getId() &&
	+ m_whichfit == 2 && getNDaug() == 6 )
	setProbMax( 30000. );
	}

	//======================================================
	void EvtBcVNpi::decay( EvtParticle* root_particle )
	{
	- ++nCall;
	+ ++m_nCall;
	// cout<<"BcVNpi::decay()"<<endl;
	root_particle->initializePhaseSpace( getNDaug(), getDaugs() );

	@@ -131,25 +131,25 @@
	EvtVector4C hardCur;
	// bool foundHadCurr=false;
	if ( getNDaug() == 2 ) {
	- hardCur = wcurr->WCurrent( root_particle->getDaug( 1 )->getP4() );
	+ hardCur = m_wcurr->WCurrent( root_particle->getDaug( 1 )->getP4() );
	// foundHadCurr=true;
	} else if ( getNDaug() == 3 ) {
	- hardCur = wcurr->WCurrent( root_particle->getDaug( 1 )->getP4(),
	- root_particle->getDaug( 2 )->getP4() );
	+ hardCur = m_wcurr->WCurrent( root_particle->getDaug( 1 )->getP4(),
	+ root_particle->getDaug( 2 )->getP4() );
	// foundHadCurr=true;
	} else if ( getNDaug() == 4 ) {
	- hardCur = wcurr->WCurrent( root_particle->getDaug( 1 )->getP4(),
	- root_particle->getDaug( 2 )->getP4(),
	- root_particle->getDaug( 3 )->getP4() );
	+ hardCur = m_wcurr->WCurrent( root_particle->getDaug( 1 )->getP4(),
	+ root_particle->getDaug( 2 )->getP4(),
	+ root_particle->getDaug( 3 )->getP4() );
	// foundHadCurr=true;
	} else if ( getNDaug() ==
	6 ) // Bc -> psi pi+ pi+ pi- pi- pi+ from [Kuhn, Was, hep-ph/0602162
	{
	- hardCur = wcurr->WCurrent( root_particle->getDaug( 1 )->getP4(),
	- root_particle->getDaug( 2 )->getP4(),
	- root_particle->getDaug( 3 )->getP4(),
	- root_particle->getDaug( 4 )->getP4(),
	- root_particle->getDaug( 5 )->getP4() );
	+ hardCur = m_wcurr->WCurrent( root_particle->getDaug( 1 )->getP4(),
	+ root_particle->getDaug( 2 )->getP4(),
	+ root_particle->getDaug( 3 )->getP4(),
	+ root_particle->getDaug( 4 )->getP4(),
	+ root_particle->getDaug( 5 )->getP4() );
	// foundHadCurr=true;
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -168,9 +168,9 @@
	double a1f, a2f, vf, a0f;
	double m_meson = root_particle->getDaug( 0 )->mass();
	double m_b = root_particle->mass();
	- ffmodel->getvectorff( root_particle->getId(),
	- root_particle->getDaug( 0 )->getId(), Q2, m_meson,
	- &a1f, &a2f, &vf, &a0f );
	+ m_ffmodel->getvectorff( root_particle->getId(),
	+ root_particle->getDaug( 0 )->getId(), Q2, m_meson,
	+ &a1f, &a2f, &vf, &a0f );
	double a3f = ( ( m_b + m_meson ) / ( 2.0 * m_meson ) ) * a1f -
	( ( m_b - m_meson ) / ( 2.0 * m_meson ) ) * a2f;

	diff --git a/src/EvtGenModels/EvtBsMuMuKK.cpp b/src/EvtGenModels/EvtBsMuMuKK.cpp
	--- a/src/EvtGenModels/EvtBsMuMuKK.cpp
	+++ b/src/EvtGenModels/EvtBsMuMuKK.cpp
	@@ -54,133 +54,134 @@
	checkNArg( 37 );

	// Non-resonant S wave
	- f_S_NR = getArg( 0 );
	- delta_S_NR = getArg( 1 );
	- phis_S_NR = getArg( 2 );
	- lambda_S_NR_abs = getArg( 3 );
	+ m_f_S_NR = getArg( 0 );
	+ m_delta_S_NR = getArg( 1 );
	+ m_phis_S_NR = getArg( 2 );
	+ m_lambda_S_NR_abs = getArg( 3 );

	// f0 (S wave)
	- f_f0 = getArg( 4 );
	- delta_f0 = getArg( 5 );
	- phis_f0 = getArg( 6 );
	- lambda_f0_abs = getArg( 7 );
	+ m_f_f0 = getArg( 4 );
	+ m_delta_f0 = getArg( 5 );
	+ m_phis_f0 = getArg( 6 );
	+ m_lambda_f0_abs = getArg( 7 );

	// phi (P wave)
	- f_phi = getArg( 8 );
	- f_phi_0 = getArg( 9 );
	- delta_phi_0 = getArg( 10 );
	- phis_phi_0 = getArg( 11 );
	- lambda_phi_0_abs = getArg( 12 );
	- f_phi_perp = getArg( 13 );
	- delta_phi_perp = pi - getArg( 14 );
	- phis_phi_perp = getArg( 15 );
	- lambda_phi_perp_abs = getArg( 16 );
	- delta_phi_par = pi - getArg( 17 );
	- phis_phi_par = getArg( 18 );
	- lambda_phi_par_abs = getArg( 19 );
	+ m_f_phi = getArg( 8 );
	+ m_f_phi_0 = getArg( 9 );
	+ m_delta_phi_0 = getArg( 10 );
	+ m_phis_phi_0 = getArg( 11 );
	+ m_lambda_phi_0_abs = getArg( 12 );
	+ m_f_phi_perp = getArg( 13 );
	+ m_delta_phi_perp = pi - getArg( 14 );
	+ m_phis_phi_perp = getArg( 15 );
	+ m_lambda_phi_perp_abs = getArg( 16 );
	+ m_delta_phi_par = pi - getArg( 17 );
	+ m_phis_phi_par = getArg( 18 );
	+ m_lambda_phi_par_abs = getArg( 19 );

	// f2' (D wave)
	- f_f2p_0 = getArg( 20 );
	- delta_f2p_0 = getArg( 21 );
	- phis_f2p_0 = getArg( 22 );
	- lambda_f2p_0_abs = getArg( 23 );
	- f_f2p_perp = getArg( 24 );
	- delta_f2p_perp = pi - getArg( 25 );
	- phis_f2p_perp = getArg( 26 );
	- lambda_f2p_perp_abs = getArg( 27 );
	- delta_f2p_par = pi - getArg( 28 );
	- phis_f2p_par = getArg( 29 );
	- lambda_f2p_par_abs = getArg( 30 );
	+ m_f_f2p_0 = getArg( 20 );
	+ m_delta_f2p_0 = getArg( 21 );
	+ m_phis_f2p_0 = getArg( 22 );
	+ m_lambda_f2p_0_abs = getArg( 23 );
	+ m_f_f2p_perp = getArg( 24 );
	+ m_delta_f2p_perp = pi - getArg( 25 );
	+ m_phis_f2p_perp = getArg( 26 );
	+ m_lambda_f2p_perp_abs = getArg( 27 );
	+ m_delta_f2p_par = pi - getArg( 28 );
	+ m_phis_f2p_par = getArg( 29 );
	+ m_lambda_f2p_par_abs = getArg( 30 );

	// Time dependence
	- Gamma = getArg( 31 );
	- deltaGamma = getArg( 32 );
	- deltaMs = getArg( 33 );
	+ m_Gamma = getArg( 31 );
	+ m_deltaGamma = getArg( 32 );
	+ m_deltaMs = getArg( 33 );

	// mKK window
	- Mf0 = getArg( 34 );
	- kin_lower_limit = getArg( 35 ); // the minimum is approx 2.03*MKp
	- kin_upper_limit = getArg( 36 );
	+ m_Mf0 = getArg( 34 );
	+ m_kin_lower_limit = getArg( 35 ); // the minimum is approx 2.03*MKp
	+ m_kin_upper_limit = getArg( 36 );

	// PDG masses
	- MBs = EvtPDL::getMass( EvtPDL::getId( "B_s0" ) );
	- MJpsi = EvtPDL::getMeanMass( EvtPDL::getId( "J/psi" ) );
	- Mphi = EvtPDL::getMeanMass( EvtPDL::getId( "phi" ) );
	- Mf2p = EvtPDL::getMeanMass( EvtPDL::getId( "f'_2" ) );
	- MKp = EvtPDL::getMass( EvtPDL::getId( "K+" ) );
	- MKm = EvtPDL::getMass( EvtPDL::getId( "K-" ) );
	- MK0 = EvtPDL::getMass( EvtPDL::getId( "K0" ) );
	- Mpip = EvtPDL::getMass( EvtPDL::getId( "pi+" ) );
	- Mpi0 = EvtPDL::getMass( EvtPDL::getId( "pi0" ) );
	- Mmu = EvtPDL::getMass( EvtPDL::getId( "mu+" ) );
	-
	- double MBsSq = MBs * MBs;
	+ m_MBs = EvtPDL::getMass( EvtPDL::getId( "B_s0" ) );
	+ m_MJpsi = EvtPDL::getMeanMass( EvtPDL::getId( "J/psi" ) );
	+ m_Mphi = EvtPDL::getMeanMass( EvtPDL::getId( "phi" ) );
	+ m_Mf2p = EvtPDL::getMeanMass( EvtPDL::getId( "f'_2" ) );
	+ m_MKp = EvtPDL::getMass( EvtPDL::getId( "K+" ) );
	+ m_MKm = EvtPDL::getMass( EvtPDL::getId( "K-" ) );
	+ m_MK0 = EvtPDL::getMass( EvtPDL::getId( "K0" ) );
	+ m_Mpip = EvtPDL::getMass( EvtPDL::getId( "pi+" ) );
	+ m_Mpi0 = EvtPDL::getMass( EvtPDL::getId( "pi0" ) );
	+ m_Mmu = EvtPDL::getMass( EvtPDL::getId( "mu+" ) );
	+
	+ double MBsSq = m_MBs * m_MBs;

	// Amplitudes and other time parameters
	- A_S_NR = sqrt( f_S_NR );
	- A_f0 = sqrt( f_f0 );
	+ m_A_S_NR = sqrt( m_f_S_NR );
	+ m_A_f0 = sqrt( m_f_f0 );

	- A_phi_0 = sqrt( f_phi_0 * f_phi );
	- A_phi_perp = sqrt( f_phi_perp * f_phi );
	+ m_A_phi_0 = sqrt( m_f_phi_0 * m_f_phi );
	+ m_A_phi_perp = sqrt( m_f_phi_perp * m_f_phi );
	// Use fabs to make sure subtractions are >= 0, since subtracting 0 from 0 can give -0
	- A_phi_par = sqrt(
	- fabs( f_phi - A_phi_perp * A_phi_perp - A_phi_0 * A_phi_0 ) );
	+ m_A_phi_par = sqrt(
	+ fabs( m_f_phi - m_A_phi_perp * m_A_phi_perp - m_A_phi_0 * m_A_phi_0 ) );

	- f_f2p = fabs( 1.0 - f_S_NR - f_f0 - f_phi );
	- A_f2p_0 = sqrt( f_f2p_0 * f_f2p );
	- A_f2p_perp = sqrt( f_f2p_perp * f_f2p );
	- A_f2p_par = sqrt(
	- fabs( f_f2p - A_f2p_perp * A_f2p_perp - A_f2p_0 * A_f2p_0 ) );
	+ m_f_f2p = fabs( 1.0 - m_f_S_NR - m_f_f0 - m_f_phi );
	+ m_A_f2p_0 = sqrt( m_f_f2p_0 * m_f_f2p );
	+ m_A_f2p_perp = sqrt( m_f_f2p_perp * m_f_f2p );
	+ m_A_f2p_par = sqrt(
	+ fabs( m_f_f2p - m_A_f2p_perp * m_A_f2p_perp - m_A_f2p_0 * m_A_f2p_0 ) );

	- ctau = 1.0 / Gamma;
	- Gamma0phi = EvtPDL::getWidth( EvtPDL::getId( "phi" ) );
	- Gamma0f2p = EvtPDL::getWidth( EvtPDL::getId( "f'_2" ) );
	+ m_ctau = 1.0 / m_Gamma;
	+ m_Gamma0phi = EvtPDL::getWidth( EvtPDL::getId( "phi" ) );
	+ m_Gamma0f2p = EvtPDL::getWidth( EvtPDL::getId( "f'_2" ) );

	- kin_middle = 0.5 * ( kin_upper_limit + kin_lower_limit );
	+ m_kin_middle = 0.5 * ( m_kin_upper_limit + m_kin_lower_limit );

	- int_const_NR = sqrt(
	- Integral( 1.0, 1.0, 0, 1, 1.0, kin_lower_limit, kin_upper_limit, 0 ) );
	+ m_int_const_NR = sqrt( Integral( 1.0, 1.0, 0, 1, 1.0, m_kin_lower_limit,
	+ m_kin_upper_limit, 0 ) );

	- int_Flatte_f0 = sqrt(
	- Integral( 1.0, Mf0, 0, 1, 1.0, kin_lower_limit, kin_upper_limit, 1 ) );
	+ m_int_Flatte_f0 = sqrt( Integral( 1.0, m_Mf0, 0, 1, 1.0, m_kin_lower_limit,
	+ m_kin_upper_limit, 1 ) );

	- p30Kp_mid_CMS = sqrt( ( pow( kin_middle, 2 ) - pow( MKp + MKm, 2 ) ) *
	- ( pow( kin_middle, 2 ) - pow( MKp - MKm, 2 ) ) ) /
	- ( 2.0 * kin_middle );
	+ m_p30Kp_mid_CMS = sqrt( ( pow( m_kin_middle, 2 ) - pow( m_MKp + m_MKm, 2 ) ) *
	+ ( pow( m_kin_middle, 2 ) - pow( m_MKp - m_MKm, 2 ) ) ) /
	+ ( 2.0 * m_kin_middle );

	- p30Kp_ll_CMS = sqrt( ( pow( kin_lower_limit, 2 ) - pow( MKp + MKm, 2 ) ) *
	- ( pow( kin_lower_limit, 2 ) - pow( MKp - MKm, 2 ) ) ) /
	- ( 2.0 * kin_lower_limit );
	+ m_p30Kp_ll_CMS =
	+ sqrt( ( pow( m_kin_lower_limit, 2 ) - pow( m_MKp + m_MKm, 2 ) ) *
	+ ( pow( m_kin_lower_limit, 2 ) - pow( m_MKp - m_MKm, 2 ) ) ) /
	+ ( 2.0 * m_kin_lower_limit );

	- p30Kp_phi_CMS = sqrt( ( Mphi * Mphi - pow( MKp + MKm, 2 ) ) *
	- ( Mphi * Mphi - pow( MKp - MKm, 2 ) ) ) /
	- ( 2.0 * Mphi );
	+ m_p30Kp_phi_CMS = sqrt( ( m_Mphi * m_Mphi - pow( m_MKp + m_MKm, 2 ) ) *
	+ ( m_Mphi * m_Mphi - pow( m_MKp - m_MKm, 2 ) ) ) /
	+ ( 2.0 * m_Mphi );

	- p30Kp_f2p_CMS = sqrt( ( Mf2p * Mf2p - pow( MKp + MKm, 2 ) ) *
	- ( Mf2p * Mf2p - pow( MKp - MKm, 2 ) ) ) /
	- ( 2.0 * Mf2p );
	+ m_p30Kp_f2p_CMS = sqrt( ( m_Mf2p * m_Mf2p - pow( m_MKp + m_MKm, 2 ) ) *
	+ ( m_Mf2p * m_Mf2p - pow( m_MKp - m_MKm, 2 ) ) ) /
	+ ( 2.0 * m_Mf2p );

	- p30Jpsi_mid_CMS = sqrt( ( MBsSq - pow( kin_middle + MJpsi, 2 ) ) *
	- ( MBsSq - pow( kin_middle - MJpsi, 2 ) ) ) /
	- ( 2.0 * MBs );
	+ m_p30Jpsi_mid_CMS = sqrt( ( MBsSq - pow( m_kin_middle + m_MJpsi, 2 ) ) *
	+ ( MBsSq - pow( m_kin_middle - m_MJpsi, 2 ) ) ) /
	+ ( 2.0 * m_MBs );

	- p30Jpsi_ll_CMS = sqrt( ( MBsSq - pow( kin_lower_limit + MJpsi, 2 ) ) *
	- ( MBsSq - pow( kin_lower_limit - MJpsi, 2 ) ) ) /
	- ( 2.0 * MBs );
	+ m_p30Jpsi_ll_CMS = sqrt( ( MBsSq - pow( m_kin_lower_limit + m_MJpsi, 2 ) ) *
	+ ( MBsSq - pow( m_kin_lower_limit - m_MJpsi, 2 ) ) ) /
	+ ( 2.0 * m_MBs );

	- p30Jpsi_phi_CMS = sqrt( ( MBsSq - pow( Mphi + MJpsi, 2 ) ) *
	- ( MBsSq - pow( Mphi - MJpsi, 2 ) ) ) /
	- ( 2.0 * MBs );
	+ m_p30Jpsi_phi_CMS = sqrt( ( MBsSq - pow( m_Mphi + m_MJpsi, 2 ) ) *
	+ ( MBsSq - pow( m_Mphi - m_MJpsi, 2 ) ) ) /
	+ ( 2.0 * m_MBs );

	- p30Jpsi_f2p_CMS = sqrt( ( MBsSq - pow( Mf2p + MJpsi, 2 ) ) *
	- ( MBsSq - pow( Mf2p - MJpsi, 2 ) ) ) /
	- ( 2.0 * MBs );
	+ m_p30Jpsi_f2p_CMS = sqrt( ( MBsSq - pow( m_Mf2p + m_MJpsi, 2 ) ) *
	+ ( MBsSq - pow( m_Mf2p - m_MJpsi, 2 ) ) ) /
	+ ( 2.0 * m_MBs );

	- int_BW_phi = sqrt( Integral( Gamma0phi, Mphi, 1, 0, p30Kp_phi_CMS,
	- kin_lower_limit, kin_upper_limit, 2 ) );
	+ m_int_BW_phi = sqrt( Integral( m_Gamma0phi, m_Mphi, 1, 0, m_p30Kp_phi_CMS,
	+ m_kin_lower_limit, m_kin_upper_limit, 2 ) );

	- int_BW_f2p = sqrt( Integral( Gamma0f2p, Mf2p, 2, 1, p30Kp_f2p_CMS,
	- kin_lower_limit, kin_upper_limit, 2 ) );
	+ m_int_BW_f2p = sqrt( Integral( m_Gamma0f2p, m_Mf2p, 2, 1, m_p30Kp_f2p_CMS,
	+ m_kin_lower_limit, m_kin_upper_limit, 2 ) );

	// 4 daughters
	checkNDaug( 4 );
	@@ -216,41 +217,41 @@
	// Get ProbMax
	void EvtBsMuMuKK::initProbMax()
	{
	- const EvtComplex term11 = sqrt( p30Jpsi_f2p_CMS * p30Kp_f2p_CMS );
	+ const EvtComplex term11 = sqrt( m_p30Jpsi_f2p_CMS * m_p30Kp_f2p_CMS );

	- const EvtComplex term12 = X_J( 2, p30Kp_f2p_CMS, 0 ) *
	- X_J( 1, p30Jpsi_f2p_CMS, 1 ) * p30Kp_f2p_CMS *
	- p30Kp_f2p_CMS * p30Jpsi_f2p_CMS *
	- ( A_f2p_0 + 0.3 * A_f2p_perp + 0.3 * A_f2p_par );
	+ const EvtComplex term12 =
	+ X_J( 2, m_p30Kp_f2p_CMS, 0 ) * X_J( 1, m_p30Jpsi_f2p_CMS, 1 ) *
	+ m_p30Kp_f2p_CMS * m_p30Kp_f2p_CMS * m_p30Jpsi_f2p_CMS *
	+ ( m_A_f2p_0 + 0.3 * m_A_f2p_perp + 0.3 * m_A_f2p_par );

	- const EvtComplex term13 = f_f2p *
	- Breit_Wigner( Gamma0f2p, Mf2p, Mf2p, 2,
	- p30Kp_f2p_CMS, p30Kp_f2p_CMS ) /
	- int_BW_f2p;
	+ const EvtComplex term13 = m_f_f2p *
	+ Breit_Wigner( m_Gamma0f2p, m_Mf2p, m_Mf2p, 2,
	+ m_p30Kp_f2p_CMS, m_p30Kp_f2p_CMS ) /
	+ m_int_BW_f2p;

	- const EvtComplex term21 = sqrt( p30Jpsi_phi_CMS * p30Kp_phi_CMS );
	+ const EvtComplex term21 = sqrt( m_p30Jpsi_phi_CMS * m_p30Kp_phi_CMS );

	- const EvtComplex term22 = X_J( 1, p30Kp_phi_CMS, 0 ) * p30Kp_phi_CMS *
	- ( 0.65 * A_phi_0 + 0.6 * A_phi_perp +
	- 0.6 * A_phi_par );
	+ const EvtComplex term22 = X_J( 1, m_p30Kp_phi_CMS, 0 ) * m_p30Kp_phi_CMS *
	+ ( 0.65 * m_A_phi_0 + 0.6 * m_A_phi_perp +
	+ 0.6 * m_A_phi_par );

	- const EvtComplex term23 = f_phi *
	- Breit_Wigner( Gamma0phi, Mphi, Mphi, 1,
	- p30Kp_phi_CMS, p30Kp_phi_CMS ) /
	- int_BW_phi;
	+ const EvtComplex term23 = m_f_phi *
	+ Breit_Wigner( m_Gamma0phi, m_Mphi, m_Mphi, 1,
	+ m_p30Kp_phi_CMS, m_p30Kp_phi_CMS ) /
	+ m_int_BW_phi;

	- const EvtComplex term31 = sqrt( p30Jpsi_ll_CMS * p30Kp_ll_CMS );
	+ const EvtComplex term31 = sqrt( m_p30Jpsi_ll_CMS * m_p30Kp_ll_CMS );

	- const EvtComplex term32 = X_J( 1, p30Jpsi_ll_CMS, 1 ) * p30Jpsi_ll_CMS;
	+ const EvtComplex term32 = X_J( 1, m_p30Jpsi_ll_CMS, 1 ) * m_p30Jpsi_ll_CMS;

	- const EvtComplex term33 = f_f0 * Flatte( Mf0, kin_lower_limit ) /
	- int_Flatte_f0;
	+ const EvtComplex term33 = m_f_f0 * Flatte( m_Mf0, m_kin_lower_limit ) /
	+ m_int_Flatte_f0;

	- const EvtComplex term41 = sqrt( p30Jpsi_mid_CMS * p30Kp_mid_CMS );
	+ const EvtComplex term41 = sqrt( m_p30Jpsi_mid_CMS * m_p30Kp_mid_CMS );

	- const EvtComplex term42 = X_J( 1, p30Jpsi_mid_CMS, 1 ) * p30Jpsi_mid_CMS;
	+ const EvtComplex term42 = X_J( 1, m_p30Jpsi_mid_CMS, 1 ) * m_p30Jpsi_mid_CMS;

	- const EvtComplex term43 = 1.2 * f_S_NR / int_const_NR;
	+ const EvtComplex term43 = 1.2 * m_f_S_NR / m_int_const_NR;

	const EvtComplex hm = term11 * term12 * term13 + term21 * term22 * term23 +
	term31 * term32 * term33 + term41 * term42 * term43;
	@@ -266,7 +267,7 @@
	double time( 0.0 );
	EvtCPUtil::getInstance()->OtherB( p, time, other_b );
	time = -log( EvtRandom::Flat() ) *
	- ctau; // This overrules the ctau made in OtherB
	+ m_ctau; // This overrules the ctau made in OtherB

	if ( EvtCPUtil::getInstance()->isBsMixed( p ) ) {
	p->getParent()->setLifetime( time * EvtConst::c / 1e12 ); // units: mm
	@@ -274,8 +275,8 @@
	p->setLifetime( time * EvtConst::c / 1e12 ); // units: mm
	}

	- double DGtime = 0.25 * deltaGamma * time;
	- double DMtime = 0.5 * deltaMs * time;
	+ double DGtime = 0.25 * m_deltaGamma * time;
	+ double DMtime = 0.5 * m_deltaMs * time;
	double mt = exp( -DGtime );
	double pt = exp( +DGtime );
	double cDMt = cos( DMtime );
	@@ -296,44 +297,46 @@
	p->setAttribute( "q", q );

	// Amplitudes
	- EvtComplex a_S_NR = AmpTime( q, gplus, gminus, delta_S_NR, lambda_S_NR_abs,
	- A_S_NR, phis_S_NR, -1 );
	+ EvtComplex a_S_NR = AmpTime( q, gplus, gminus, m_delta_S_NR,
	+ m_lambda_S_NR_abs, m_A_S_NR, m_phis_S_NR, -1 );

	- EvtComplex a_f0 = AmpTime( q, gplus, gminus, delta_f0, lambda_f0_abs, A_f0,
	- phis_f0, -1 );
	+ EvtComplex a_f0 = AmpTime( q, gplus, gminus, m_delta_f0, m_lambda_f0_abs,
	+ m_A_f0, m_phis_f0, -1 );

	- EvtComplex a0_phi = AmpTime( q, gplus, gminus, delta_phi_0,
	- lambda_phi_0_abs, A_phi_0, phis_phi_0, 1 );
	+ EvtComplex a0_phi = AmpTime( q, gplus, gminus, m_delta_phi_0,
	+ m_lambda_phi_0_abs, m_A_phi_0, m_phis_phi_0, 1 );

	- EvtComplex aperp_phi = AmpTime( q, gplus, gminus, delta_phi_perp,
	- lambda_phi_perp_abs, A_phi_perp,
	- phis_phi_perp, -1 );
	+ EvtComplex aperp_phi = AmpTime( q, gplus, gminus, m_delta_phi_perp,
	+ m_lambda_phi_perp_abs, m_A_phi_perp,
	+ m_phis_phi_perp, -1 );

	- EvtComplex apar_phi = AmpTime( q, gplus, gminus, delta_phi_par,
	- lambda_phi_par_abs, A_phi_par, phis_phi_par,
	- 1 );
	+ EvtComplex apar_phi = AmpTime( q, gplus, gminus, m_delta_phi_par,
	+ m_lambda_phi_par_abs, m_A_phi_par,
	+ m_phis_phi_par, 1 );

	- EvtComplex a0_f2p = AmpTime( q, gplus, gminus, delta_f2p_0,
	- lambda_f2p_0_abs, A_f2p_0, phis_f2p_0, -1 );
	+ EvtComplex a0_f2p = AmpTime( q, gplus, gminus, m_delta_f2p_0,
	+ m_lambda_f2p_0_abs, m_A_f2p_0, m_phis_f2p_0,
	+ -1 );

	- EvtComplex aperp_f2p = AmpTime( q, gplus, gminus, delta_f2p_perp,
	- lambda_f2p_perp_abs, A_f2p_perp,
	- phis_f2p_perp, 1 );
	+ EvtComplex aperp_f2p = AmpTime( q, gplus, gminus, m_delta_f2p_perp,
	+ m_lambda_f2p_perp_abs, m_A_f2p_perp,
	+ m_phis_f2p_perp, 1 );

	- EvtComplex apar_f2p = AmpTime( q, gplus, gminus, delta_f2p_par,
	- lambda_f2p_par_abs, A_f2p_par, phis_f2p_par,
	- -1 );
	+ EvtComplex apar_f2p = AmpTime( q, gplus, gminus, m_delta_f2p_par,
	+ m_lambda_f2p_par_abs, m_A_f2p_par,
	+ m_phis_f2p_par, -1 );

	// Generate 4-momenta
	- double mKK = EvtRandom::Flat( kin_lower_limit, kin_upper_limit );
	- double mass[10] = { MJpsi, mKK, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
	- double Kmass[10] = { MKp, MKm, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
	- double muMass[10] = { Mmu, Mmu, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
	+ double mKK = EvtRandom::Flat( m_kin_lower_limit, m_kin_upper_limit );
	+ double mass[10] = { m_MJpsi, mKK, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
	+ double Kmass[10] = { m_MKp, m_MKm, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
	+ double muMass[10] = { m_Mmu, m_Mmu, 0.0, 0.0, 0.0,
	+ 0.0, 0.0, 0.0, 0.0, 0.0 };

	EvtVector4R mypV[2], mypK[2], mypmu[2];
	- EvtGenKine::PhaseSpace( 2, mass, mypV, MBs );
	+ EvtGenKine::PhaseSpace( 2, mass, mypV, m_MBs );
	EvtGenKine::PhaseSpace( 2, Kmass, mypK, mKK );
	- EvtGenKine::PhaseSpace( 2, muMass, mypmu, MJpsi );
	+ EvtGenKine::PhaseSpace( 2, muMass, mypmu, m_MJpsi );

	EvtVector4R p4mup = boostTo( mypmu[0], mypV[0] );
	EvtVector4R p4mum = boostTo( mypmu[1], mypV[0] );
	@@ -378,32 +381,32 @@
	double p4Bs_mass = p4Bs.mass();

	// Kp momentum in the KK CMS
	- double p3Kp_KK_CMS = sqrt( ( p4KK_mass2 - pow( MKp + MKm, 2 ) ) *
	- ( p4KK_mass2 - pow( MKp - MKm, 2 ) ) ) /
	+ double p3Kp_KK_CMS = sqrt( ( p4KK_mass2 - pow( m_MKp + m_MKm, 2 ) ) *
	+ ( p4KK_mass2 - pow( m_MKp - m_MKm, 2 ) ) ) /
	( 2.0 * p4KK_mass );

	// J/psi momentum in the KK CMS
	- double p3Jpsi_KK_CMS = sqrt( ( p4Bs_mass2 - pow( p4KK_mass + MJpsi, 2 ) ) *
	- ( p4Bs_mass2 - pow( p4KK_mass - MJpsi, 2 ) ) ) /
	+ double p3Jpsi_KK_CMS = sqrt( ( p4Bs_mass2 - pow( p4KK_mass + m_MJpsi, 2 ) ) *
	+ ( p4Bs_mass2 - pow( p4KK_mass - m_MJpsi, 2 ) ) ) /
	( 2.0 * p4Bs_mass );

	// Mass lineshapes

	// Non-resonant S wave
	- EvtComplex P_NR = 1.0 / int_const_NR;
	+ EvtComplex P_NR = 1.0 / m_int_const_NR;

	// f0 Flatte
	- EvtComplex F_f0 = Flatte( Mf0, p4KK_mass ) / int_Flatte_f0;
	+ EvtComplex F_f0 = Flatte( m_Mf0, p4KK_mass ) / m_int_Flatte_f0;

	// phi Breit Wigner
	- EvtComplex BW_phi = Breit_Wigner( Gamma0phi, Mphi, p4KK_mass, 1,
	- p30Kp_phi_CMS, p3Kp_KK_CMS ) /
	- int_BW_phi;
	+ EvtComplex BW_phi = Breit_Wigner( m_Gamma0phi, m_Mphi, p4KK_mass, 1,
	+ m_p30Kp_phi_CMS, p3Kp_KK_CMS ) /
	+ m_int_BW_phi;

	// f2' Breit Wigner
	- EvtComplex BW_f2p = Breit_Wigner( Gamma0f2p, Mf2p, p4KK_mass, 1,
	- p30Kp_f2p_CMS, p3Kp_KK_CMS ) /
	- int_BW_f2p;
	+ EvtComplex BW_f2p = Breit_Wigner( m_Gamma0f2p, m_Mf2p, p4KK_mass, 1,
	+ m_p30Kp_f2p_CMS, p3Kp_KK_CMS ) /
	+ m_int_BW_f2p;

	// Barrier factors: Always taking the lowest Bs L
	double X_KK_0 = 1.0;
	@@ -521,8 +524,8 @@
	double gpipi = 0.167;
	double gKK = 3.05 * gpipi;

	- EvtComplex term1 = ( 2.0 * GetRho( Mpip, m ) + GetRho( Mpi0, m ) ) / 3.0;
	- EvtComplex term2 = ( GetRho( MKp, m ) + GetRho( MK0, m ) ) / 2.0;
	+ EvtComplex term1 = ( 2.0 * GetRho( m_Mpip, m ) + GetRho( m_Mpi0, m ) ) / 3.0;
	+ EvtComplex term2 = ( GetRho( m_MKp, m ) + GetRho( m_MK0, m ) ) / 2.0;

	EvtComplex w = gpipi * term1 + gKK * term2;

	@@ -553,9 +556,9 @@
	int bins = 1000;
	double bin_width = ( M_KK_ul - M_KK_ll ) / static_cast<double>( bins );
	EvtComplex integral( 0.0, 0.0 );
	- double sumMKpKm2 = pow( MKp + MKm, 2 );
	- double diffMKpKm2 = pow( MKp - MKm, 2 );
	- double MBs2 = pow( MBs, 2 );
	+ double sumMKpKm2 = pow( m_MKp + m_MKm, 2 );
	+ double diffMKpKm2 = pow( m_MKp - m_MKm, 2 );
	+ double MBs2 = pow( m_MBs, 2 );

	for ( int i = 0; i < bins; i++ ) {
	double M_KK_i = M_KK_ll + static_cast<double>( i ) * bin_width;
	@@ -570,12 +573,12 @@
	( M_KK_f_sq - diffMKpKm2 ) ) /
	( 2.0 * M_KK_f );

	- double p3Jpsi_Bs_CMS_i = sqrt( ( MBs2 - pow( M_KK_i + MJpsi, 2 ) ) *
	- ( MBs2 - pow( M_KK_i - MJpsi, 2 ) ) ) /
	- ( 2.0 * MBs );
	- double p3Jpsi_Bs_CMS_f = sqrt( ( MBs2 - pow( M_KK_f + MJpsi, 2 ) ) *
	- ( MBs2 - pow( M_KK_f - MJpsi, 2 ) ) ) /
	- ( 2.0 * MBs );
	+ double p3Jpsi_Bs_CMS_i = sqrt( ( MBs2 - pow( M_KK_i + m_MJpsi, 2 ) ) *
	+ ( MBs2 - pow( M_KK_i - m_MJpsi, 2 ) ) ) /
	+ ( 2.0 * m_MBs );
	+ double p3Jpsi_Bs_CMS_f = sqrt( ( MBs2 - pow( M_KK_f + m_MJpsi, 2 ) ) *
	+ ( MBs2 - pow( M_KK_f - m_MJpsi, 2 ) ) ) /
	+ ( 2.0 * m_MBs );

	double f_PHSP_i = sqrt( p3Kp_KK_CMS_i * p3Jpsi_Bs_CMS_i );
	double f_PHSP_f = sqrt( p3Kp_KK_CMS_f * p3Jpsi_Bs_CMS_f );
	diff --git a/src/EvtGenModels/EvtBtoKD3P.cpp b/src/EvtGenModels/EvtBtoKD3P.cpp
	--- a/src/EvtGenModels/EvtBtoKD3P.cpp
	+++ b/src/EvtGenModels/EvtBtoKD3P.cpp
	@@ -62,9 +62,9 @@
	// Check that the B dtr types are K D D:

	// get the parameters:
	- _r = getArg( 0 );
	+ m_r = getArg( 0 );
	double phase = getArg( 1 );
	- _exp = EvtComplex( cos( phase ), sin( phase ) );
	+ m_exp = EvtComplex( cos( phase ), sin( phase ) );
	}

	//------------------------------------------------------------------
	@@ -77,7 +77,7 @@
	void EvtBtoKD3P::decay( EvtParticle* p )
	{
	// tell the subclass that we decay the daughter:
	- _daugsDecayedByParentModel = true;
	+ m_daugsDecayedByParentModel = true;

	// the K is the 1st daughter of the B EvtParticle.
	// The decay mode of the allowed D (the one produced in b->c decay) is 2nd
	@@ -104,12 +104,12 @@
	(EvtPto3P*)( EvtDecayTable::getInstance()->getDecayFunc( theD ) );

	// on the first call:
	- if ( false == _decayedOnce ) {
	- _decayedOnce = true;
	+ if ( false == m_decayedOnce ) {
	+ m_decayedOnce = true;

	// store the D decay model pointers:
	- _model1 = model1;
	- _model2 = model2;
	+ m_model1 = model1;
	+ m_model2 = model2;

	// check the decay models of the first 2 daughters and that they
	// have the same final states:
	@@ -160,13 +160,13 @@
	// estimate the probmax. Need to know the probmax's of the 2
	// models for this:
	setProbMax(
	- model1->getProbMax( 0 ) + _r * _r * model2->getProbMax( 0 ) +
	- 2 * _r * sqrt( model1->getProbMax( 0 ) * model2->getProbMax( 0 ) ) );
	+ model1->getProbMax( 0 ) + m_r * m_r * model2->getProbMax( 0 ) +
	+ 2 * m_r * sqrt( model1->getProbMax( 0 ) * model2->getProbMax( 0 ) ) );

	} // end of things to do on the first call

	// make sure the models haven't changed since the first call:
	- if ( _model1 != model1 \|\| _model2 != model2 ) {
	+ if ( m_model1 != model1 \|\| m_model2 != model2 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "D daughters of EvtBtoKD3P decay should have only 1 decay modes, "
	<< endl
	@@ -183,7 +183,7 @@
	// They are summed with coefficients 1 because we are willing to
	// take a small inefficiency (~50%) in order to ensure that the
	// cover function is large enough without getting into complications
	- // associated with the smallness of _r:
	+ // associated with the smallness of m_r:
	EvtPdfSum<EvtDalitzPoint>* pc1 = model1->getPC();
	EvtPdfSum<EvtDalitzPoint>* pc2 = model2->getPC();
	EvtPdfSum<EvtDalitzPoint> pc;
	@@ -196,7 +196,7 @@
	// get the aptitude for each of the models on this point and add them up:
	EvtComplex amp1 = model1->amplNonCP( x );
	EvtComplex amp2 = model2->amplNonCP( x );
	- EvtComplex amp = amp1 + amp2 * _r * _exp;
	+ EvtComplex amp = amp1 + amp2 * m_r * m_exp;

	// get the value of the cover function for this point and set the
	// relative amplitude for this decay:
	diff --git a/src/EvtGenModels/EvtBtoXsgamma.cpp b/src/EvtGenModels/EvtBtoXsgamma.cpp
	--- a/src/EvtGenModels/EvtBtoXsgamma.cpp
	+++ b/src/EvtGenModels/EvtBtoXsgamma.cpp
	@@ -75,15 +75,15 @@
	{
	//initialize here. -- its too damn slow otherwise.

	- if ( _model == nullptr ) {
	+ if ( m_model == nullptr ) {
	if ( getArg( 0 ) == 1 )
	- _model = std::make_unique<EvtBtoXsgammaAliGreub>();
	+ m_model = std::make_unique<EvtBtoXsgammaAliGreub>();
	else if ( getArg( 0 ) == 2 )
	- _model = std::make_unique<EvtBtoXsgammaKagan>();
	+ m_model = std::make_unique<EvtBtoXsgammaKagan>();
	else if ( getArg( 0 ) == 3 )
	- _model = std::make_unique<EvtBtoXsgammaFixedMass>();
	+ m_model = std::make_unique<EvtBtoXsgammaFixedMass>();
	else if ( getArg( 0 ) == 4 )
	- _model = std::make_unique<EvtBtoXsgammaFlatEnergy>();
	+ m_model = std::make_unique<EvtBtoXsgammaFlatEnergy>();
	else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "No valid EvtBtoXsgamma generator model selected "
	@@ -93,7 +93,7 @@
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- _model->init( getNArg(), getArgs() );
	+ m_model->init( getNArg(), getArgs() );
	}

	// if ( p->getNDaug() != 0 ) {
	@@ -120,7 +120,7 @@

	int Xscode = EvtPDL::getStdHep( getDaug( 0 ) );

	- mass[0] = _model->GetMass( Xscode );
	+ mass[0] = m_model->GetMass( Xscode );

	EvtGenKine::PhaseSpace( getNDaug(), mass, p4, m_b );

	diff --git a/src/EvtGenModels/EvtBtoXsgammaFixedMass.cpp b/src/EvtGenModels/EvtBtoXsgammaFixedMass.cpp
	--- a/src/EvtGenModels/EvtBtoXsgammaFixedMass.cpp
	+++ b/src/EvtGenModels/EvtBtoXsgammaFixedMass.cpp
	@@ -44,13 +44,13 @@
	}

	if ( nArg == 1 ) {
	- _mH = 2.0;
	+ m_mH = 2.0;
	} else {
	- _mH = args[1];
	+ m_mH = args[1];
	}
	}

	double EvtBtoXsgammaFixedMass::GetMass( int /Xscode/ )
	{
	- return _mH;
	+ return m_mH;
	}
	diff --git a/src/EvtGenModels/EvtBtoXsgammaFlatEnergy.cpp b/src/EvtGenModels/EvtBtoXsgammaFlatEnergy.cpp
	--- a/src/EvtGenModels/EvtBtoXsgammaFlatEnergy.cpp
	+++ b/src/EvtGenModels/EvtBtoXsgammaFlatEnergy.cpp
	@@ -43,33 +43,33 @@
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- _mB0 = 5.2794;
	+ m_mB0 = 5.2794;
	double mPi = 0.140;
	double mK = 0.494;
	if ( nArg == 1 ) {
	- _eMin = 1.7;
	+ m_eMin = 1.7;
	//Invariant mass of Xsd must be greater the m_pi+m_K leads to
	//Egamma < (m_B2-(m_pi+m_k)2)/(2m_B)
	- _eMax = ( pow( _mB0, 2 ) - pow( mPi + mK, 2 ) ) / ( 2.0 * _mB0 );
	+ m_eMax = ( pow( m_mB0, 2 ) - pow( mPi + mK, 2 ) ) / ( 2.0 * m_mB0 );
	} else {
	- _eMin = args[1];
	- _eMax = args[2];
	+ m_eMin = args[1];
	+ m_eMax = args[2];
	}
	- if ( _eMax > ( pow( _mB0, 2 ) - pow( mPi + mK, 2 ) ) / ( 2.0 * _mB0 ) ) {
	+ if ( m_eMax > ( pow( m_mB0, 2 ) - pow( mPi + mK, 2 ) ) / ( 2.0 * m_mB0 ) ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Emax greater than Kinematic limit" << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Reset to the kinematic limit" << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "(m_B2-(m_pi+m_k)2)/(2m_B)" << endl;
	- _eMax = ( pow( _mB0, 2 ) - pow( mPi + mK, 2 ) ) / ( 2.0 * _mB0 );
	+ m_eMax = ( pow( m_mB0, 2 ) - pow( mPi + mK, 2 ) ) / ( 2.0 * m_mB0 );
	}
	- _eRange = _eMax - _eMin;
	+ m_eRange = m_eMax - m_eMin;
	}

	double EvtBtoXsgammaFlatEnergy::GetMass( int /Xscode/ )
	{
	- double eGamma = EvtRandom::Flat( _eRange ) + _eMin;
	- double mH = sqrt( pow( _mB0, 2 ) - 2.0 * _mB0 * eGamma );
	+ double eGamma = EvtRandom::Flat( m_eRange ) + m_eMin;
	+ double mH = sqrt( pow( m_mB0, 2 ) - 2.0 * m_mB0 * eGamma );
	return mH;
	}
	diff --git a/src/EvtGenModels/EvtBtoXsgammaKagan.cpp b/src/EvtGenModels/EvtBtoXsgammaKagan.cpp
	--- a/src/EvtGenModels/EvtBtoXsgammaKagan.cpp
	+++ b/src/EvtGenModels/EvtBtoXsgammaKagan.cpp
	@@ -44,8 +44,8 @@
	using std::endl;
	using std::fstream;

	-bool EvtBtoXsgammaKagan::bbprod = false;
	-double EvtBtoXsgammaKagan::intervalMH = 0;
	+bool EvtBtoXsgammaKagan::m_bbprod = false;
	+double EvtBtoXsgammaKagan::m_intervalMH = 0;

	void EvtBtoXsgammaKagan::init( int nArg, double* args )
	{
	@@ -62,10 +62,10 @@
	}

	if ( nArg == 1 ) {
	- bbprod = true;
	+ m_bbprod = true;
	getDefaultHadronicMass();
	} else {
	- bbprod = false;
	+ m_bbprod = false;
	computeHadronicMass( nArg, args );
	}

	@@ -73,92 +73,92 @@
	double mHmaxLimit = 4.5;

	if ( nArg > 10 ) {
	- _mHmin = args[10];
	- _mHmax = args[11];
	- if ( _mHmin > _mHmax ) {
	+ m_mHmin = args[10];
	+ m_mHmax = args[11];
	+ if ( m_mHmin > m_mHmax ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Minimum hadronic mass exceeds maximum " << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- if ( _mHmin < mHminLimit ) {
	+ if ( m_mHmin < mHminLimit ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Minimum hadronic mass below K pi threshold" << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Resetting to K pi threshold" << endl;
	- _mHmin = mHminLimit;
	+ m_mHmin = mHminLimit;
	}
	- if ( _mHmax > mHmaxLimit ) {
	+ if ( m_mHmax > mHmaxLimit ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Maximum hadronic mass above 4.5 GeV/c^2" << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Resetting to 4.5 GeV/c^2" << endl;
	- _mHmax = mHmaxLimit;
	+ m_mHmax = mHmaxLimit;
	}
	} else {
	- _mHmin = mHminLimit; // usually just above K pi threshold for Xsd/u
	- _mHmax = mHmaxLimit;
	+ m_mHmin = mHminLimit; // usually just above K pi threshold for Xsd/u
	+ m_mHmax = mHmaxLimit;
	}
	}

	void EvtBtoXsgammaKagan::getDefaultHadronicMass()
	{
	- massHad = { 0, 0.0625995, 0.125199, 0.187798, 0.250398, 0.312997,
	- 0.375597, 0.438196, 0.500796, 0.563395, 0.625995, 0.688594,
	- 0.751194, 0.813793, 0.876392, 0.938992, 1.00159, 1.06419,
	- 1.12679, 1.18939, 1.25199, 1.31459, 1.37719, 1.43979,
	- 1.50239, 1.56499, 1.62759, 1.69019, 1.75278, 1.81538,
	- 1.87798, 1.94058, 2.00318, 2.06578, 2.12838, 2.19098,
	- 2.25358, 2.31618, 2.37878, 2.44138, 2.50398, 2.56658,
	- 2.62918, 2.69178, 2.75438, 2.81698, 2.87958, 2.94217,
	- 3.00477, 3.06737, 3.12997, 3.19257, 3.25517, 3.31777,
	- 3.38037, 3.44297, 3.50557, 3.56817, 3.63077, 3.69337,
	- 3.75597, 3.81857, 3.88117, 3.94377, 4.00637, 4.06896,
	- 4.13156, 4.19416, 4.25676, 4.31936, 4.38196, 4.44456,
	- 4.50716, 4.56976, 4.63236, 4.69496, 4.75756, 4.82016,
	- 4.88276, 4.94536, 5.00796 };
	- brHad = { 0, 1.03244e-09, 3.0239e-08, 1.99815e-07, 7.29392e-07,
	- 1.93129e-06, 4.17806e-06, 7.86021e-06, 1.33421e-05, 2.09196e-05,
	- 3.07815e-05, 4.29854e-05, 5.74406e-05, 7.3906e-05, 9.2003e-05,
	- 0.000111223, 0.000130977, 0.000150618, 0.000169483, 0.000186934,
	- 0.000202392, 0.000215366, 0.000225491, 0.000232496, 0.000236274,
	- 0.000236835, 0.000234313, 0.000228942, 0.000221042, 0.000210994,
	- 0.000199215, 0.000186137, 0.000172194, 0.000157775, 0.000143255,
	- 0.000128952, 0.000115133, 0.000102012, 8.97451e-05, 7.84384e-05,
	- 6.81519e-05, 5.89048e-05, 5.06851e-05, 4.34515e-05, 3.71506e-05,
	- 3.1702e-05, 2.70124e-05, 2.30588e-05, 1.96951e-05, 1.68596e-05,
	- 1.44909e-05, 1.25102e-05, 1.08596e-05, 9.48476e-06, 8.34013e-06,
	- 7.38477e-06, 6.58627e-06, 5.91541e-06, 5.35022e-06, 4.87047e-06,
	- 4.46249e-06, 4.11032e-06, 3.80543e-06, 3.54051e-06, 3.30967e-06,
	- 3.10848e-06, 2.93254e-06, 2.78369e-06, 2.65823e-06, 2.55747e-06,
	- 2.51068e-06, 2.57179e-06, 2.74684e-06, 3.02719e-06, 3.41182e-06,
	- 3.91387e-06, 4.56248e-06, 5.40862e-06, 6.53915e-06, 8.10867e-06,
	- 1.04167e-05 };
	- massHad.resize( 81 );
	- brHad.resize( 81 );
	-
	- intervalMH = 80;
	+ m_massHad = { 0, 0.0625995, 0.125199, 0.187798, 0.250398, 0.312997,
	+ 0.375597, 0.438196, 0.500796, 0.563395, 0.625995, 0.688594,
	+ 0.751194, 0.813793, 0.876392, 0.938992, 1.00159, 1.06419,
	+ 1.12679, 1.18939, 1.25199, 1.31459, 1.37719, 1.43979,
	+ 1.50239, 1.56499, 1.62759, 1.69019, 1.75278, 1.81538,
	+ 1.87798, 1.94058, 2.00318, 2.06578, 2.12838, 2.19098,
	+ 2.25358, 2.31618, 2.37878, 2.44138, 2.50398, 2.56658,
	+ 2.62918, 2.69178, 2.75438, 2.81698, 2.87958, 2.94217,
	+ 3.00477, 3.06737, 3.12997, 3.19257, 3.25517, 3.31777,
	+ 3.38037, 3.44297, 3.50557, 3.56817, 3.63077, 3.69337,
	+ 3.75597, 3.81857, 3.88117, 3.94377, 4.00637, 4.06896,
	+ 4.13156, 4.19416, 4.25676, 4.31936, 4.38196, 4.44456,
	+ 4.50716, 4.56976, 4.63236, 4.69496, 4.75756, 4.82016,
	+ 4.88276, 4.94536, 5.00796 };
	+ m_brHad = { 0, 1.03244e-09, 3.0239e-08, 1.99815e-07, 7.29392e-07,
	+ 1.93129e-06, 4.17806e-06, 7.86021e-06, 1.33421e-05, 2.09196e-05,
	+ 3.07815e-05, 4.29854e-05, 5.74406e-05, 7.3906e-05, 9.2003e-05,
	+ 0.000111223, 0.000130977, 0.000150618, 0.000169483, 0.000186934,
	+ 0.000202392, 0.000215366, 0.000225491, 0.000232496, 0.000236274,
	+ 0.000236835, 0.000234313, 0.000228942, 0.000221042, 0.000210994,
	+ 0.000199215, 0.000186137, 0.000172194, 0.000157775, 0.000143255,
	+ 0.000128952, 0.000115133, 0.000102012, 8.97451e-05, 7.84384e-05,
	+ 6.81519e-05, 5.89048e-05, 5.06851e-05, 4.34515e-05, 3.71506e-05,
	+ 3.1702e-05, 2.70124e-05, 2.30588e-05, 1.96951e-05, 1.68596e-05,
	+ 1.44909e-05, 1.25102e-05, 1.08596e-05, 9.48476e-06, 8.34013e-06,
	+ 7.38477e-06, 6.58627e-06, 5.91541e-06, 5.35022e-06, 4.87047e-06,
	+ 4.46249e-06, 4.11032e-06, 3.80543e-06, 3.54051e-06, 3.30967e-06,
	+ 3.10848e-06, 2.93254e-06, 2.78369e-06, 2.65823e-06, 2.55747e-06,
	+ 2.51068e-06, 2.57179e-06, 2.74684e-06, 3.02719e-06, 3.41182e-06,
	+ 3.91387e-06, 4.56248e-06, 5.40862e-06, 6.53915e-06, 8.10867e-06,
	+ 1.04167e-05 };
	+ m_massHad.resize( 81 );
	+ m_brHad.resize( 81 );
	+
	+ m_intervalMH = 80;
	}

	void EvtBtoXsgammaKagan::computeHadronicMass( int /nArg/, double* args )
	{
	//Input parameters
	int fermiFunction = (int)args[1];
	- _mB = args[2];
	- _mb = args[3];
	- _mu = args[4];
	- _lam1 = args[5];
	- _delta = args[6];
	- _z = args[7];
	- _nIntervalS = args[8];
	- _nIntervalmH = args[9];
	- std::vector<double> mHVect( int( _nIntervalmH + 1.0 ) );
	- massHad.clear();
	- massHad.resize( int( _nIntervalmH + 1.0 ) );
	- brHad.clear();
	- brHad.resize( int( _nIntervalmH + 1.0 ) );
	- intervalMH = _nIntervalmH;
	+ m_mB = args[2];
	+ m_mb = args[3];
	+ m_mu = args[4];
	+ m_lam1 = args[5];
	+ m_delta = args[6];
	+ m_z = args[7];
	+ m_nIntervalS = args[8];
	+ m_nIntervalmH = args[9];
	+ std::vector<double> mHVect( int( m_nIntervalmH + 1.0 ) );
	+ m_massHad.clear();
	+ m_massHad.resize( int( m_nIntervalmH + 1.0 ) );
	+ m_brHad.clear();
	+ m_brHad.resize( int( m_nIntervalmH + 1.0 ) );
	+ m_intervalMH = m_nIntervalmH;

	//Going to have to add a new entry into the data file - takes ages...
	EvtGenReport( EVTGEN_WARNING, "EvtGen" )
	@@ -169,56 +169,56 @@
	//the current parameters

	//A few more parameters
	- double _mubar = _mu;
	- _mW = 80.33;
	- _mt = 175.0;
	- _alpha = 1. / 137.036;
	- _lambdabar = _mB - _mb;
	- _kappabar = 3.382 - 4.14 * ( sqrt( _z ) - 0.29 );
	- _fz = Fz( _z );
	- _rer8 = ( 44. / 9. ) - ( 8. / 27. ) * pow( EvtConst::pi, 2. );
	- _r7 = ( -10. / 3. ) - ( 8. / 9. ) * pow( EvtConst::pi, 2. );
	- _rer2 = -4.092 + 12.78 * ( sqrt( _z ) - .29 );
	- _gam77 = 32. / 3.;
	- _gam27 = 416. / 81.;
	- _gam87 = -32. / 9.;
	- _lam2 = .12;
	- _beta0 = 23. / 3.;
	- _beta1 = 116. / 3.;
	- _alphasmZ = .118;
	- _mZ = 91.187;
	- _ms = _mb / 50.;
	-
	- double eGammaMin = 0.5 * _mB * ( 1. - _delta );
	- double eGammaMax = 0.5 * _mB;
	- double yMin = 2. * eGammaMin / _mB;
	- double yMax = 2. * eGammaMax / _mB;
	+ double _mubar = m_mu;
	+ m_mW = 80.33;
	+ m_mt = 175.0;
	+ m_alpha = 1. / 137.036;
	+ m_lambdabar = m_mB - m_mb;
	+ m_kappabar = 3.382 - 4.14 * ( sqrt( m_z ) - 0.29 );
	+ m_fz = Fz( m_z );
	+ m_rer8 = ( 44. / 9. ) - ( 8. / 27. ) * pow( EvtConst::pi, 2. );
	+ m_r7 = ( -10. / 3. ) - ( 8. / 9. ) * pow( EvtConst::pi, 2. );
	+ m_rer2 = -4.092 + 12.78 * ( sqrt( m_z ) - .29 );
	+ m_gam77 = 32. / 3.;
	+ m_gam27 = 416. / 81.;
	+ m_gam87 = -32. / 9.;
	+ m_lam2 = .12;
	+ m_beta0 = 23. / 3.;
	+ m_beta1 = 116. / 3.;
	+ m_alphasmZ = .118;
	+ m_mZ = 91.187;
	+ m_ms = m_mb / 50.;
	+
	+ double eGammaMin = 0.5 * m_mB * ( 1. - m_delta );
	+ double eGammaMax = 0.5 * m_mB;
	+ double yMin = 2. * eGammaMin / m_mB;
	+ double yMax = 2. * eGammaMax / m_mB;
	double _CKMrat = 0.976;
	double Nsl = 1.0;

	//Calculate alpha the various scales
	- _alphasmW = CalcAlphaS( _mW );
	- _alphasmt = CalcAlphaS( _mt );
	- _alphasmu = CalcAlphaS( _mu );
	- _alphasmubar = CalcAlphaS( _mubar );
	+ m_alphasmW = CalcAlphaS( m_mW );
	+ m_alphasmt = CalcAlphaS( m_mt );
	+ m_alphasmu = CalcAlphaS( m_mu );
	+ m_alphasmubar = CalcAlphaS( _mubar );

	//Calculate the Wilson Coefficients and Delta
	- _etamu = _alphasmW / _alphasmu;
	- _kSLemmu = ( 12. / 23. ) * ( ( 1. / _etamu ) - 1. );
	+ m_etamu = m_alphasmW / m_alphasmu;
	+ m_kSLemmu = ( 12. / 23. ) * ( ( 1. / m_etamu ) - 1. );
	CalcWilsonCoeffs();
	CalcDelta();

	//Build s22 and s27 vector - saves time because double
	//integration is required otherwise
	- std::vector<double> s22Coeffs( int( _nIntervalS + 1.0 ) );
	- std::vector<double> s27Coeffs( int( _nIntervalS + 1.0 ) );
	- std::vector<double> s28Coeffs( int( _nIntervalS + 1.0 ) );
	+ std::vector<double> s22Coeffs( int( m_nIntervalS + 1.0 ) );
	+ std::vector<double> s27Coeffs( int( m_nIntervalS + 1.0 ) );
	+ std::vector<double> s28Coeffs( int( m_nIntervalS + 1.0 ) );

	- double dy = ( yMax - yMin ) / _nIntervalS;
	+ double dy = ( yMax - yMin ) / m_nIntervalS;
	double yp = yMin;

	std::vector<double> sCoeffs( 1 );
	- sCoeffs[0] = _z;
	+ sCoeffs[0] = m_z;

	//Define s22 and s27 functions
	auto mys22Func = EvtItgPtrFunction{ &s22Func, 0., yMax + 0.1, sCoeffs };
	@@ -230,9 +230,9 @@

	int i;

	- for ( i = 0; i < int( _nIntervalS + 1.0 ); i++ ) {
	+ for ( i = 0; i < int( m_nIntervalS + 1.0 ); i++ ) {
	s22Coeffs[i] = ( 16. / 27. ) * mys22Simp.evaluate( 1.0e-20, yp );
	- s27Coeffs[i] = ( -8. / 9. ) * _z * mys27Simp.evaluate( 1.0e-20, yp );
	+ s27Coeffs[i] = ( -8. / 9. ) * m_z * mys27Simp.evaluate( 1.0e-20, yp );
	s28Coeffs[i] = -s27Coeffs[i] / 3.;
	yp = yp + dy;
	}
	@@ -245,16 +245,16 @@
	std::vector<double> s88Coeffs( 2 );
	std::vector<double> sInitCoeffs( 3 );

	- varCoeffs[0] = _mB;
	- varCoeffs[1] = _mb;
	+ varCoeffs[0] = m_mB;
	+ varCoeffs[1] = m_mb;
	varCoeffs[2] = 0.;

	- DeltaCoeffs[0] = _alphasmu;
	+ DeltaCoeffs[0] = m_alphasmu;

	- s88Coeffs[0] = _mb;
	- s88Coeffs[1] = _ms;
	+ s88Coeffs[0] = m_mb;
	+ s88Coeffs[1] = m_ms;

	- sInitCoeffs[0] = _nIntervalS;
	+ sInitCoeffs[0] = m_nIntervalS;
	sInitCoeffs[1] = yMin;
	sInitCoeffs[2] = yMax;

	@@ -277,21 +277,23 @@
	//Calculate quantities for the fermi function to be used
	//Distinguish among the different shape functions
	if ( fermiFunction == 1 ) {
	- FermiCoeffs[1] = _lambdabar;
	- FermiCoeffs[2] = ( -3. * pow( _lambdabar, 2. ) / _lam1 ) - 1.;
	- FermiCoeffs[3] = _lam1;
	+ FermiCoeffs[1] = m_lambdabar;
	+ FermiCoeffs[2] = ( -3. * pow( m_lambdabar, 2. ) / m_lam1 ) - 1.;
	+ FermiCoeffs[3] = m_lam1;
	FermiCoeffs[4] = 1.0;

	auto myNormFunc = std::make_unique<EvtItgPtrFunction>(
	- &EvtBtoXsgammaFermiUtil::FermiExpFunc, -_mb, _mB - _mb, FermiCoeffs );
	+ &EvtBtoXsgammaFermiUtil::FermiExpFunc, -m_mb, m_mB - m_mb,
	+ FermiCoeffs );
	auto myNormSimp =
	std::make_unique<EvtItgSimpsonIntegrator>( *myNormFunc, 1.0e-4, 40 );
	FermiCoeffs[4] = myNormSimp->normalisation();

	} else if ( fermiFunction == 2 ) {
	- double a = EvtBtoXsgammaFermiUtil::FermiGaussFuncRoot( _lambdabar, _lam1,
	- _mb, gammaCoeffs );
	- FermiCoeffs[1] = _lambdabar;
	+ double a = EvtBtoXsgammaFermiUtil::FermiGaussFuncRoot( m_lambdabar,
	+ m_lam1, m_mb,
	+ gammaCoeffs );
	+ FermiCoeffs[1] = m_lambdabar;
	FermiCoeffs[2] = a;
	FermiCoeffs[3] =
	EvtBtoXsgammaFermiUtil::Gamma( ( 2.0 + a ) / 2., gammaCoeffs ) /
	@@ -299,23 +301,23 @@
	FermiCoeffs[4] = 1.0;

	auto myNormFunc = std::make_unique<EvtItgPtrFunction>(
	- &EvtBtoXsgammaFermiUtil::FermiGaussFunc, -_mb, _mB - _mb,
	+ &EvtBtoXsgammaFermiUtil::FermiGaussFunc, -m_mb, m_mB - m_mb,
	FermiCoeffs );
	auto myNormSimp =
	std::make_unique<EvtItgSimpsonIntegrator>( *myNormFunc, 1.0e-4, 40 );
	FermiCoeffs[4] = myNormSimp->normalisation();

	} else if ( fermiFunction == 3 ) {
	- double rho = EvtBtoXsgammaFermiUtil::FermiRomanFuncRoot( _lambdabar,
	- _lam1 );
	- FermiCoeffs[1] = _mB;
	- FermiCoeffs[2] = _mb;
	+ double rho = EvtBtoXsgammaFermiUtil::FermiRomanFuncRoot( m_lambdabar,
	+ m_lam1 );
	+ FermiCoeffs[1] = m_mB;
	+ FermiCoeffs[2] = m_mb;
	FermiCoeffs[3] = rho;
	- FermiCoeffs[4] = _lambdabar;
	+ FermiCoeffs[4] = m_lambdabar;
	FermiCoeffs[5] = 1.0;

	auto myNormFunc = std::make_unique<EvtItgPtrFunction>(
	- &EvtBtoXsgammaFermiUtil::FermiRomanFunc, -_mb, _mB - _mb,
	+ &EvtBtoXsgammaFermiUtil::FermiRomanFunc, -m_mb, m_mB - m_mb,
	FermiCoeffs );
	auto myNormSimp =
	std::make_unique<EvtItgSimpsonIntegrator>( *myNormFunc, 1.0e-4, 40 );
	@@ -323,26 +325,26 @@
	}

	//Define functions
	- auto myDeltaFermiFunc = EvtItgThreeCoeffFcn{ &DeltaFermiFunc, -_mb,
	- _mB - _mb, FermiCoeffs,
	+ auto myDeltaFermiFunc = EvtItgThreeCoeffFcn{ &DeltaFermiFunc, -m_mb,
	+ m_mB - m_mb, FermiCoeffs,
	varCoeffs, DeltaCoeffs };
	- auto mys88FermiFunc = EvtItgThreeCoeffFcn{ &s88FermiFunc, -_mb,
	- _mB - _mb, FermiCoeffs,
	+ auto mys88FermiFunc = EvtItgThreeCoeffFcn{ &s88FermiFunc, -m_mb,
	+ m_mB - m_mb, FermiCoeffs,
	varCoeffs, s88Coeffs };
	- auto mys77FermiFunc = EvtItgTwoCoeffFcn{ &s77FermiFunc, -_mb, _mB - _mb,
	+ auto mys77FermiFunc = EvtItgTwoCoeffFcn{ &s77FermiFunc, -m_mb, m_mB - m_mb,
	FermiCoeffs, varCoeffs };
	- auto mys78FermiFunc = EvtItgTwoCoeffFcn{ &s78FermiFunc, -_mb, _mB - _mb,
	+ auto mys78FermiFunc = EvtItgTwoCoeffFcn{ &s78FermiFunc, -m_mb, m_mB - m_mb,
	FermiCoeffs, varCoeffs };
	- auto mys22FermiFunc = EvtItgFourCoeffFcn{ &sFermiFunc, -_mb,
	- _mB - _mb, FermiCoeffs,
	+ auto mys22FermiFunc = EvtItgFourCoeffFcn{ &sFermiFunc, -m_mb,
	+ m_mB - m_mb, FermiCoeffs,
	varCoeffs, sInitCoeffs,
	s22Coeffs };
	- auto mys27FermiFunc = EvtItgFourCoeffFcn{ &sFermiFunc, -_mb,
	- _mB - _mb, FermiCoeffs,
	+ auto mys27FermiFunc = EvtItgFourCoeffFcn{ &sFermiFunc, -m_mb,
	+ m_mB - m_mb, FermiCoeffs,
	varCoeffs, sInitCoeffs,
	s27Coeffs };
	- auto mys28FermiFunc = EvtItgFourCoeffFcn{ &sFermiFunc, -_mb,
	- _mB - _mb, FermiCoeffs,
	+ auto mys28FermiFunc = EvtItgFourCoeffFcn{ &sFermiFunc, -m_mb,
	+ m_mB - m_mb, FermiCoeffs,
	varCoeffs, sInitCoeffs,
	s28Coeffs };

	@@ -357,15 +359,15 @@
	auto mys28FermiSimp = EvtItgSimpsonIntegrator{ mys28FermiFunc, 1.0e-4, 40 };

	//Finally calculate mHVect for the range of hadronic masses
	- double mHmin = sqrt( _mB * _mB - 2. * _mB * eGammaMax );
	- double mHmax = sqrt( _mB * _mB - 2. * _mB * eGammaMin );
	- double dmH = ( mHmax - mHmin ) / _nIntervalmH;
	+ double mHmin = sqrt( m_mB * m_mB - 2. * m_mB * eGammaMax );
	+ double mHmax = sqrt( m_mB * m_mB - 2. * m_mB * eGammaMin );
	+ double dmH = ( mHmax - mHmin ) / m_nIntervalmH;

	double mH = mHmin;

	//Calculating the Branching Fractions
	- for ( i = 0; i < int( _nIntervalmH + 1.0 ); i++ ) {
	- double ymH = 1. - ( ( mH * mH ) / ( _mB * _mB ) );
	+ for ( i = 0; i < int( m_nIntervalmH + 1.0 ); i++ ) {
	+ double ymH = 1. - ( ( mH * mH ) / ( m_mB * m_mB ) );

	//Need to set ymH as one of the input parameters
	myDeltaFermiFunc.setCoeff( 2, 2, ymH );
	@@ -378,33 +380,33 @@

	//Integrate

	- double deltaResult = myDeltaFermiSimp.evaluate( ( _mB * ymH - _mb ),
	- _mB - _mb );
	- double s77Result = mys77FermiSimp.evaluate( ( _mB * ymH - _mb ),
	- _mB - _mb );
	- double s88Result = mys88FermiSimp.evaluate( ( _mB * ymH - _mb ),
	- _mB - _mb );
	- double s78Result = mys78FermiSimp.evaluate( ( _mB * ymH - _mb ),
	- _mB - _mb );
	- double s22Result = mys22FermiSimp.evaluate( ( _mB * ymH - _mb ),
	- _mB - _mb );
	- double s27Result = mys27FermiSimp.evaluate( ( _mB * ymH - _mb ),
	- _mB - _mb );
	- mys28FermiSimp.evaluate( ( _mB * ymH - _mb ), _mB - _mb );
	+ double deltaResult = myDeltaFermiSimp.evaluate( ( m_mB * ymH - m_mb ),
	+ m_mB - m_mb );
	+ double s77Result = mys77FermiSimp.evaluate( ( m_mB * ymH - m_mb ),
	+ m_mB - m_mb );
	+ double s88Result = mys88FermiSimp.evaluate( ( m_mB * ymH - m_mb ),
	+ m_mB - m_mb );
	+ double s78Result = mys78FermiSimp.evaluate( ( m_mB * ymH - m_mb ),
	+ m_mB - m_mb );
	+ double s22Result = mys22FermiSimp.evaluate( ( m_mB * ymH - m_mb ),
	+ m_mB - m_mb );
	+ double s27Result = mys27FermiSimp.evaluate( ( m_mB * ymH - m_mb ),
	+ m_mB - m_mb );
	+ mys28FermiSimp.evaluate( ( m_mB * ymH - m_mb ), m_mB - m_mb );

	double py =
	- ( pow( _CKMrat, 2. ) * ( 6. / _fz ) * ( _alpha / EvtConst::pi ) *
	- ( deltaResult * _cDeltatot +
	- ( _alphasmu / EvtConst::pi ) *
	- ( s77Result * pow( _c70mu, 2. ) +
	- s27Result * _c2mu * ( _c70mu - _c80mu / 3. ) +
	- s78Result * _c70mu * _c80mu + s22Result * _c2mu * _c2mu +
	- s88Result * _c80mu * _c80mu ) ) );
	+ ( pow( _CKMrat, 2. ) * ( 6. / m_fz ) * ( m_alpha / EvtConst::pi ) *
	+ ( deltaResult * m_cDeltatot +
	+ ( m_alphasmu / EvtConst::pi ) *
	+ ( s77Result * pow( m_c70mu, 2. ) +
	+ s27Result * m_c2mu * ( m_c70mu - m_c80mu / 3. ) +
	+ s78Result * m_c70mu * m_c80mu + s22Result * m_c2mu * m_c2mu +
	+ s88Result * m_c80mu * m_c80mu ) ) );

	- mHVect[i] = 2. * ( mH / ( _mB * _mB ) ) * 0.105 * Nsl * py;
	+ mHVect[i] = 2. * ( mH / ( m_mB * m_mB ) ) * 0.105 * Nsl * py;

	- massHad[i] = mH;
	- brHad[i] = 2. * ( mH / ( _mB * _mB ) ) * 0.105 * Nsl * py;
	+ m_massHad[i] = mH;
	+ m_brHad[i] = 2. * ( mH / ( m_mB * m_mB ) ) * 0.105 * Nsl * py;

	mH = mH + dmH;
	}
	@@ -414,30 +416,32 @@
	{
	// Get hadronic mass for the event according to the hadronic mass spectra computed in computeHadronicMass
	double mass = 0.0;
	- double min = _mHmin;
	- if ( bbprod )
	+ double min = m_mHmin;
	+ if ( m_bbprod )
	min = 1.1;
	// double max=4.5;
	- double max = _mHmax;
	+ double max = m_mHmax;
	double xbox( 0 ), ybox( 0 );
	double boxheight( 0 );
	double trueHeight( 0 );
	double boxwidth = max - min;
	double wgt( 0. );

	- for ( int i = 0; i < int( intervalMH + 1.0 ); i++ ) {
	- if ( brHad[i] > boxheight )
	- boxheight = brHad[i];
	+ for ( int i = 0; i < int( m_intervalMH + 1.0 ); i++ ) {
	+ if ( m_brHad[i] > boxheight )
	+ boxheight = m_brHad[i];
	}
	while ( ( mass > max ) \|\| ( mass < min ) ) {
	xbox = EvtRandom::Flat( boxwidth ) + min;
	ybox = EvtRandom::Flat( boxheight );
	trueHeight = 0.0;
	// Correction by Peter Richardson
	- for ( int i = 1; i < int( intervalMH + 1.0 ); ++i ) {
	- if ( ( massHad[i] >= xbox ) && ( 0.0 == trueHeight ) ) {
	- wgt = ( xbox - massHad[i - 1] ) / ( massHad[i] - massHad[i - 1] );
	- trueHeight = brHad[i - 1] + wgt * ( brHad[i] - brHad[i - 1] );
	+ for ( int i = 1; i < int( m_intervalMH + 1.0 ); ++i ) {
	+ if ( ( m_massHad[i] >= xbox ) && ( 0.0 == trueHeight ) ) {
	+ wgt = ( xbox - m_massHad[i - 1] ) /
	+ ( m_massHad[i] - m_massHad[i - 1] );
	+ trueHeight = m_brHad[i - 1] +
	+ wgt * ( m_brHad[i] - m_brHad[i - 1] );
	}
	}

	@@ -453,24 +457,25 @@

	double EvtBtoXsgammaKagan::CalcAlphaS( double scale )
	{
	- double v = 1. - _beta0 * ( _alphasmZ / ( 2. * EvtConst::pi ) ) *
	- ( log( _mZ / scale ) );
	- return ( _alphasmZ / v ) *
	- ( 1. - ( ( _beta1 / _beta0 ) *
	- ( _alphasmZ / ( 4. * EvtConst::pi ) ) * ( log( v ) / v ) ) );
	+ double v = 1. - m_beta0 * ( m_alphasmZ / ( 2. * EvtConst::pi ) ) *
	+ ( log( m_mZ / scale ) );
	+ return ( m_alphasmZ / v ) *
	+ ( 1. - ( ( m_beta1 / m_beta0 ) *
	+ ( m_alphasmZ / ( 4. * EvtConst::pi ) ) * ( log( v ) / v ) ) );
	}

	void EvtBtoXsgammaKagan::CalcWilsonCoeffs()
	{
	- double mtatmw = _mt * pow( ( _alphasmW / _alphasmt ), ( 12. / 23. ) ) *
	+ double mtatmw = m_mt * pow( ( m_alphasmW / m_alphasmt ), ( 12. / 23. ) ) *
	( 1 +
	( 12. / 23. ) * ( ( 253. / 18. ) - ( 116. / 23. ) ) *
	- ( ( _alphasmW - _alphasmt ) / ( 4.0 * EvtConst::pi ) ) -
	- ( 4. / 3. ) * ( _alphasmt / EvtConst::pi ) );
	- double xt = pow( mtatmw, 2. ) / pow( _mW, 2. );
	+ ( ( m_alphasmW - m_alphasmt ) / ( 4.0 * EvtConst::pi ) ) -
	+ ( 4. / 3. ) * ( m_alphasmt / EvtConst::pi ) );
	+ double xt = pow( mtatmw, 2. ) / pow( m_mW, 2. );

	/////LO
	- _c2mu = .5 * pow( _etamu, ( -12. / 23. ) ) + .5 * pow( _etamu, ( 6. / 23. ) );
	+ m_c2mu = .5 * pow( m_etamu, ( -12. / 23. ) ) +
	+ .5 * pow( m_etamu, ( 6. / 23. ) );

	double c7mWsm = ( ( 3. * pow( xt, 3. ) - 2. * pow( xt, 2. ) ) /
	( 4. * pow( ( xt - 1. ), 4. ) ) ) *
	@@ -483,28 +488,29 @@
	( ( -pow( xt, 3. ) + 5. * pow( xt, 2. ) + 2. * xt ) /
	( 8. * pow( ( xt - 1. ), 3. ) ) );

	- double c7constmu = ( 626126. / 272277. ) * pow( _etamu, ( 14. / 23. ) ) -
	- ( 56281. / 51730. ) * pow( _etamu, ( 16. / 23. ) ) -
	- ( 3. / 7. ) * pow( _etamu, ( 6. / 23. ) ) -
	- ( 1. / 14. ) * pow( _etamu, ( -12. / 23. ) ) -
	- .6494 * pow( _etamu, .4086 ) -
	- .038 * pow( _etamu, -.423 ) -
	- .0186 * pow( _etamu, -.8994 ) -
	- .0057 * pow( _etamu, .1456 );
	-
	- _c70mu = c7mWsm * pow( _etamu, ( 16. / 23. ) ) +
	- ( 8. / 3. ) *
	- ( pow( _etamu, ( 14. / 23. ) ) - pow( _etamu, ( 16. / 23. ) ) ) *
	- c8mWsm +
	- c7constmu;
	-
	- double c8constmu = ( 313063. / 363036. ) * pow( _etamu, ( 14. / 23. ) ) -
	- .9135 * pow( _etamu, .4086 ) +
	- .0873 * pow( _etamu, -.423 ) -
	- .0571 * pow( _etamu, -.8994 ) +
	- .0209 * pow( _etamu, .1456 );
	-
	- _c80mu = c8mWsm * pow( _etamu, ( 14. / 23. ) ) + c8constmu;
	+ double c7constmu = ( 626126. / 272277. ) * pow( m_etamu, ( 14. / 23. ) ) -
	+ ( 56281. / 51730. ) * pow( m_etamu, ( 16. / 23. ) ) -
	+ ( 3. / 7. ) * pow( m_etamu, ( 6. / 23. ) ) -
	+ ( 1. / 14. ) * pow( m_etamu, ( -12. / 23. ) ) -
	+ .6494 * pow( m_etamu, .4086 ) -
	+ .038 * pow( m_etamu, -.423 ) -
	+ .0186 * pow( m_etamu, -.8994 ) -
	+ .0057 * pow( m_etamu, .1456 );
	+
	+ m_c70mu = c7mWsm * pow( m_etamu, ( 16. / 23. ) ) +
	+ ( 8. / 3. ) *
	+ ( pow( m_etamu, ( 14. / 23. ) ) -
	+ pow( m_etamu, ( 16. / 23. ) ) ) *
	+ c8mWsm +
	+ c7constmu;
	+
	+ double c8constmu = ( 313063. / 363036. ) * pow( m_etamu, ( 14. / 23. ) ) -
	+ .9135 * pow( m_etamu, .4086 ) +
	+ .0873 * pow( m_etamu, -.423 ) -
	+ .0571 * pow( m_etamu, -.8994 ) +
	+ .0209 * pow( m_etamu, .1456 );
	+
	+ m_c80mu = c8mWsm * pow( m_etamu, ( 14. / 23. ) ) + c8constmu;

	//Compute the dilogarithm (PolyLog(2,x)) with the Simpson integrator
	//The dilogarithm is defined as: Li_2(x)=Int_0^x(-log(1.-z)/z)
	@@ -577,82 +583,86 @@
	double g8 = .0225;

	double c71constmu =
	- ( ( e1 * _etamu * E1 + f1 + g1 * _etamu ) * pow( _etamu, ( 14. / 23. ) ) +
	- ( e2 * _etamu * E1 + f2 + g2 * _etamu ) * pow( _etamu, ( 16. / 23. ) ) +
	- ( e3 * _etamu * E1 + f3 + g3 * _etamu ) * pow( _etamu, ( 6. / 23. ) ) +
	- ( e4 * _etamu * E1 + f4 + g4 * _etamu ) * pow( _etamu, ( -12. / 23. ) ) +
	- ( e5 * _etamu * E1 + f5 + g5 * _etamu ) * pow( _etamu, .4086 ) +
	- ( e6 * _etamu * E1 + f6 + g6 * _etamu ) * pow( _etamu, ( -.423 ) ) +
	- ( e7 * _etamu * E1 + f7 + g7 * _etamu ) * pow( _etamu, ( -.8994 ) ) +
	- ( e8 * _etamu * E1 + f8 + g8 * _etamu ) * pow( _etamu, .1456 ) );
	-
	- double c71pmu =
	- ( ( ( 297664. / 14283. * pow( _etamu, ( 16. / 23. ) ) -
	- 7164416. / 357075. * pow( _etamu, ( 14. / 23. ) ) +
	- 256868. / 14283. * pow( _etamu, ( 37. / 23. ) ) -
	- 6698884. / 357075. * pow( _etamu, ( 39. / 23. ) ) ) *
	- ( c8mWsm ) ) +
	- 37208. / 4761. *
	- ( pow( _etamu, ( 39. / 23. ) ) - pow( _etamu, ( 16. / 23. ) ) ) *
	- ( c7mWsm ) +
	- c71constmu );
	-
	- _c71mu = ( _alphasmW / _alphasmu *
	- ( pow( _etamu, ( 16. / 23. ) ) * c7mWsm1 +
	- 8. / 3. *
	- ( pow( _etamu, ( 14. / 23. ) ) -
	- pow( _etamu, ( 16. / 23. ) ) ) *
	- c8mWsm1 ) +
	- c71pmu );
	-
	- _c7emmu = ( ( 32. / 75. * pow( _etamu, ( -9. / 23. ) ) -
	- 40. / 69. * pow( _etamu, ( -7. / 23. ) ) +
	- 88. / 575. * pow( _etamu, ( 16. / 23. ) ) ) *
	- c7mWsm +
	- ( -32. / 575. * pow( _etamu, ( -9. / 23. ) ) +
	- 32. / 1449. * pow( _etamu, ( -7. / 23. ) ) +
	- 640. / 1449. * pow( _etamu, ( 14. / 23. ) ) -
	- 704. / 1725. * pow( _etamu, ( 16. / 23. ) ) ) *
	- c8mWsm -
	- 190. / 8073. * pow( _etamu, ( -35. / 23. ) ) -
	- 359. / 3105. * pow( _etamu, ( -17. / 23. ) ) +
	- 4276. / 121095. * pow( _etamu, ( -12. / 23. ) ) +
	- 350531. / 1009125. * pow( _etamu, ( -9. / 23. ) ) +
	- 2. / 4347. * pow( _etamu, ( -7. / 23. ) ) -
	- 5956. / 15525. * pow( _etamu, ( 6. / 23. ) ) +
	- 38380. / 169533. * pow( _etamu, ( 14. / 23. ) ) -
	- 748. / 8625. * pow( _etamu, ( 16. / 23. ) ) );
	+ ( ( e1 * m_etamu * E1 + f1 + g1 * m_etamu ) *
	+ pow( m_etamu, ( 14. / 23. ) ) +
	+ ( e2 * m_etamu * E1 + f2 + g2 * m_etamu ) *
	+ pow( m_etamu, ( 16. / 23. ) ) +
	+ ( e3 * m_etamu * E1 + f3 + g3 * m_etamu ) * pow( m_etamu, ( 6. / 23. ) ) +
	+ ( e4 * m_etamu * E1 + f4 + g4 * m_etamu ) *
	+ pow( m_etamu, ( -12. / 23. ) ) +
	+ ( e5 * m_etamu * E1 + f5 + g5 * m_etamu ) * pow( m_etamu, .4086 ) +
	+ ( e6 * m_etamu * E1 + f6 + g6 * m_etamu ) * pow( m_etamu, ( -.423 ) ) +
	+ ( e7 * m_etamu * E1 + f7 + g7 * m_etamu ) * pow( m_etamu, ( -.8994 ) ) +
	+ ( e8 * m_etamu * E1 + f8 + g8 * m_etamu ) * pow( m_etamu, .1456 ) );
	+
	+ double c71pmu = ( ( ( 297664. / 14283. * pow( m_etamu, ( 16. / 23. ) ) -
	+ 7164416. / 357075. * pow( m_etamu, ( 14. / 23. ) ) +
	+ 256868. / 14283. * pow( m_etamu, ( 37. / 23. ) ) -
	+ 6698884. / 357075. * pow( m_etamu, ( 39. / 23. ) ) ) *
	+ ( c8mWsm ) ) +
	+ 37208. / 4761. *
	+ ( pow( m_etamu, ( 39. / 23. ) ) -
	+ pow( m_etamu, ( 16. / 23. ) ) ) *
	+ ( c7mWsm ) +
	+ c71constmu );
	+
	+ m_c71mu = ( m_alphasmW / m_alphasmu *
	+ ( pow( m_etamu, ( 16. / 23. ) ) * c7mWsm1 +
	+ 8. / 3. *
	+ ( pow( m_etamu, ( 14. / 23. ) ) -
	+ pow( m_etamu, ( 16. / 23. ) ) ) *
	+ c8mWsm1 ) +
	+ c71pmu );
	+
	+ m_c7emmu = ( ( 32. / 75. * pow( m_etamu, ( -9. / 23. ) ) -
	+ 40. / 69. * pow( m_etamu, ( -7. / 23. ) ) +
	+ 88. / 575. * pow( m_etamu, ( 16. / 23. ) ) ) *
	+ c7mWsm +
	+ ( -32. / 575. * pow( m_etamu, ( -9. / 23. ) ) +
	+ 32. / 1449. * pow( m_etamu, ( -7. / 23. ) ) +
	+ 640. / 1449. * pow( m_etamu, ( 14. / 23. ) ) -
	+ 704. / 1725. * pow( m_etamu, ( 16. / 23. ) ) ) *
	+ c8mWsm -
	+ 190. / 8073. * pow( m_etamu, ( -35. / 23. ) ) -
	+ 359. / 3105. * pow( m_etamu, ( -17. / 23. ) ) +
	+ 4276. / 121095. * pow( m_etamu, ( -12. / 23. ) ) +
	+ 350531. / 1009125. * pow( m_etamu, ( -9. / 23. ) ) +
	+ 2. / 4347. * pow( m_etamu, ( -7. / 23. ) ) -
	+ 5956. / 15525. * pow( m_etamu, ( 6. / 23. ) ) +
	+ 38380. / 169533. * pow( m_etamu, ( 14. / 23. ) ) -
	+ 748. / 8625. * pow( m_etamu, ( 16. / 23. ) ) );

	// Wilson coefficients values as according to Kagan's program
	- // _c2mu=1.10566;
	- //_c70mu=-0.314292;
	- // _c80mu=-0.148954;
	- // _c71mu=0.480964;
	- // _c7emmu=0.0323219;
	+ // m_c2mu=1.10566;
	+ //m_c70mu=-0.314292;
	+ // m_c80mu=-0.148954;
	+ // m_c71mu=0.480964;
	+ // m_c7emmu=0.0323219;
	}

	void EvtBtoXsgammaKagan::CalcDelta()
	{
	double cDelta77 = ( 1. +
	- ( _alphasmu / ( 2. * EvtConst::pi ) ) *
	- ( _r7 - ( 16. / 3. ) + _gam77 * log( _mb / _mu ) ) +
	- ( ( pow( ( 1. - _z ), 4. ) / _fz ) - 1. ) *
	- ( 6. * _lam2 / pow( _mb, 2. ) ) +
	- ( _alphasmubar / ( 2. * EvtConst::pi ) ) * _kappabar ) *
	- pow( _c70mu, 2. );
	-
	- double cDelta27 = ( ( _alphasmu / ( 2. * EvtConst::pi ) ) *
	- ( _rer2 + _gam27 * log( _mb / _mu ) ) -
	- ( _lam2 / ( 9. * _z * pow( _mb, 2. ) ) ) ) *
	- _c2mu * _c70mu;
	-
	- double cDelta78 = ( _alphasmu / ( 2. * EvtConst::pi ) ) *
	- ( _rer8 + _gam87 * log( _mb / _mu ) ) * _c70mu * _c80mu;
	-
	- _cDeltatot = cDelta77 + cDelta27 + cDelta78 +
	- ( _alphasmu / ( 2. * EvtConst::pi ) ) * _c71mu * _c70mu +
	- ( _alpha / _alphasmu ) *
	- ( 2. * _c7emmu * _c70mu - _kSLemmu * pow( _c70mu, 2. ) );
	+ ( m_alphasmu / ( 2. * EvtConst::pi ) ) *
	+ ( m_r7 - ( 16. / 3. ) + m_gam77 * log( m_mb / m_mu ) ) +
	+ ( ( pow( ( 1. - m_z ), 4. ) / m_fz ) - 1. ) *
	+ ( 6. * m_lam2 / pow( m_mb, 2. ) ) +
	+ ( m_alphasmubar / ( 2. * EvtConst::pi ) ) * m_kappabar ) *
	+ pow( m_c70mu, 2. );
	+
	+ double cDelta27 = ( ( m_alphasmu / ( 2. * EvtConst::pi ) ) *
	+ ( m_rer2 + m_gam27 * log( m_mb / m_mu ) ) -
	+ ( m_lam2 / ( 9. * m_z * pow( m_mb, 2. ) ) ) ) *
	+ m_c2mu * m_c70mu;
	+
	+ double cDelta78 = ( m_alphasmu / ( 2. * EvtConst::pi ) ) *
	+ ( m_rer8 + m_gam87 * log( m_mb / m_mu ) ) * m_c70mu *
	+ m_c80mu;
	+
	+ m_cDeltatot = cDelta77 + cDelta27 + cDelta78 +
	+ ( m_alphasmu / ( 2. * EvtConst::pi ) ) * m_c71mu * m_c70mu +
	+ ( m_alpha / m_alphasmu ) * ( 2. * m_c7emmu * m_c70mu -
	+ m_kSLemmu * pow( m_c70mu, 2. ) );
	}

	double EvtBtoXsgammaKagan::Delta( double y, double alphasMu )
	diff --git a/src/EvtGenModels/EvtBtoXsll.cpp b/src/EvtGenModels/EvtBtoXsll.cpp
	--- a/src/EvtGenModels/EvtBtoXsll.cpp
	+++ b/src/EvtGenModels/EvtBtoXsll.cpp
	@@ -114,26 +114,26 @@
	::abort();
	}

	- _mb = 4.8;
	- _ms = 0.2;
	- _mq = 0.;
	- _pf = 0.41;
	- _mxmin = 1.1;
	+ m_mb = 4.8;
	+ m_ms = 0.2;
	+ m_mq = 0.;
	+ m_pf = 0.41;
	+ m_mxmin = 1.1;
	if ( getNArg() == 4 ) {
	// b-quark mass
	- _mb = getArg( 0 );
	+ m_mb = getArg( 0 );
	// s-quark mass
	- _ms = getArg( 1 );
	+ m_ms = getArg( 1 );
	// spectator quark mass
	- _mq = getArg( 2 );
	+ m_mq = getArg( 2 );
	// Fermi motion parameter
	- _pf = getArg( 3 );
	+ m_pf = getArg( 3 );
	}
	if ( getNArg() == 5 ) {
	- _mxmin = getArg( 4 );
	+ m_mxmin = getArg( 4 );
	}

	- _calcprob = std::make_unique<EvtBtoXsllUtil>();
	+ m_calcprob = std::make_unique<EvtBtoXsllUtil>();

	double ml = EvtPDL::getMeanMass( getDaug( 1 ) );

	@@ -143,21 +143,21 @@
	int nsteps = 100;
	double s = 0.0;
	double smin = 4.0 * ml * ml;
	- double smax = ( _mb - _ms ) * ( _mb - _ms );
	+ double smax = ( m_mb - m_ms ) * ( m_mb - m_ms );
	double probMax = -10000.0;
	double sProbMax = -10.0;
	double uProbMax = -10.0;

	for ( i = 0; i < nsteps; i++ ) {
	s = smin + ( i + 0.002 ) * ( smax - smin ) / (double)nsteps;
	- double prob = _calcprob->dGdsProb( _mb, _ms, ml, s );
	+ double prob = m_calcprob->dGdsProb( m_mb, m_ms, ml, s );
	if ( prob > probMax ) {
	sProbMax = s;
	probMax = prob;
	}
	}

	- _dGdsProbMax = probMax;
	+ m_dGdsProbMax = probMax;

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -171,11 +171,11 @@

	for ( i = 0; i < nsteps; i++ ) {
	s = smin + ( i + 0.002 ) * ( smax - smin ) / (double)nsteps;
	- double umax = sqrt( ( s - ( _mb + _ms ) * ( _mb + _ms ) ) *
	- ( s - ( _mb - _ms ) * ( _mb - _ms ) ) );
	+ double umax = sqrt( ( s - ( m_mb + m_ms ) * ( m_mb + m_ms ) ) *
	+ ( s - ( m_mb - m_ms ) * ( m_mb - m_ms ) ) );
	for ( j = 0; j < nsteps; j++ ) {
	double u = -umax + ( j + 0.002 ) * ( 2.0 * umax ) / (double)nsteps;
	- double prob = _calcprob->dGdsdupProb( _mb, _ms, ml, s, u );
	+ double prob = m_calcprob->dGdsdupProb( m_mb, m_ms, ml, s, u );
	if ( prob > probMax ) {
	sProbMax = s;
	uProbMax = u;
	@@ -184,7 +184,7 @@
	}
	}

	- _dGdsdupProbMax = 2.0 * probMax;
	+ m_dGdsdupProbMax = 2.0 * probMax;

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -229,7 +229,7 @@
	// to threshold as far as JETSET is concerned
	// (JETSET gets caught in an infinite loop)
	// so we choose a lightly larger value for the threshold
	- while ( xhadronMass < _mxmin ) {
	+ while ( xhadronMass < m_mxmin ) {
	im++;

	// Apply Fermi motion and determine effective b-quark mass
	@@ -244,11 +244,11 @@
	double xbox, ybox;

	while ( mb <= 0.0 ) {
	- pb = _calcprob->FermiMomentum( _pf );
	+ pb = m_calcprob->FermiMomentum( m_pf );

	// effective b-quark mass
	- mb = mB * mB + _mq * _mq - 2.0 * mB * sqrt( pb * pb + _mq * _mq );
	- if ( mb > 0. && sqrt( mb ) - _ms < 2.0 * ml )
	+ mb = mB * mB + m_mq * m_mq - 2.0 * mB * sqrt( pb * pb + m_mq * m_mq );
	+ if ( mb > 0. && sqrt( mb ) - m_ms < 2.0 * ml )
	mb = -10.;
	}
	mb = sqrt( mb );
	@@ -259,20 +259,20 @@

	double s = 0.0;
	double smin = 4.0 * ml * ml;
	- double smax = ( mb - _ms ) * ( mb - _ms );
	+ double smax = ( mb - m_ms ) * ( mb - m_ms );

	while ( s == 0.0 ) {
	xbox = EvtRandom::Flat( smin, smax );
	- ybox = EvtRandom::Flat( _dGdsProbMax );
	- double prob = _calcprob->dGdsProb( mb, _ms, ml, xbox );
	+ ybox = EvtRandom::Flat( m_dGdsProbMax );
	+ double prob = m_calcprob->dGdsProb( mb, m_ms, ml, xbox );
	if ( !( prob >= 0.0 ) && !( prob <= 0.0 ) ) {
	- // EvtGenReport(EVTGEN_INFO,"EvtGen") << "nan from dGdsProb " << prob << " " << mb << " " << _ms << " " << ml << " " << xbox << std::endl;
	+ // EvtGenReport(EVTGEN_INFO,"EvtGen") << "nan from dGdsProb " << prob << " " << mb << " " << m_ms << " " << ml << " " << xbox << std::endl;
	}
	if ( ybox < prob )
	s = xbox;
	}

	- // cout << "dGdsProb(s) = " << _calcprob->dGdsProb(mb, _ms, ml, s)
	+ // cout << "dGdsProb(s) = " << m_calcprob->dGdsProb(mb, m_ms, ml, s)
	// << " for s = " << s << endl;

	// two-body decay of b quark at rest into s quark and dilepton pair:
	@@ -281,7 +281,7 @@
	EvtVector4R p4sdilep[2];

	double msdilep[2];
	- msdilep[0] = _ms;
	+ msdilep[0] = m_ms;
	msdilep[1] = sqrt( s );

	EvtGenKine::PhaseSpace( 2, msdilep, p4sdilep, mb );
	@@ -313,18 +313,18 @@

	double u = p4slp.mass2() - p4sln.mass2();

	- ybox = EvtRandom::Flat( _dGdsdupProbMax );
	+ ybox = EvtRandom::Flat( m_dGdsdupProbMax );

	- double prob = _calcprob->dGdsdupProb( mb, _ms, ml, s, u );
	+ double prob = m_calcprob->dGdsdupProb( mb, m_ms, ml, s, u );
	if ( !( prob >= 0.0 ) && !( prob <= 0.0 ) ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "nan from dGdsProb " << prob << " " << mb << " " << _ms
	+ << "nan from dGdsProb " << prob << " " << mb << " " << m_ms
	<< " " << ml << " " << s << " " << u << std::endl;
	}
	- if ( prob > _dGdsdupProbMax && nmsg < 20 ) {
	+ if ( prob > m_dGdsdupProbMax && nmsg < 20 ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "d2gdsdup GT d2gdsdup_max:" << prob << " "
	- << _dGdsdupProbMax << " for s = " << s << " u = " << u
	+ << m_dGdsdupProbMax << " for s = " << s << " u = " << u
	<< " mb = " << mb << endl;
	nmsg++;
	}
	@@ -368,7 +368,7 @@

	// spectator quark in B meson rest frame

	- EvtVector4R p4q( sqrt( pb * pb + _mq * _mq ), -p4b.get( 1 ),
	+ EvtVector4R p4q( sqrt( pb * pb + m_mq * m_mq ), -p4b.get( 1 ),
	-p4b.get( 2 ), -p4b.get( 3 ) );

	// hadron system in B meson rest frame
	diff --git a/src/EvtGenModels/EvtCBTo3piMPP.cpp b/src/EvtGenModels/EvtCBTo3piMPP.cpp
	--- a/src/EvtGenModels/EvtCBTo3piMPP.cpp
	+++ b/src/EvtGenModels/EvtCBTo3piMPP.cpp
	@@ -58,8 +58,8 @@
	int iset( 10000 );
	double realA, imgA, realbarA, imgbarA;

	- generator.Evt3piMPP( alpha, iset, p4[0], p4[1], p4[2], realA, imgA,
	- realbarA, imgbarA );
	+ m_generator.Evt3piMPP( alpha, iset, p4[0], p4[1], p4[2], realA, imgA,
	+ realbarA, imgbarA );
	}

	void EvtCBTo3piMPP::initProbMax()
	@@ -86,8 +86,8 @@
	int iset( 0 );
	double realA, imgA, realbarA, imgbarA;

	- generator.Evt3piMPP( alpha, iset, p4[0], p4[1], p4[2], realA, imgA,
	- realbarA, imgbarA );
	+ m_generator.Evt3piMPP( alpha, iset, p4[0], p4[1], p4[2], realA, imgA,
	+ realbarA, imgbarA );

	pi1->init( getDaug( 0 ), p4[0] );
	pi2->init( getDaug( 1 ), p4[1] );
	diff --git a/src/EvtGenModels/EvtCBTo3piP00.cpp b/src/EvtGenModels/EvtCBTo3piP00.cpp
	--- a/src/EvtGenModels/EvtCBTo3piP00.cpp
	+++ b/src/EvtGenModels/EvtCBTo3piP00.cpp
	@@ -56,8 +56,8 @@
	EvtVector4R pin, p4pi1, p4Gamma11, p4Gamma12;
	EvtVector4R p4Gamma21, p4Gamma22;
	double realA, imgA, realbarA, imgbarA;
	- generator.Evt3piP00( alpha, iset, pin, p4Gamma11, p4Gamma12, p4Gamma21,
	- p4Gamma22, realA, imgA, realbarA, imgbarA );
	+ m_generator.Evt3piP00( alpha, iset, pin, p4Gamma11, p4Gamma12, p4Gamma21,
	+ p4Gamma22, realA, imgA, realbarA, imgbarA );
	}

	void EvtCBTo3piP00::initProbMax()
	@@ -86,8 +86,8 @@
	EvtVector4R p4Gamma21, p4Gamma22;

	double realA, imgA, realbarA, imgbarA;
	- generator.Evt3piP00( alpha, iset, p4[0], p4Gamma11, p4Gamma12, p4Gamma21,
	- p4Gamma22, realA, imgA, realbarA, imgbarA );
	+ m_generator.Evt3piP00( alpha, iset, p4[0], p4Gamma11, p4Gamma12, p4Gamma21,
	+ p4Gamma22, realA, imgA, realbarA, imgbarA );

	p4[1] = p4Gamma11 + p4Gamma12;
	p4[2] = p4Gamma21 + p4Gamma22;
	diff --git a/src/EvtGenModels/EvtD0gammaDalitz.cpp b/src/EvtGenModels/EvtD0gammaDalitz.cpp
	--- a/src/EvtGenModels/EvtD0gammaDalitz.cpp
	+++ b/src/EvtGenModels/EvtD0gammaDalitz.cpp
	@@ -36,23 +36,24 @@
	#include <string>

	// Initialize the static variables.
	-const EvtSpinType::spintype& EvtD0gammaDalitz::_SCALAR = EvtSpinType::SCALAR;
	-const EvtSpinType::spintype& EvtD0gammaDalitz::_VECTOR = EvtSpinType::VECTOR;
	-const EvtSpinType::spintype& EvtD0gammaDalitz::_TENSOR = EvtSpinType::TENSOR;
	+const EvtSpinType::spintype& EvtD0gammaDalitz::m_SCALAR = EvtSpinType::SCALAR;
	+const EvtSpinType::spintype& EvtD0gammaDalitz::m_VECTOR = EvtSpinType::VECTOR;
	+const EvtSpinType::spintype& EvtD0gammaDalitz::m_TENSOR = EvtSpinType::TENSOR;

	-const EvtDalitzReso::CouplingType& EvtD0gammaDalitz::_EtaPic =
	+const EvtDalitzReso::CouplingType& EvtD0gammaDalitz::m_EtaPic =
	EvtDalitzReso::EtaPic;
	-const EvtDalitzReso::CouplingType& EvtD0gammaDalitz::_PicPicKK =
	+const EvtDalitzReso::CouplingType& EvtD0gammaDalitz::m_PicPicKK =
	EvtDalitzReso::PicPicKK;

	-const EvtDalitzReso::NumType& EvtD0gammaDalitz::_RBW =
	+const EvtDalitzReso::NumType& EvtD0gammaDalitz::m_RBW =
	EvtDalitzReso::RBW_CLEO_ZEMACH;
	-const EvtDalitzReso::NumType& EvtD0gammaDalitz::_GS = EvtDalitzReso::GS_CLEO_ZEMACH;
	-const EvtDalitzReso::NumType& EvtD0gammaDalitz::_KMAT = EvtDalitzReso::K_MATRIX;
	+const EvtDalitzReso::NumType& EvtD0gammaDalitz::m_GS =
	+ EvtDalitzReso::GS_CLEO_ZEMACH;
	+const EvtDalitzReso::NumType& EvtD0gammaDalitz::m_KMAT = EvtDalitzReso::K_MATRIX;

	-const EvtCyclic3::Pair& EvtD0gammaDalitz::_AB = EvtCyclic3::AB;
	-const EvtCyclic3::Pair& EvtD0gammaDalitz::_AC = EvtCyclic3::AC;
	-const EvtCyclic3::Pair& EvtD0gammaDalitz::_BC = EvtCyclic3::BC;
	+const EvtCyclic3::Pair& EvtD0gammaDalitz::m_AB = EvtCyclic3::AB;
	+const EvtCyclic3::Pair& EvtD0gammaDalitz::m_AC = EvtCyclic3::AC;
	+const EvtCyclic3::Pair& EvtD0gammaDalitz::m_BC = EvtCyclic3::BC;

	std::string EvtD0gammaDalitz::getName()
	{
	@@ -71,10 +72,10 @@

	// Check that this model is valid for the specified decay.
	checkNDaug( 3 );
	- checkSpinParent( _SCALAR );
	- checkSpinDaughter( 0, _SCALAR );
	- checkSpinDaughter( 1, _SCALAR );
	- checkSpinDaughter( 2, _SCALAR );
	+ checkSpinParent( m_SCALAR );
	+ checkSpinDaughter( 0, m_SCALAR );
	+ checkSpinDaughter( 1, m_SCALAR );
	+ checkSpinDaughter( 2, m_SCALAR );

	// Get the values of the EvtId objects from the data files.
	readPDGValues();
	@@ -89,22 +90,22 @@

	// Look for K0bar h+ h-. The order will be K[0SL] h+ h-
	for ( int index = 0; index < 3; index++ ) {
	- if ( ( dau[index] == _K0B ) \|\| ( dau[index] == _KS ) \|\|
	- ( dau[index] == _KL ) ) {
	- _d1 = index;
	- } else if ( ( dau[index] == _PIP ) \|\| ( dau[index] == _KP ) ) {
	- _d2 = index;
	- } else if ( ( dau[index] == _PIM ) \|\| ( dau[index] == _KM ) ) {
	- _d3 = index;
	+ if ( ( dau[index] == m_K0B ) \|\| ( dau[index] == m_KS ) \|\|
	+ ( dau[index] == m_KL ) ) {
	+ m_d1 = index;
	+ } else if ( ( dau[index] == m_PIP ) \|\| ( dau[index] == m_KP ) ) {
	+ m_d2 = index;
	+ } else if ( ( dau[index] == m_PIM ) \|\| ( dau[index] == m_KM ) ) {
	+ m_d3 = index;
	} else {
	reportInvalidAndExit();
	}
	}

	// Check if we're dealing with Ks pi pi or with Ks K K.
	- _isKsPiPi = false;
	- if ( dau[_d2] == _PIP \|\| dau[_d2] == _PIM ) {
	- _isKsPiPi = true;
	+ m_isKsPiPi = false;
	+ if ( dau[m_d2] == m_PIP \|\| dau[m_d2] == m_PIM ) {
	+ m_isKsPiPi = true;
	}
	}

	@@ -122,9 +123,9 @@
	EvtDecayTable::getInstance()->getDecayFunc( parent )->getName() ==
	"BTODDALITZCPK" ) {
	EvtId parId = parent->getId();
	- if ( ( parId == _BP ) \|\| ( parId == _BM ) \|\| ( parId == _B0 ) \|\|
	- ( parId == _B0B ) ) {
	- _bFlavor = parId;
	+ if ( ( parId == m_BP ) \|\| ( parId == m_BM ) \|\| ( parId == m_B0 ) \|\|
	+ ( parId == m_B0B ) ) {
	+ m_bFlavor = parId;
	} else {
	reportInvalidAndExit();
	}
	@@ -144,9 +145,9 @@

	// Same structure for all of these decays.
	part->initializePhaseSpace( getNDaug(), getDaugs() );
	- EvtVector4R pA = part->getDaug( _d1 )->getP4();
	- EvtVector4R pB = part->getDaug( _d2 )->getP4();
	- EvtVector4R pC = part->getDaug( _d3 )->getP4();
	+ EvtVector4R pA = part->getDaug( m_d1 )->getP4();
	+ EvtVector4R pB = part->getDaug( m_d2 )->getP4();
	+ EvtVector4R pC = part->getDaug( m_d3 )->getP4();

	// Squared invariant masses.
	double mSqAB = ( pA + pB ).mass2();
	@@ -159,25 +160,25 @@
	EvtComplex ampDir;
	EvtComplex ampCnj;

	- if ( _isKsPiPi ) {
	+ if ( m_isKsPiPi ) {
	// Direct and conjugated Dalitz points.
	- EvtDalitzPoint pointDir( _mKs, _mPi, _mPi, mSqAB, mSqBC, mSqAC );
	- EvtDalitzPoint pointCnj( _mKs, _mPi, _mPi, mSqAC, mSqBC, mSqAB );
	+ EvtDalitzPoint pointDir( m_mKs, m_mPi, m_mPi, mSqAB, mSqBC, mSqAC );
	+ EvtDalitzPoint pointCnj( m_mKs, m_mPi, m_mPi, mSqAC, mSqBC, mSqAB );

	// Direct and conjugated amplitudes.
	ampDir = dalitzKsPiPi( pointDir );
	ampCnj = dalitzKsPiPi( pointCnj );
	} else {
	// Direct and conjugated Dalitz points.
	- EvtDalitzPoint pointDir( _mKs, _mK, _mK, mSqAB, mSqBC, mSqAC );
	- EvtDalitzPoint pointCnj( _mKs, _mK, _mK, mSqAC, mSqBC, mSqAB );
	+ EvtDalitzPoint pointDir( m_mKs, m_mK, m_mK, mSqAB, mSqBC, mSqAC );
	+ EvtDalitzPoint pointCnj( m_mKs, m_mK, m_mK, mSqAC, mSqBC, mSqAB );

	// Direct and conjugated amplitudes.
	ampDir = dalitzKsKK( pointDir );
	ampCnj = dalitzKsKK( pointCnj );
	}

	- if ( _bFlavor == _BP \|\| _bFlavor == _B0 ) {
	+ if ( m_bFlavor == m_BP \|\| m_bFlavor == m_B0 ) {
	amp = ampCnj + rB * exp( EvtComplex( 0., delta + gamma ) ) * ampDir;
	} else {
	amp = ampDir + rB * exp( EvtComplex( 0., delta - gamma ) ) * ampCnj;
	@@ -190,35 +191,38 @@

	EvtComplex EvtD0gammaDalitz::dalitzKsPiPi( const EvtDalitzPoint& point ) const
	{
	- static const EvtDalitzPlot plot( _mKs, _mPi, _mPi, _mD0 );
	+ static const EvtDalitzPlot plot( m_mKs, m_mPi, m_mPi, m_mD0 );

	EvtComplex amp = 0.;

	// This corresponds to relativistic Breit-Wigner distributions. Not K-matrix.
	// Defining resonances.
	- static EvtDalitzReso KStarm( plot, _BC, _AC, _VECTOR, 0.893606, 0.0463407,
	- _RBW );
	- static EvtDalitzReso KStarp( plot, _BC, _AB, _VECTOR, 0.893606, 0.0463407,
	- _RBW );
	- static EvtDalitzReso rho0( plot, _AC, _BC, _VECTOR, 0.7758, 0.1464, _GS );
	- static EvtDalitzReso omega( plot, _AC, _BC, _VECTOR, 0.78259, 0.00849, _RBW );
	- static EvtDalitzReso f0_980( plot, _AC, _BC, _SCALAR, 0.975, 0.044, _RBW );
	- static EvtDalitzReso f0_1370( plot, _AC, _BC, _SCALAR, 1.434, 0.173, _RBW );
	- static EvtDalitzReso f2_1270( plot, _AC, _BC, _TENSOR, 1.2754, 0.1851, _RBW );
	- static EvtDalitzReso K0Starm_1430( plot, _BC, _AC, _SCALAR, 1.459, 0.175,
	- _RBW );
	- static EvtDalitzReso K0Starp_1430( plot, _BC, _AB, _SCALAR, 1.459, 0.175,
	- _RBW );
	- static EvtDalitzReso K2Starm_1430( plot, _BC, _AC, _TENSOR, 1.4256, 0.0985,
	- _RBW );
	- static EvtDalitzReso K2Starp_1430( plot, _BC, _AB, _TENSOR, 1.4256, 0.0985,
	- _RBW );
	- static EvtDalitzReso sigma( plot, _AC, _BC, _SCALAR, 0.527699, 0.511861,
	- _RBW );
	- static EvtDalitzReso sigma2( plot, _AC, _BC, _SCALAR, 1.03327, 0.0987890,
	- _RBW );
	- static EvtDalitzReso KStarm_1680( plot, _BC, _AC, _VECTOR, 1.677, 0.205,
	- _RBW );
	+ static EvtDalitzReso KStarm( plot, m_BC, m_AC, m_VECTOR, 0.893606,
	+ 0.0463407, m_RBW );
	+ static EvtDalitzReso KStarp( plot, m_BC, m_AB, m_VECTOR, 0.893606,
	+ 0.0463407, m_RBW );
	+ static EvtDalitzReso rho0( plot, m_AC, m_BC, m_VECTOR, 0.7758, 0.1464, m_GS );
	+ static EvtDalitzReso omega( plot, m_AC, m_BC, m_VECTOR, 0.78259, 0.00849,
	+ m_RBW );
	+ static EvtDalitzReso f0_980( plot, m_AC, m_BC, m_SCALAR, 0.975, 0.044, m_RBW );
	+ static EvtDalitzReso f0_1370( plot, m_AC, m_BC, m_SCALAR, 1.434, 0.173,
	+ m_RBW );
	+ static EvtDalitzReso f2_1270( plot, m_AC, m_BC, m_TENSOR, 1.2754, 0.1851,
	+ m_RBW );
	+ static EvtDalitzReso K0Starm_1430( plot, m_BC, m_AC, m_SCALAR, 1.459, 0.175,
	+ m_RBW );
	+ static EvtDalitzReso K0Starp_1430( plot, m_BC, m_AB, m_SCALAR, 1.459, 0.175,
	+ m_RBW );
	+ static EvtDalitzReso K2Starm_1430( plot, m_BC, m_AC, m_TENSOR, 1.4256,
	+ 0.0985, m_RBW );
	+ static EvtDalitzReso K2Starp_1430( plot, m_BC, m_AB, m_TENSOR, 1.4256,
	+ 0.0985, m_RBW );
	+ static EvtDalitzReso sigma( plot, m_AC, m_BC, m_SCALAR, 0.527699, 0.511861,
	+ m_RBW );
	+ static EvtDalitzReso sigma2( plot, m_AC, m_BC, m_SCALAR, 1.03327, 0.0987890,
	+ m_RBW );
	+ static EvtDalitzReso KStarm_1680( plot, m_BC, m_AC, m_VECTOR, 1.677, 0.205,
	+ m_RBW );

	// Adding terms to the amplitude with their corresponding amplitude and phase terms.
	amp += EvtComplex( .848984, .893618 );
	@@ -242,23 +246,28 @@

	EvtComplex EvtD0gammaDalitz::dalitzKsKK( const EvtDalitzPoint& point ) const
	{
	- static const EvtDalitzPlot plot( _mKs, _mK, _mK, _mD0 );
	+ static const EvtDalitzPlot plot( m_mKs, m_mK, m_mK, m_mD0 );

	// Defining resonances.
	- static EvtDalitzReso a00_980( plot, _AC, _BC, _SCALAR, 0.999, _RBW, .550173,
	- .324, _EtaPic );
	- static EvtDalitzReso phi( plot, _AC, _BC, _VECTOR, 1.01943, .00459319, _RBW );
	- static EvtDalitzReso a0p_980( plot, _AC, _AB, _SCALAR, 0.999, _RBW, .550173,
	- .324, _EtaPic );
	- static EvtDalitzReso f0_1370( plot, _AC, _BC, _SCALAR, 1.350, .265, _RBW );
	- static EvtDalitzReso a0m_980( plot, _AB, _AC, _SCALAR, 0.999, _RBW, .550173,
	- .324, _EtaPic );
	- static EvtDalitzReso f0_980( plot, _AC, _BC, _SCALAR, 0.965, _RBW, .695,
	- .165, _PicPicKK );
	- static EvtDalitzReso f2_1270( plot, _AC, _BC, _TENSOR, 1.2754, .1851, _RBW );
	- static EvtDalitzReso a00_1450( plot, _AC, _BC, _SCALAR, 1.474, .265, _RBW );
	- static EvtDalitzReso a0p_1450( plot, _AC, _AB, _SCALAR, 1.474, .265, _RBW );
	- static EvtDalitzReso a0m_1450( plot, _AB, _AC, _SCALAR, 1.474, .265, _RBW );
	+ static EvtDalitzReso a00_980( plot, m_AC, m_BC, m_SCALAR, 0.999, m_RBW,
	+ .550173, .324, m_EtaPic );
	+ static EvtDalitzReso phi( plot, m_AC, m_BC, m_VECTOR, 1.01943, .00459319,
	+ m_RBW );
	+ static EvtDalitzReso a0p_980( plot, m_AC, m_AB, m_SCALAR, 0.999, m_RBW,
	+ .550173, .324, m_EtaPic );
	+ static EvtDalitzReso f0_1370( plot, m_AC, m_BC, m_SCALAR, 1.350, .265, m_RBW );
	+ static EvtDalitzReso a0m_980( plot, m_AB, m_AC, m_SCALAR, 0.999, m_RBW,
	+ .550173, .324, m_EtaPic );
	+ static EvtDalitzReso f0_980( plot, m_AC, m_BC, m_SCALAR, 0.965, m_RBW, .695,
	+ .165, m_PicPicKK );
	+ static EvtDalitzReso f2_1270( plot, m_AC, m_BC, m_TENSOR, 1.2754, .1851,
	+ m_RBW );
	+ static EvtDalitzReso a00_1450( plot, m_AC, m_BC, m_SCALAR, 1.474, .265,
	+ m_RBW );
	+ static EvtDalitzReso a0p_1450( plot, m_AC, m_AB, m_SCALAR, 1.474, .265,
	+ m_RBW );
	+ static EvtDalitzReso a0m_1450( plot, m_AB, m_AC, m_SCALAR, 1.474, .265,
	+ m_RBW );

	// Adding terms to the amplitude with their corresponding amplitude and phase terms.
	EvtComplex amp( 0., 0. ); // Phase space amplitude.
	@@ -280,26 +289,26 @@
	void EvtD0gammaDalitz::readPDGValues()
	{
	// Define the EvtIds.
	- _BP = EvtPDL::getId( "B+" );
	- _BM = EvtPDL::getId( "B-" );
	- _B0 = EvtPDL::getId( "B0" );
	- _B0B = EvtPDL::getId( "anti-B0" );
	- _D0 = EvtPDL::getId( "D0" );
	- _D0B = EvtPDL::getId( "anti-D0" );
	- _KM = EvtPDL::getId( "K-" );
	- _KP = EvtPDL::getId( "K+" );
	- _K0 = EvtPDL::getId( "K0" );
	- _K0B = EvtPDL::getId( "anti-K0" );
	- _KL = EvtPDL::getId( "K_L0" );
	- _KS = EvtPDL::getId( "K_S0" );
	- _PIM = EvtPDL::getId( "pi-" );
	- _PIP = EvtPDL::getId( "pi+" );
	+ m_BP = EvtPDL::getId( "B+" );
	+ m_BM = EvtPDL::getId( "B-" );
	+ m_B0 = EvtPDL::getId( "B0" );
	+ m_B0B = EvtPDL::getId( "anti-B0" );
	+ m_D0 = EvtPDL::getId( "D0" );
	+ m_D0B = EvtPDL::getId( "anti-D0" );
	+ m_KM = EvtPDL::getId( "K-" );
	+ m_KP = EvtPDL::getId( "K+" );
	+ m_K0 = EvtPDL::getId( "K0" );
	+ m_K0B = EvtPDL::getId( "anti-K0" );
	+ m_KL = EvtPDL::getId( "K_L0" );
	+ m_KS = EvtPDL::getId( "K_S0" );
	+ m_PIM = EvtPDL::getId( "pi-" );
	+ m_PIP = EvtPDL::getId( "pi+" );

	// Read the relevant masses.
	- _mD0 = EvtPDL::getMass( _D0 );
	- _mKs = EvtPDL::getMass( _KS );
	- _mPi = EvtPDL::getMass( _PIP );
	- _mK = EvtPDL::getMass( _KP );
	+ m_mD0 = EvtPDL::getMass( m_D0 );
	+ m_mKs = EvtPDL::getMass( m_KS );
	+ m_mPi = EvtPDL::getMass( m_PIP );
	+ m_mK = EvtPDL::getMass( m_KP );
	}

	void EvtD0gammaDalitz::reportInvalidAndExit() const
	diff --git a/src/EvtGenModels/EvtD0mixDalitz.cpp b/src/EvtGenModels/EvtD0mixDalitz.cpp
	--- a/src/EvtGenModels/EvtD0mixDalitz.cpp
	+++ b/src/EvtGenModels/EvtD0mixDalitz.cpp
	@@ -31,21 +31,22 @@
	#include <cmath> // for std::fabs

	// Initialize the static variables.
	-const EvtSpinType::spintype& EvtD0mixDalitz::_SCALAR = EvtSpinType::SCALAR;
	-const EvtSpinType::spintype& EvtD0mixDalitz::_VECTOR = EvtSpinType::VECTOR;
	-const EvtSpinType::spintype& EvtD0mixDalitz::_TENSOR = EvtSpinType::TENSOR;
	+const EvtSpinType::spintype& EvtD0mixDalitz::m_SCALAR = EvtSpinType::SCALAR;
	+const EvtSpinType::spintype& EvtD0mixDalitz::m_VECTOR = EvtSpinType::VECTOR;
	+const EvtSpinType::spintype& EvtD0mixDalitz::m_TENSOR = EvtSpinType::TENSOR;

	-const EvtDalitzReso::CouplingType& EvtD0mixDalitz::_EtaPic = EvtDalitzReso::EtaPic;
	-const EvtDalitzReso::CouplingType& EvtD0mixDalitz::_PicPicKK =
	+const EvtDalitzReso::CouplingType& EvtD0mixDalitz::m_EtaPic = EvtDalitzReso::EtaPic;
	+const EvtDalitzReso::CouplingType& EvtD0mixDalitz::m_PicPicKK =
	EvtDalitzReso::PicPicKK;

	-const EvtDalitzReso::NumType& EvtD0mixDalitz::_RBW = EvtDalitzReso::RBW_CLEO_ZEMACH;
	-const EvtDalitzReso::NumType& EvtD0mixDalitz::_GS = EvtDalitzReso::GS_CLEO_ZEMACH;
	-const EvtDalitzReso::NumType& EvtD0mixDalitz::_KMAT = EvtDalitzReso::K_MATRIX;
	+const EvtDalitzReso::NumType& EvtD0mixDalitz::m_RBW =
	+ EvtDalitzReso::RBW_CLEO_ZEMACH;
	+const EvtDalitzReso::NumType& EvtD0mixDalitz::m_GS = EvtDalitzReso::GS_CLEO_ZEMACH;
	+const EvtDalitzReso::NumType& EvtD0mixDalitz::m_KMAT = EvtDalitzReso::K_MATRIX;

	-const EvtCyclic3::Pair& EvtD0mixDalitz::_AB = EvtCyclic3::AB;
	-const EvtCyclic3::Pair& EvtD0mixDalitz::_AC = EvtCyclic3::AC;
	-const EvtCyclic3::Pair& EvtD0mixDalitz::_BC = EvtCyclic3::BC;
	+const EvtCyclic3::Pair& EvtD0mixDalitz::m_AB = EvtCyclic3::AB;
	+const EvtCyclic3::Pair& EvtD0mixDalitz::m_AC = EvtCyclic3::AC;
	+const EvtCyclic3::Pair& EvtD0mixDalitz::m_BC = EvtCyclic3::BC;

	void EvtD0mixDalitz::init()
	{
	@@ -54,17 +55,17 @@

	if ( getNArg() ) {
	if ( getNArg() == 2 ) {
	- _x = getArg( 0 );
	- _y = getArg( 1 );
	+ m_x = getArg( 0 );
	+ m_y = getArg( 1 );
	} else if ( getNArg() == 4 ) {
	- _x = getArg( 0 );
	- _y = getArg( 1 );
	- _qp = EvtComplex( getArg( 2 ), getArg( 3 ) );
	+ m_x = getArg( 0 );
	+ m_y = getArg( 1 );
	+ m_qp = EvtComplex( getArg( 2 ), getArg( 3 ) );
	} else if ( getNArg() == 5 ) {
	- _x = getArg( 0 );
	- _y = getArg( 1 );
	- _qp = EvtComplex( getArg( 2 ), getArg( 3 ) );
	- _isRBWmodel = !getArg(
	+ m_x = getArg( 0 );
	+ m_y = getArg( 1 );
	+ m_qp = EvtComplex( getArg( 2 ), getArg( 3 ) );
	+ m_isRBWmodel = !getArg(
	4 ); // RBW by default. If arg4 is set, do K-matrix.
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtD0mixDalitz" )
	@@ -76,10 +77,10 @@
	}
	}

	- checkSpinParent( _SCALAR );
	- checkSpinDaughter( 0, _SCALAR );
	- checkSpinDaughter( 1, _SCALAR );
	- checkSpinDaughter( 2, _SCALAR );
	+ checkSpinParent( m_SCALAR );
	+ checkSpinDaughter( 0, m_SCALAR );
	+ checkSpinDaughter( 1, m_SCALAR );
	+ checkSpinDaughter( 2, m_SCALAR );

	readPDGValues();

	@@ -90,53 +91,53 @@
	for ( int index = 0; index < 3; index++ )
	dau[index] = getDaug( index );

	- if ( parId == _D0 ) // Look for K0bar h+ h-. The order must be K[0SL] h+ h-
	+ if ( parId == m_D0 ) // Look for K0bar h+ h-. The order must be K[0SL] h+ h-
	for ( int index = 0; index < 3; index++ )
	- if ( ( dau[index] == _K0B ) \|\| ( dau[index] == _KS ) \|\|
	- ( dau[index] == _KL ) )
	- _d1 = index;
	- else if ( ( dau[index] == _PIP ) \|\| ( dau[index] == _KP ) )
	- _d2 = index;
	- else if ( ( dau[index] == _PIM ) \|\| ( dau[index] == _KM ) )
	- _d3 = index;
	+ if ( ( dau[index] == m_K0B ) \|\| ( dau[index] == m_KS ) \|\|
	+ ( dau[index] == m_KL ) )
	+ m_d1 = index;
	+ else if ( ( dau[index] == m_PIP ) \|\| ( dau[index] == m_KP ) )
	+ m_d2 = index;
	+ else if ( ( dau[index] == m_PIM ) \|\| ( dau[index] == m_KM ) )
	+ m_d3 = index;
	else
	reportInvalidAndExit();
	- else if ( parId == _D0B ) // Look for K0 h+ h-. The order must be K[0SL] h- h+
	+ else if ( parId == m_D0B ) // Look for K0 h+ h-. The order must be K[0SL] h- h+
	for ( int index = 0; index < 3; index++ )
	- if ( ( dau[index] == _K0 ) \|\| ( dau[index] == _KS ) \|\|
	- ( dau[index] == _KL ) )
	- _d1 = index;
	- else if ( ( dau[index] == _PIM ) \|\| ( dau[index] == _KM ) )
	- _d2 = index;
	- else if ( ( dau[index] == _PIP ) \|\| ( dau[index] == _KP ) )
	- _d3 = index;
	+ if ( ( dau[index] == m_K0 ) \|\| ( dau[index] == m_KS ) \|\|
	+ ( dau[index] == m_KL ) )
	+ m_d1 = index;
	+ else if ( ( dau[index] == m_PIM ) \|\| ( dau[index] == m_KM ) )
	+ m_d2 = index;
	+ else if ( ( dau[index] == m_PIP ) \|\| ( dau[index] == m_KP ) )
	+ m_d3 = index;
	else
	reportInvalidAndExit();
	else
	reportInvalidAndExit();

	// If the D meson is a D0bar, the expressions should use p/q instead of q/p.
	- if ( parId == _D0B )
	- _qp = 1.0 / _qp;
	+ if ( parId == m_D0B )
	+ m_qp = 1.0 / m_qp;

	// At this point, if parId is D0bar, the amplitude is the D0bar amplitude, the conjugated amplitude
	- // is the amplitude of the D0 decay, and _qp means p/q, so it is like changing the meaning of
	+ // is the amplitude of the D0 decay, and m_qp means p/q, so it is like changing the meaning of
	// A <-> Abar, and p <-> q. It is just a trick so after this point the code for D0bar can be the
	// same as the code for D0.

	// Check if we're dealing with Ks pi pi or with Ks K K.
	- _isKsPiPi = false;
	- if ( dau[_d2] == _PIP \|\| dau[_d2] == _PIM )
	- _isKsPiPi = true;
	+ m_isKsPiPi = false;
	+ if ( dau[m_d2] == m_PIP \|\| dau[m_d2] == m_PIM )
	+ m_isKsPiPi = true;
	}

	void EvtD0mixDalitz::decay( EvtParticle* part )
	{
	// Same structure for all of these decays.
	part->initializePhaseSpace( getNDaug(), getDaugs() );
	- EvtVector4R pA = part->getDaug( _d1 )->getP4();
	- EvtVector4R pB = part->getDaug( _d2 )->getP4();
	- EvtVector4R pC = part->getDaug( _d3 )->getP4();
	+ EvtVector4R pA = part->getDaug( m_d1 )->getP4();
	+ EvtVector4R pB = part->getDaug( m_d2 )->getP4();
	+ EvtVector4R pC = part->getDaug( m_d3 )->getP4();

	// Squared invariant masses.
	double m2AB = ( pA + pB ).mass2();
	@@ -147,15 +148,15 @@
	EvtComplex ampDalitz;
	EvtComplex ampAntiDalitz;

	- if ( _isKsPiPi ) { // For Ks pi pi
	- EvtDalitzPoint point( _mKs, _mPi, _mPi, m2AB, m2BC, m2AC );
	- EvtDalitzPoint antiPoint( _mKs, _mPi, _mPi, m2AC, m2BC, m2AB );
	+ if ( m_isKsPiPi ) { // For Ks pi pi
	+ EvtDalitzPoint point( m_mKs, m_mPi, m_mPi, m2AB, m2BC, m2AC );
	+ EvtDalitzPoint antiPoint( m_mKs, m_mPi, m_mPi, m2AC, m2BC, m2AB );

	ampDalitz = dalitzKsPiPi( point );
	ampAntiDalitz = dalitzKsPiPi( antiPoint );
	} else { // For Ks K K
	- EvtDalitzPoint point( _mKs, _mK, _mK, m2AB, m2BC, m2AC );
	- EvtDalitzPoint antiPoint( _mKs, _mK, _mK, m2AC, m2BC, m2AB );
	+ EvtDalitzPoint point( m_mKs, m_mK, m_mK, m2AB, m2BC, m2AC );
	+ EvtDalitzPoint antiPoint( m_mKs, m_mK, m_mK, m2AC, m2BC, m2AB );

	ampDalitz = dalitzKsKK( point );
	ampAntiDalitz = dalitzKsKK( antiPoint );
	@@ -164,15 +165,15 @@
	// Assume there's no direct CP violation.
	EvtComplex barAOverA = ampAntiDalitz / ampDalitz;

	- // CP violation in the interference. _qp implements CP violation in the mixing.
	- EvtComplex chi = _qp * barAOverA;
	+ // CP violation in the interference. m_qp implements CP violation in the mixing.
	+ EvtComplex chi = m_qp * barAOverA;

	// Generate a negative exponential life time. p( gt ) = ( 1 - y ) * e^{ - ( 1 - y ) gt }
	- double gt = -log( EvtRandom::Flat() ) / ( 1.0 - std::fabs( _y ) );
	- part->setLifetime( gt / _gamma );
	+ double gt = -log( EvtRandom::Flat() ) / ( 1.0 - std::fabs( m_y ) );
	+ part->setLifetime( gt / m_gamma );

	// Compute time dependent amplitude.
	- EvtComplex amp = 0.5 * ampDalitz * exp( -std::fabs( _y ) * gt / 2.0 ) *
	+ EvtComplex amp = 0.5 * ampDalitz * exp( -std::fabs( m_y ) * gt / 2.0 ) *
	( ( 1.0 + chi ) * h1( gt ) + ( 1.0 - chi ) * h2( gt ) );

	vertex( amp );
	@@ -183,64 +184,66 @@
	void EvtD0mixDalitz::readPDGValues()
	{
	// Define the EvtIds.
	- _D0 = EvtPDL::getId( "D0" );
	- _D0B = EvtPDL::getId( "anti-D0" );
	- _KM = EvtPDL::getId( "K-" );
	- _KP = EvtPDL::getId( "K+" );
	- _K0 = EvtPDL::getId( "K0" );
	- _K0B = EvtPDL::getId( "anti-K0" );
	- _KL = EvtPDL::getId( "K_L0" );
	- _KS = EvtPDL::getId( "K_S0" );
	- _PIM = EvtPDL::getId( "pi-" );
	- _PIP = EvtPDL::getId( "pi+" );
	+ m_D0 = EvtPDL::getId( "D0" );
	+ m_D0B = EvtPDL::getId( "anti-D0" );
	+ m_KM = EvtPDL::getId( "K-" );
	+ m_KP = EvtPDL::getId( "K+" );
	+ m_K0 = EvtPDL::getId( "K0" );
	+ m_K0B = EvtPDL::getId( "anti-K0" );
	+ m_KL = EvtPDL::getId( "K_L0" );
	+ m_KS = EvtPDL::getId( "K_S0" );
	+ m_PIM = EvtPDL::getId( "pi-" );
	+ m_PIP = EvtPDL::getId( "pi+" );

	// Read the relevant masses.
	- _mD0 = EvtPDL::getMass( _D0 );
	- _mKs = EvtPDL::getMass( _KS );
	- _mPi = EvtPDL::getMass( _PIP );
	- _mK = EvtPDL::getMass( _KP );
	+ m_mD0 = EvtPDL::getMass( m_D0 );
	+ m_mKs = EvtPDL::getMass( m_KS );
	+ m_mPi = EvtPDL::getMass( m_PIP );
	+ m_mK = EvtPDL::getMass( m_KP );

	// Compute the decay rate from the parameter in the evt.pdl file.
	- _ctau = EvtPDL::getctau( EvtPDL::getId( "D0" ) );
	+ m_ctau = EvtPDL::getctau( EvtPDL::getId( "D0" ) );

	- _gamma = 1.0 / _ctau; // ALERT: Gamma is not 1 / tau.
	+ m_gamma = 1.0 / m_ctau; // ALERT: Gamma is not 1 / tau.
	}

	EvtComplex EvtD0mixDalitz::dalitzKsPiPi( const EvtDalitzPoint& point )
	{
	- static const EvtDalitzPlot plot( _mKs, _mPi, _mPi, _mD0 );
	+ static const EvtDalitzPlot plot( m_mKs, m_mPi, m_mPi, m_mD0 );

	EvtComplex amp = 0.;

	- if ( _isRBWmodel ) {
	+ if ( m_isRBWmodel ) {
	// This corresponds to relativistic Breit-Wigner distributions. Not K-matrix.
	// Defining resonances.
	- static EvtDalitzReso KStarm( plot, _BC, _AC, _VECTOR, 0.893606,
	- 0.0463407, _RBW );
	- static EvtDalitzReso KStarp( plot, _BC, _AB, _VECTOR, 0.893606,
	- 0.0463407, _RBW );
	- static EvtDalitzReso rho0( plot, _AC, _BC, _VECTOR, 0.7758, 0.1464, _GS );
	- static EvtDalitzReso omega( plot, _AC, _BC, _VECTOR, 0.78259, 0.00849,
	- _RBW );
	- static EvtDalitzReso f0_980( plot, _AC, _BC, _SCALAR, 0.975, 0.044, _RBW );
	- static EvtDalitzReso f0_1370( plot, _AC, _BC, _SCALAR, 1.434, 0.173,
	- _RBW );
	- static EvtDalitzReso f2_1270( plot, _AC, _BC, _TENSOR, 1.2754, 0.1851,
	- _RBW );
	- static EvtDalitzReso K0Starm_1430( plot, _BC, _AC, _SCALAR, 1.459,
	- 0.175, _RBW );
	- static EvtDalitzReso K0Starp_1430( plot, _BC, _AB, _SCALAR, 1.459,
	- 0.175, _RBW );
	- static EvtDalitzReso K2Starm_1430( plot, _BC, _AC, _TENSOR, 1.4256,
	- 0.0985, _RBW );
	- static EvtDalitzReso K2Starp_1430( plot, _BC, _AB, _TENSOR, 1.4256,
	- 0.0985, _RBW );
	- static EvtDalitzReso sigma( plot, _AC, _BC, _SCALAR, 0.527699, 0.511861,
	- _RBW );
	- static EvtDalitzReso sigma2( plot, _AC, _BC, _SCALAR, 1.03327,
	- 0.0987890, _RBW );
	- static EvtDalitzReso KStarm_1680( plot, _BC, _AC, _VECTOR, 1.677, 0.205,
	- _RBW );
	+ static EvtDalitzReso KStarm( plot, m_BC, m_AC, m_VECTOR, 0.893606,
	+ 0.0463407, m_RBW );
	+ static EvtDalitzReso KStarp( plot, m_BC, m_AB, m_VECTOR, 0.893606,
	+ 0.0463407, m_RBW );
	+ static EvtDalitzReso rho0( plot, m_AC, m_BC, m_VECTOR, 0.7758, 0.1464,
	+ m_GS );
	+ static EvtDalitzReso omega( plot, m_AC, m_BC, m_VECTOR, 0.78259,
	+ 0.00849, m_RBW );
	+ static EvtDalitzReso f0_980( plot, m_AC, m_BC, m_SCALAR, 0.975, 0.044,
	+ m_RBW );
	+ static EvtDalitzReso f0_1370( plot, m_AC, m_BC, m_SCALAR, 1.434, 0.173,
	+ m_RBW );
	+ static EvtDalitzReso f2_1270( plot, m_AC, m_BC, m_TENSOR, 1.2754,
	+ 0.1851, m_RBW );
	+ static EvtDalitzReso K0Starm_1430( plot, m_BC, m_AC, m_SCALAR, 1.459,
	+ 0.175, m_RBW );
	+ static EvtDalitzReso K0Starp_1430( plot, m_BC, m_AB, m_SCALAR, 1.459,
	+ 0.175, m_RBW );
	+ static EvtDalitzReso K2Starm_1430( plot, m_BC, m_AC, m_TENSOR, 1.4256,
	+ 0.0985, m_RBW );
	+ static EvtDalitzReso K2Starp_1430( plot, m_BC, m_AB, m_TENSOR, 1.4256,
	+ 0.0985, m_RBW );
	+ static EvtDalitzReso sigma( plot, m_AC, m_BC, m_SCALAR, 0.527699,
	+ 0.511861, m_RBW );
	+ static EvtDalitzReso sigma2( plot, m_AC, m_BC, m_SCALAR, 1.03327,
	+ 0.0987890, m_RBW );
	+ static EvtDalitzReso KStarm_1680( plot, m_BC, m_AC, m_VECTOR, 1.677,
	+ 0.205, m_RBW );

	// Adding terms to the amplitude with their corresponding amplitude and phase terms.
	amp += EvtComplex( 0.848984, 0.893618 );
	@@ -261,42 +264,43 @@
	} else {
	// This corresponds to the complete model (RBW, GS, LASS and K-matrix).
	// Defining resonances.
	- static EvtDalitzReso KStarm( plot, _BC, _AC, _VECTOR, 0.893619,
	- 0.0466508, _RBW );
	- static EvtDalitzReso KStarp( plot, _BC, _AB, _VECTOR, 0.893619,
	- 0.0466508, _RBW );
	- static EvtDalitzReso rho0( plot, _AC, _BC, _VECTOR, 0.7758, 0.1464, _GS );
	- static EvtDalitzReso omega( plot, _AC, _BC, _VECTOR, 0.78259, 0.00849,
	- _RBW );
	- static EvtDalitzReso f2_1270( plot, _AC, _BC, _TENSOR, 1.2754, 0.1851,
	- _RBW );
	- static EvtDalitzReso K0Starm_1430( plot, _AC, 1.46312, 0.232393, 1.0746,
	+ static EvtDalitzReso KStarm( plot, m_BC, m_AC, m_VECTOR, 0.893619,
	+ 0.0466508, m_RBW );
	+ static EvtDalitzReso KStarp( plot, m_BC, m_AB, m_VECTOR, 0.893619,
	+ 0.0466508, m_RBW );
	+ static EvtDalitzReso rho0( plot, m_AC, m_BC, m_VECTOR, 0.7758, 0.1464,
	+ m_GS );
	+ static EvtDalitzReso omega( plot, m_AC, m_BC, m_VECTOR, 0.78259,
	+ 0.00849, m_RBW );
	+ static EvtDalitzReso f2_1270( plot, m_AC, m_BC, m_TENSOR, 1.2754,
	+ 0.1851, m_RBW );
	+ static EvtDalitzReso K0Starm_1430( plot, m_AC, 1.46312, 0.232393, 1.0746,
	-1.83214, .803516, 2.32788, 1.0,
	-5.31306 ); // LASS
	- static EvtDalitzReso K0Starp_1430( plot, _AB, 1.46312, 0.232393, 1.0746,
	+ static EvtDalitzReso K0Starp_1430( plot, m_AB, 1.46312, 0.232393, 1.0746,
	-1.83214, .803516, 2.32788, 1.0,
	-5.31306 ); // LASS
	- static EvtDalitzReso K2Starm_1430( plot, _BC, _AC, _TENSOR, 1.4256,
	- 0.0985, _RBW );
	- static EvtDalitzReso K2Starp_1430( plot, _BC, _AB, _TENSOR, 1.4256,
	- 0.0985, _RBW );
	- static EvtDalitzReso KStarm_1680( plot, _BC, _AC, _VECTOR, 1.677, 0.205,
	- _RBW );
	+ static EvtDalitzReso K2Starm_1430( plot, m_BC, m_AC, m_TENSOR, 1.4256,
	+ 0.0985, m_RBW );
	+ static EvtDalitzReso K2Starp_1430( plot, m_BC, m_AB, m_TENSOR, 1.4256,
	+ 0.0985, m_RBW );
	+ static EvtDalitzReso KStarm_1680( plot, m_BC, m_AC, m_VECTOR, 1.677,
	+ 0.205, m_RBW );

	// Defining K-matrix.
	static EvtComplex fr12( 1.87981, -0.628378 );
	static EvtComplex fr13( 4.3242, 2.75019 );
	static EvtComplex fr14( 3.22336, 0.271048 );
	static EvtComplex fr15( 0.0, 0.0 );
	- static EvtDalitzReso Pole1( plot, _BC, "Pole1", _KMAT, fr12, fr13, fr14,
	- fr15, -0.0694725 );
	- static EvtDalitzReso Pole2( plot, _BC, "Pole2", _KMAT, fr12, fr13, fr14,
	- fr15, -0.0694725 );
	- static EvtDalitzReso Pole3( plot, _BC, "Pole3", _KMAT, fr12, fr13, fr14,
	- fr15, -0.0694725 );
	- static EvtDalitzReso Pole4( plot, _BC, "Pole4", _KMAT, fr12, fr13, fr14,
	- fr15, -0.0694725 );
	- static EvtDalitzReso kmatrix( plot, _BC, "f11prod", _KMAT, fr12, fr13,
	+ static EvtDalitzReso Pole1( plot, m_BC, "Pole1", m_KMAT, fr12, fr13,
	+ fr14, fr15, -0.0694725 );
	+ static EvtDalitzReso Pole2( plot, m_BC, "Pole2", m_KMAT, fr12, fr13,
	+ fr14, fr15, -0.0694725 );
	+ static EvtDalitzReso Pole3( plot, m_BC, "Pole3", m_KMAT, fr12, fr13,
	+ fr14, fr15, -0.0694725 );
	+ static EvtDalitzReso Pole4( plot, m_BC, "Pole4", m_KMAT, fr12, fr13,
	+ fr14, fr15, -0.0694725 );
	+ static EvtDalitzReso kmatrix( plot, m_BC, "f11prod", m_KMAT, fr12, fr13,
	fr14, fr15, -0.0694725 );

	// Adding terms to the amplitude with their corresponding amplitude and phase terms.
	@@ -325,23 +329,29 @@

	EvtComplex EvtD0mixDalitz::dalitzKsKK( const EvtDalitzPoint& point )
	{
	- static const EvtDalitzPlot plot( _mKs, _mK, _mK, _mD0 );
	+ static const EvtDalitzPlot plot( m_mKs, m_mK, m_mK, m_mD0 );

	// Defining resonances.
	- static EvtDalitzReso a00_980( plot, _AC, _BC, _SCALAR, 0.999, _RBW,
	- 0.550173, 0.324, _EtaPic );
	- static EvtDalitzReso phi( plot, _AC, _BC, _VECTOR, 1.01943, 0.00459319, _RBW );
	- static EvtDalitzReso a0p_980( plot, _AC, _AB, _SCALAR, 0.999, _RBW,
	- 0.550173, 0.324, _EtaPic );
	- static EvtDalitzReso f0_1370( plot, _AC, _BC, _SCALAR, 1.350, 0.265, _RBW );
	- static EvtDalitzReso a0m_980( plot, _AB, _AC, _SCALAR, 0.999, _RBW,
	- 0.550173, 0.324, _EtaPic );
	- static EvtDalitzReso f0_980( plot, _AC, _BC, _SCALAR, 0.965, _RBW, 0.695,
	- 0.165, _PicPicKK );
	- static EvtDalitzReso f2_1270( plot, _AC, _BC, _TENSOR, 1.2754, 0.1851, _RBW );
	- static EvtDalitzReso a00_1450( plot, _AC, _BC, _SCALAR, 1.474, 0.265, _RBW );
	- static EvtDalitzReso a0p_1450( plot, _AC, _AB, _SCALAR, 1.474, 0.265, _RBW );
	- static EvtDalitzReso a0m_1450( plot, _AB, _AC, _SCALAR, 1.474, 0.265, _RBW );
	+ static EvtDalitzReso a00_980( plot, m_AC, m_BC, m_SCALAR, 0.999, m_RBW,
	+ 0.550173, 0.324, m_EtaPic );
	+ static EvtDalitzReso phi( plot, m_AC, m_BC, m_VECTOR, 1.01943, 0.00459319,
	+ m_RBW );
	+ static EvtDalitzReso a0p_980( plot, m_AC, m_AB, m_SCALAR, 0.999, m_RBW,
	+ 0.550173, 0.324, m_EtaPic );
	+ static EvtDalitzReso f0_1370( plot, m_AC, m_BC, m_SCALAR, 1.350, 0.265,
	+ m_RBW );
	+ static EvtDalitzReso a0m_980( plot, m_AB, m_AC, m_SCALAR, 0.999, m_RBW,
	+ 0.550173, 0.324, m_EtaPic );
	+ static EvtDalitzReso f0_980( plot, m_AC, m_BC, m_SCALAR, 0.965, m_RBW,
	+ 0.695, 0.165, m_PicPicKK );
	+ static EvtDalitzReso f2_1270( plot, m_AC, m_BC, m_TENSOR, 1.2754, 0.1851,
	+ m_RBW );
	+ static EvtDalitzReso a00_1450( plot, m_AC, m_BC, m_SCALAR, 1.474, 0.265,
	+ m_RBW );
	+ static EvtDalitzReso a0p_1450( plot, m_AC, m_AB, m_SCALAR, 1.474, 0.265,
	+ m_RBW );
	+ static EvtDalitzReso a0m_1450( plot, m_AB, m_AC, m_SCALAR, 1.474, 0.265,
	+ m_RBW );

	// Adding terms to the amplitude with their corresponding amplitude and phase terms.
	EvtComplex amp( 0., 0. ); // Phase space amplitude.
	@@ -365,10 +375,10 @@
	// e{1,2}( gt ) = exp( -gt / 2 ) * h{1,2}( gt ).
	EvtComplex EvtD0mixDalitz::h1( const double& gt ) const
	{
	- return exp( -EvtComplex( _y, _x ) * gt / 2. );
	+ return exp( -EvtComplex( m_y, m_x ) * gt / 2. );
	}

	EvtComplex EvtD0mixDalitz::h2( const double& gt ) const
	{
	- return exp( EvtComplex( _y, _x ) * gt / 2. );
	+ return exp( EvtComplex( m_y, m_x ) * gt / 2. );
	}
	diff --git a/src/EvtGenModels/EvtDDalitz.cpp b/src/EvtGenModels/EvtDDalitz.cpp
	--- a/src/EvtGenModels/EvtDDalitz.cpp
	+++ b/src/EvtGenModels/EvtDDalitz.cpp
	@@ -172,7 +172,7 @@
	std::cout << std::endl;
	*/

	- _flag = 0;
	+ m_flag = 0;

	// D0 or anti-D0 modes. We only need to check the particle modes, since anti-particle
	// modes have their ordered daughter ids charged-conjugated above
	@@ -181,37 +181,37 @@
	// Look for D0 to K- pi+ pi0
	if ( daughters[0].first == KM && daughters[1].first == PI0 &&
	daughters[2].first == PIP ) {
	- _flag = 4;
	- _d1 = daughters[0].second;
	- _d2 = daughters[2].second;
	- _d3 = daughters[1].second;
	+ m_flag = 4;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[2].second;
	+ m_d3 = daughters[1].second;
	}

	// Look for D0 to KB pi- pi+
	if ( isNeutralKaon( daughters[0].first ) == true &&
	daughters[1].first == PIM && daughters[2].first == PIP ) {
	- _flag = 3;
	- _d1 = daughters[0].second;
	- _d2 = daughters[1].second;
	- _d3 = daughters[2].second;
	+ m_flag = 3;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[1].second;
	+ m_d3 = daughters[2].second;
	}

	// Look for D0 to KB K+ K-
	if ( isNeutralKaon( daughters[0].first ) == true &&
	daughters[1].first == KM && daughters[2].first == KP ) {
	- _flag = 5;
	- _d1 = daughters[0].second;
	- _d2 = daughters[2].second;
	- _d3 = daughters[1].second;
	+ m_flag = 5;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[2].second;
	+ m_d3 = daughters[1].second;
	}

	// Look for D0 to pi- pi+ pi0
	if ( daughters[0].first == PIM && daughters[1].first == PI0 &&
	daughters[2].first == PIP ) {
	- _flag = 12;
	- _d1 = daughters[0].second;
	- _d2 = daughters[2].second;
	- _d3 = daughters[1].second;
	+ m_flag = 12;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[2].second;
	+ m_d3 = daughters[1].second;
	}
	}

	@@ -220,46 +220,46 @@
	// Look for D+ to KB pi+ pi0
	if ( isNeutralKaon( daughters[0].first ) == true &&
	daughters[1].first == PI0 && daughters[2].first == PIP ) {
	- _flag = 2;
	- _d1 = daughters[0].second;
	- _d2 = daughters[2].second;
	- _d3 = daughters[1].second;
	+ m_flag = 2;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[2].second;
	+ m_d3 = daughters[1].second;
	}

	// Look for D+ to K- pi+ pi+
	if ( daughters[0].first == KM && daughters[1].first == PIP &&
	daughters[2].first == PIP ) {
	- _flag = 1;
	- _d1 = daughters[0].second;
	- _d2 = daughters[1].second;
	- _d3 = daughters[2].second;
	+ m_flag = 1;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[1].second;
	+ m_d3 = daughters[2].second;
	}

	// Look for D+ to K- K+ pi+
	if ( daughters[0].first == KM && daughters[1].first == PIP &&
	daughters[2].first == KP ) {
	- _flag = 7;
	- _d1 = daughters[0].second;
	- _d2 = daughters[2].second;
	- _d3 = daughters[1].second;
	+ m_flag = 7;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[2].second;
	+ m_d3 = daughters[1].second;
	}

	// Look for D+ to pi- pi+ K+
	if ( daughters[0].first == PIM && daughters[1].first == PIP &&
	daughters[2].first == KP ) {
	- _flag = 8;
	- _d1 = daughters[0].second;
	- _d2 = daughters[1].second;
	- _d3 = daughters[2].second;
	+ m_flag = 8;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[1].second;
	+ m_d3 = daughters[2].second;
	}

	// Look for D+ to pi- pi+ pi+
	if ( daughters[0].first == PIM && daughters[1].first == PIP &&
	daughters[2].first == PIP ) {
	- _flag = 10;
	- _d1 = daughters[0].second;
	- _d2 = daughters[1].second;
	- _d3 = daughters[2].second;
	+ m_flag = 10;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[1].second;
	+ m_d3 = daughters[2].second;
	}
	}

	@@ -268,37 +268,37 @@
	// Look for Ds+ to K- K+ pi+
	if ( daughters[0].first == KM && daughters[1].first == PIP &&
	daughters[2].first == KP ) {
	- _flag = 6;
	- _d1 = daughters[0].second;
	- _d2 = daughters[2].second;
	- _d3 = daughters[1].second;
	+ m_flag = 6;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[2].second;
	+ m_d3 = daughters[1].second;
	}

	// Look for Ds+ to pi- pi+ K+
	if ( daughters[0].first == PIM && daughters[1].first == PIP &&
	daughters[2].first == KP ) {
	- _flag = 9;
	- _d1 = daughters[0].second;
	- _d2 = daughters[1].second;
	- _d3 = daughters[2].second;
	+ m_flag = 9;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[1].second;
	+ m_d3 = daughters[2].second;
	}

	// Look for Ds+ to pi- pi+ pi+
	if ( daughters[0].first == PIM && daughters[1].first == PIP &&
	daughters[2].first == PIP ) {
	- _flag = 11;
	- _d1 = daughters[0].second;
	- _d2 = daughters[1].second;
	- _d3 = daughters[2].second;
	+ m_flag = 11;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[1].second;
	+ m_d3 = daughters[2].second;
	}
	}

	- if ( _flag == 6 ) {
	- _kkpi_params.push_back( EvtFlatteParam( MPI, MPI, 0.406 ) );
	- _kkpi_params.push_back( EvtFlatteParam( MKP, MKP, 0.800 ) );
	+ if ( m_flag == 6 ) {
	+ m_kkpi_params.push_back( EvtFlatteParam( MPI, MPI, 0.406 ) );
	+ m_kkpi_params.push_back( EvtFlatteParam( MKP, MKP, 0.800 ) );
	}

	- if ( _flag == 0 ) {
	+ if ( m_flag == 0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "EvtDDaltiz: Invalid mode." << endl;
	assert( 0 );
	@@ -306,10 +306,10 @@

	/*
	EvtGenReport(EVTGEN_INFO,"EvtGen") << "DDALITZ ordering for " << parnum.getName()
	- << " with mode = " << _flag << ": "
	- << getDaug(_d1).getName() << " "
	- << getDaug(_d2).getName() << " "
	- << getDaug(_d3).getName() << std::endl;
	+ << " with mode = " << m_flag << ": "
	+ << getDaug(m_d1).getName() << " "
	+ << getDaug(m_d2).getName() << " "
	+ << getDaug(m_d3).getName() << std::endl;
	*/
	}

	@@ -317,40 +317,40 @@
	{
	// probmax different for different modes!

	- if ( _flag == 1 ) {
	+ if ( m_flag == 1 ) {
	setProbMax( 2500.0 );
	}
	- if ( _flag == 2 ) {
	+ if ( m_flag == 2 ) {
	setProbMax( 150.0 );
	}
	- if ( _flag == 3 ) {
	+ if ( m_flag == 3 ) {
	setProbMax( 3000.0 );
	}
	- if ( _flag == 4 ) {
	+ if ( m_flag == 4 ) {
	setProbMax( 600.0 );
	}
	- if ( _flag == 5 ) {
	+ if ( m_flag == 5 ) {
	setProbMax( 2500000.0 );
	}
	- if ( _flag == 6 ) {
	+ if ( m_flag == 6 ) {
	setProbMax( 45000.0 );
	}
	- if ( _flag == 7 ) {
	+ if ( m_flag == 7 ) {
	setProbMax( 35000.0 );
	}
	- if ( _flag == 8 ) {
	+ if ( m_flag == 8 ) {
	setProbMax( 2500.0 );
	}
	- if ( _flag == 9 ) {
	+ if ( m_flag == 9 ) {
	setProbMax( 1700.0 );
	}
	- if ( _flag == 10 ) {
	+ if ( m_flag == 10 ) {
	setProbMax( 1300.0 );
	}
	- if ( _flag == 11 ) {
	+ if ( m_flag == 11 ) {
	setProbMax( 2200.0 );
	}
	- if ( _flag == 12 ) {
	+ if ( m_flag == 12 ) {
	setProbMax( 1000.0 );
	}
	}
	@@ -380,9 +380,9 @@
	//same structure for all of these decays

	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- EvtVector4R moms1 = p->getDaug( _d1 )->getP4();
	- EvtVector4R moms2 = p->getDaug( _d2 )->getP4();
	- EvtVector4R moms3 = p->getDaug( _d3 )->getP4();
	+ EvtVector4R moms1 = p->getDaug( m_d1 )->getP4();
	+ EvtVector4R moms2 = p->getDaug( m_d2 )->getP4();
	+ EvtVector4R moms3 = p->getDaug( m_d3 )->getP4();

	EvtVector4R p4_p;
	p4_p.set( p->mass(), 0.0, 0.0, 0.0 );
	@@ -396,7 +396,7 @@
	//(Mark III results) for D+ -> K0bar pi+ pi0.
	//CLEO results for D0->k-pi+pi0

	- if ( _flag == 1 ) {
	+ if ( m_flag == 1 ) {
	// D+ -> K- pi+ pi+ decay, or charge conjugate

	// //Anjos etal e691 - Phys Rev D48, 56 (1993)
	@@ -444,7 +444,7 @@
	//amp = amp+oneby2*(-DplusRes11.resAmpl()+DplusRes12.resAmpl());
	}

	- if ( _flag == 2 ) {
	+ if ( m_flag == 2 ) {
	//have a D+ -> K0bar pi+ pi0 decay
	//adler etal MarkIII - Phys Lett B196, 107 (1987)
	// Results in this paper:
	@@ -465,7 +465,7 @@
	DplusKpipi0Res2.relBrWig( 1 );
	}

	- if ( _flag == 3 ) {
	+ if ( m_flag == 3 ) {
	// D0 -> K0bar pi- pi+ & CC
	// If it does not come from a B->DK, decay it as D0 or D0bar separately
	// if p4_p is D0, moms1 is K0, moms2 is pi-, moms3 is pi+
	@@ -522,7 +522,7 @@
	}
	}

	- if ( _flag == 4 ) {
	+ if ( m_flag == 4 ) {
	// D0 to K- pi+ pi0
	EvtResonance2 DKpipi0Res1( p4_p, moms2, moms3, 1.0, 0.0, 0.1507, 0.770,
	1 ); //rho
	@@ -550,7 +550,7 @@
	DKpipi0Res7.resAmpl();
	}

	- if ( _flag == 5 ) {
	+ if ( m_flag == 5 ) {
	// D0 -> K0bar K+ K- & CC
	// If it does not come from a B->DK, decay it as D0 or D0bar separately
	// if p4_p is D0, moms1 is K0, moms2 is pi-, moms3 is pi+
	@@ -609,13 +609,13 @@

	// Ds+ -> K- K+ pi+
	//Babar, arxiv:1011.4190
	- if ( _flag == 6 ) {
	+ if ( m_flag == 6 ) {
	EvtResonance2 DsKKpiRes1( p4_p, moms3, moms1, 1.0, 0.0, 0.0455, 0.8944,
	1, true ); // K*(892)
	EvtResonance2 DsKKpiRes2( p4_p, moms3, moms1, 1.48, 138., 0.290, 1.414,
	0 ); // K*_0(1430)
	EvtFlatte DsKKpiRes3( p4_p, moms1, moms2, 5.07, 156., 0.965,
	- _kkpi_params ); // f_0(980)
	+ m_kkpi_params ); // f_0(980)
	EvtResonance2 DsKKpiRes4( p4_p, moms1, moms2, 1.15, -10., 0.00426,
	1.019455, 1, true ); // phi(1020)
	EvtResonance2 DsKKpiRes5( p4_p, moms1, moms2, 1.28, 53., 0.265, 1.350,
	@@ -628,7 +628,7 @@

	//D+ -> K- K+ pi+
	//CLEO PRD 78, 072003 (2008) Fit A
	- if ( _flag == 7 ) {
	+ if ( m_flag == 7 ) {
	EvtResonance2 DpKKpiRes1( p4_p, moms3, moms1, 1.0, 0.0, 0.0503, 0.8960,
	1, true ); // K*(892)
	EvtResonance2 DpKKpiRes2( p4_p, moms3, moms1, 3.7, 73.0, 0.290, 1.414,
	@@ -653,7 +653,7 @@
	// thus the magnitudes appearing below come from dividing the ones appearing in the paper by the sqrt of the
	// integral over the DP of the corresponding squared amplitude. Writing as pi- pi+ K+ so pipi resonances are (12)
	// and Kpi resonances are (31); masses and widths corresponds to PDG 2010
	- if ( _flag == 8 ) {
	+ if ( m_flag == 8 ) {
	EvtResonance2 DpKpipiDCSRes1( p4_p, moms1, moms2, 1.0, 0.0, 0.149,
	0.775, 1, true ); // rho(770)
	EvtResonance2 DpKpipiDCSRes2( p4_p, moms3, moms1, 1.0971, -167.1,
	@@ -673,7 +673,7 @@
	// and Kpi resonances are (31); masses and widths corresponds to PDG 2010
	// PROBLEM: by simply doing the procedure for D+, the resulting DP and projections do not resemble what is
	// in the paper; the best model is by adding 180 to the vector Kpi resonances
	- if ( _flag == 9 ) {
	+ if ( m_flag == 9 ) {
	EvtResonance2 DsKpipiCSRes1( p4_p, moms1, moms2, 1.0, 0.0, 0.149, 0.775,
	1, true ); // rho(770)
	EvtResonance2 DsKpipiCSRes2( p4_p, moms3, moms1, 0.7236, -18.3, 0.0487,
	@@ -696,7 +696,7 @@
	// (although not explicit) so magnitudes here are obtained after correcting for that
	// Breit-Wigner has a factor of (-1) there which changes the relative phase of the NR wrt to the resonances
	// thus the NR magnitude is set as negative
	- if ( _flag == 10 ) {
	+ if ( m_flag == 10 ) {
	EvtResonance2 DppipipiRes11( p4_p, moms1, moms2, 1.0, 0.0, 0.150, 0.769,
	1, true ); // rho(770)
	EvtResonance2 DppipipiRes12( p4_p, moms3, moms1, 1.0, 0.0, 0.150, 0.769,
	@@ -736,7 +736,7 @@
	// (although not explicit) so magnitudes here are obtained after correcting for that
	// Breit-Wigner has a factor of (-1) there which changes the relative phase of the NR wrt to the resonances
	// thus the NR magnitude is set as negative
	- if ( _flag == 11 ) {
	+ if ( m_flag == 11 ) {
	EvtResonance2 DspipipiRes11( p4_p, moms1, moms2, 0.288, 109., 0.150,
	0.769, 1, true ); // rho(770)
	EvtResonance2 DspipipiRes12( p4_p, moms3, moms1, 0.288, 109., 0.150,
	@@ -772,7 +772,7 @@
	//arXiv:hep-ex/0703037
	// Amplitude magnitudes taken from the above paper, but corrected for normalization
	// For details, see https://phab.hepforge.org/T219
	- if ( _flag == 12 ) {
	+ if ( m_flag == 12 ) {
	EvtResonance2 DpipipiRes1p( p4_p, moms2, moms3, 1.0, 0.0, 0.149, 0.775,
	1, true ); //rho+(770)
	EvtResonance2 DpipipiRes1( p4_p, moms1, moms2, 0.6237, 16.2, 0.149,
	diff --git a/src/EvtGenModels/EvtDMix.cpp b/src/EvtGenModels/EvtDMix.cpp
	--- a/src/EvtGenModels/EvtDMix.cpp
	+++ b/src/EvtGenModels/EvtDMix.cpp
	@@ -44,9 +44,9 @@
	{
	// check arguments
	checkNArg( 3 );
	- _rd = getArg( 0 );
	- _xpr = getArg( 1 );
	- _ypr = getArg( 2 );
	+ m_rd = getArg( 0 );
	+ m_xpr = getArg( 1 );
	+ m_ypr = getArg( 2 );
	}

	void EvtDMix::initProbMax()
	@@ -72,15 +72,15 @@

	double pdf, random, gt, weight;

	- double maxPdf = _rd + sqrt( _rd ) * _ypr * 50. +
	- 2500.0 * ( _xpr * _xpr + _ypr * _ypr ) / 4.0;
	+ double maxPdf = m_rd + sqrt( m_rd ) * m_ypr * 50. +
	+ 2500.0 * ( m_xpr * m_xpr + m_ypr * m_ypr ) / 4.0;
	bool keepGoing = true;
	while ( keepGoing ) {
	random = EvtRandom::Flat();
	gt = -log( random );
	weight = random;
	- pdf = _rd + sqrt( _rd ) * _ypr * gt +
	- gt * gt * ( _xpr * _xpr + _ypr * _ypr ) / 4.0;
	+ pdf = m_rd + sqrt( m_rd ) * m_ypr * gt +
	+ gt * gt * ( m_xpr * m_xpr + m_ypr * m_ypr ) / 4.0;
	pdf = exp( -1.0 gt );
	pdf /= weight;
	if ( pdf > maxPdf )
	diff --git a/src/EvtGenModels/EvtDToKpienu.cpp b/src/EvtGenModels/EvtDToKpienu.cpp
	--- a/src/EvtGenModels/EvtDToKpienu.cpp
	+++ b/src/EvtGenModels/EvtDToKpienu.cpp
	@@ -48,52 +48,52 @@

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "EvtDToKpienu ==> Initialization !" << std::endl;
	- nAmps = 2;
	-
	- rS = -11.57; // S-wave
	- rS1 = 0.08;
	- a_delta = 1.94;
	- b_delta = -0.81;
	- m0_1430_S = 1.425;
	- width0_1430_S = 0.270;
	- type[0] = 0;
	-
	- mV = 1.81;
	- mA = 2.61;
	- V_0 = 1.411;
	- A1_0 = 1;
	- A2_0 = 0.788;
	-
	- m0 = 0.8946; // P-wave K*
	- width0 = 0.04642;
	- rBW = 3.07;
	- rho = 1;
	- phi = 0;
	- type[1] = 1;
	-
	- m0_1410 = 1.414; // P-wave K*(1410)
	- width0_1410 = 0.232;
	- rho_1410 = 0.1;
	- phi_1410 = 0.;
	- type[2] = 2;
	-
	- TV_0 = 1; // D-wave K*2(1430)
	- T1_0 = 1;
	- T2_0 = 1;
	- m0_1430 = 1.4324;
	- width0_1430 = 0.109;
	- rho_1430 = 15;
	- phi_1430 = 0;
	- type[3] = 3;
	-
	- mD = 1.86962;
	- mPi = 0.13957;
	- mK = 0.49368;
	- Pi = atan2( 0.0, -1.0 );
	- root2 = sqrt( 2. );
	- root2d3 = sqrt( 2. / 3 );
	- root1d2 = sqrt( 0.5 );
	- root3d2 = sqrt( 1.5 );
	+ m_nAmps = 2;
	+
	+ m_rS = -11.57; // S-wave
	+ m_rS1 = 0.08;
	+ m_a_delta = 1.94;
	+ m_b_delta = -0.81;
	+ m_m0_1430_S = 1.425;
	+ m_width0_1430_S = 0.270;
	+ m_type[0] = 0;
	+
	+ m_mV = 1.81;
	+ m_mA = 2.61;
	+ m_V_0 = 1.411;
	+ m_A1_0 = 1;
	+ m_A2_0 = 0.788;
	+
	+ m_m0 = 0.8946; // P-wave K*
	+ m_width0 = 0.04642;
	+ m_rBW = 3.07;
	+ m_rho = 1;
	+ m_phi = 0;
	+ m_type[1] = 1;
	+
	+ m_m0_1410 = 1.414; // P-wave K*(1410)
	+ m_width0_1410 = 0.232;
	+ m_rho_1410 = 0.1;
	+ m_phi_1410 = 0.;
	+ m_type[2] = 2;
	+
	+ m_TV_0 = 1; // D-wave K*2(1430)
	+ m_T1_0 = 1;
	+ m_T2_0 = 1;
	+ m_m0_1430 = 1.4324;
	+ m_width0_1430 = 0.109;
	+ m_rho_1430 = 15;
	+ m_phi_1430 = 0;
	+ m_type[3] = 3;
	+
	+ m_mD = 1.86962;
	+ m_mPi = 0.13957;
	+ m_mK = 0.49368;
	+ m_Pi = atan2( 0.0, -1.0 );
	+ m_root2 = sqrt( 2. );
	+ m_root2d3 = sqrt( 2. / 3 );
	+ m_root1d2 = sqrt( 0.5 );
	+ m_root3d2 = sqrt( 1.5 );
	}

	void EvtDToKpienu::initProbMax()
	@@ -209,20 +209,21 @@
	EvtComplex coef( 0.0, 0.0 );
	double amplitude_temp, delta_temp;

	- for ( int index = 0; index < nAmps; index++ ) {
	- switch ( type[index] ) {
	+ for ( int index = 0; index < m_nAmps; index++ ) {
	+ switch ( m_type[index] ) {
	case 0: // calculate form factor of S wave
	{
	- NRS( m, q, rS, rS1, a_delta, b_delta, mA, m0_1430_S,
	- width0_1430_S, amplitude_temp, delta_temp, f10 );
	+ NRS( m, q, m_rS, m_rS1, m_a_delta, m_b_delta, m_mA, m_m0_1430_S,
	+ m_width0_1430_S, amplitude_temp, delta_temp, f10 );
	F10 = F10 + f10;
	break;
	}
	case 1: // calculate form factor of P wave (K*)
	{
	- ResonanceP( m, q, mV, mA, V_0, A1_0, A2_0, m0, width0, rBW,
	- amplitude_temp, delta_temp, f11, f21, f31 );
	- coef = getCoef( rho, phi );
	+ ResonanceP( m, q, m_mV, m_mA, m_V_0, m_A1_0, m_A2_0, m_m0,
	+ m_width0, m_rBW, amplitude_temp, delta_temp, f11,
	+ f21, f31 );
	+ coef = getCoef( m_rho, m_phi );
	F11 = F11 + coef * f11;
	F21 = F21 + coef * f21;
	F31 = F31 + coef * f31;
	@@ -230,9 +231,10 @@
	}
	case 2: // calculate form factor of P wave (K*(1410))
	{
	- ResonanceP( m, q, mV, mA, V_0, A1_0, A2_0, m0_1410, width0_1410,
	- rBW, amplitude_temp, delta_temp, f11, f21, f31 );
	- coef = getCoef( rho_1410, phi_1410 );
	+ ResonanceP( m, q, m_mV, m_mA, m_V_0, m_A1_0, m_A2_0, m_m0_1410,
	+ m_width0_1410, m_rBW, amplitude_temp, delta_temp,
	+ f11, f21, f31 );
	+ coef = getCoef( m_rho_1410, m_phi_1410 );
	F11 = F11 + coef * f11;
	F21 = F21 + coef * f21;
	F31 = F31 + coef * f31;
	@@ -240,9 +242,10 @@
	}
	case 3: // calculate form factor of D wave
	{
	- ResonanceD( m, q, mV, mA, TV_0, T1_0, T2_0, m0_1430, width0_1430,
	- rBW, amplitude_temp, delta_temp, f12, f22, f32 );
	- coef = getCoef( rho_1430, phi_1430 );
	+ ResonanceD( m, q, m_mV, m_mA, m_TV_0, m_T1_0, m_T2_0, m_m0_1430,
	+ m_width0_1430, m_rBW, amplitude_temp, delta_temp,
	+ f12, f22, f32 );
	+ coef = getCoef( m_rho_1430, m_phi_1430 );
	F12 = F12 + coef * f12;
	F22 = F22 + coef * f22;
	F32 = F32 + coef * f32;
	@@ -264,8 +267,8 @@
	double sinV2 = sinV * sinV;

	EvtComplex F1 = F10 + F11 * cosV + F12 * ( 1.5 * cosV2 - 0.5 );
	- EvtComplex F2 = F21 * root1d2 + F22 * cosV * root3d2;
	- EvtComplex F3 = F31 * root1d2 + F32 * cosV * root3d2;
	+ EvtComplex F2 = F21 * m_root1d2 + F22 * cosV * m_root3d2;
	+ EvtComplex F3 = F31 * m_root1d2 + F32 * cosV * m_root3d2;

	I1 = 0.25 * ( abs2( F1 ) + 1.5 * sinV2 * ( abs2( F2 ) + abs2( F3 ) ) );
	I2 = -0.25 * ( abs2( F1 ) - 0.5 * sinV2 * ( abs2( F2 ) + abs2( F3 ) ) );
	@@ -301,19 +304,19 @@
	double& delta, EvtComplex& F11, EvtComplex& F21,
	EvtComplex& F31 ) const
	{
	- double pKPi = getPStar( mD, m, q );
	- double mD2 = mD * mD;
	+ double pKPi = getPStar( m_mD, m, q );
	+ double mD2 = m_mD * m_mD;
	double m2 = m * m;
	double m02 = m0 * m0;
	double q2 = q * q;
	double mV2 = mV * mV;
	double mA2 = mA * mA;
	- double summDm = mD + m;
	+ double summDm = m_mD + m;
	double V = V_0 / ( 1.0 - q2 / ( mV2 ) );
	double A1 = A1_0 / ( 1.0 - q2 / ( mA2 ) );
	double A2 = A2_0 / ( 1.0 - q2 / ( mA2 ) );
	double A = summDm * A1;
	- double B = 2.0 * mD * pKPi / summDm * V;
	+ double B = 2.0 * m_mD * pKPi / summDm * V;

	// construct the helicity form factor
	double H0 = 0.5 / ( m * q ) *
	@@ -324,12 +327,12 @@

	// calculate alpha
	double B_Kstar = 2. / 3.; // B_Kstar = Br(Kstar(892)->k pi)
	- double pStar0 = getPStar( m0, mPi, mK );
	- double alpha = sqrt( 3. * Pi * B_Kstar / ( pStar0 * width0 ) );
	+ double pStar0 = getPStar( m0, m_mPi, m_mK );
	+ double alpha = sqrt( 3. * m_Pi * B_Kstar / ( pStar0 * width0 ) );

	// construct amplitudes of (non)resonance
	- double F = getF1( m, m0, mPi, mK, rBW );
	- double width = getWidth1( m, m0, mPi, mK, width0, rBW );
	+ double F = getF1( m, m0, m_mPi, m_mK, rBW );
	+ double width = getWidth1( m, m0, m_mPi, m_mK, width0, rBW );

	EvtComplex C( m0 * width0 * F, 0.0 );
	double AA = m02 - m2;
	@@ -339,7 +342,7 @@
	delta = atan2( imag( amp ), real( amp ) );

	double alpham2 = alpha * 2.0;
	- F11 = amp * alpham2 * q * H0 * root2;
	+ F11 = amp * alpham2 * q * H0 * m_root2;
	F21 = amp * alpham2 * q * ( Hp + Hm );
	F31 = amp * alpham2 * q * ( Hp - Hm );
	}
	@@ -350,16 +353,16 @@
	const double width0, double& amplitude, double& delta,
	EvtComplex& F10 ) const
	{
	- static const double tmp = ( mK + mPi ) * ( mK + mPi );
	+ static const double tmp = ( m_mK + m_mPi ) * ( m_mK + m_mPi );

	double m2 = m * m;
	double q2 = q * q;
	double mA2 = mA * mA;
	- double pKPi = getPStar( mD, m, q );
	+ double pKPi = getPStar( m_mD, m, q );
	double m_K0_1430 = m0;
	double width_K0_1430 = width0;
	double m2_K0_1430 = m_K0_1430 * m_K0_1430;
	- double width = getWidth0( m, m_K0_1430, mPi, mK, width_K0_1430 );
	+ double width = getWidth0( m, m_K0_1430, m_mPi, m_mK, width_K0_1430 );

	// calculate modul of the amplitude
	double x, Pm;
	@@ -375,21 +378,21 @@
	}

	// calculate phase of the amplitude
	- double pStar = getPStar( m, mPi, mK );
	+ double pStar = getPStar( m, m_mPi, m_mK );
	double delta_bg = atan( 2. * a_delta * pStar /
	( 2. + a_delta * b_delta * pStar * pStar ) );
	- delta_bg = ( delta_bg > 0 ) ? delta_bg : ( delta_bg + Pi );
	+ delta_bg = ( delta_bg > 0 ) ? delta_bg : ( delta_bg + m_Pi );

	double delta_K0_1430 = atan( m_K0_1430 * width / ( m2_K0_1430 - m2 ) );
	delta_K0_1430 = ( delta_K0_1430 > 0 ) ? delta_K0_1430
	- : ( delta_K0_1430 + Pi );
	+ : ( delta_K0_1430 + m_Pi );
	delta = delta_bg + delta_K0_1430;

	EvtComplex ci( cos( delta ), sin( delta ) );
	EvtComplex amp = ci * rS * Pm;
	amplitude = rS * Pm;

	- F10 = amp * pKPi * mD / ( 1. - q2 / mA2 );
	+ F10 = amp * pKPi * m_mD / ( 1. - q2 / mA2 );
	}

	void EvtDToKpienu::ResonanceD( const double m, const double q, const double mV,
	@@ -400,21 +403,21 @@
	double& delta, EvtComplex& F12, EvtComplex& F22,
	EvtComplex& F32 ) const
	{
	- double pKPi = getPStar( mD, m, q );
	- double mD2 = mD * mD;
	+ double pKPi = getPStar( m_mD, m, q );
	+ double mD2 = m_mD * m_mD;
	double m2 = m * m;
	double m02 = m0 * m0;
	double q2 = q * q;
	double mV2 = mV * mV;
	double mA2 = mA * mA;
	- double summDm = mD + m;
	+ double summDm = m_mD + m;
	double TV = TV_0 / ( 1.0 - q2 / ( mV2 ) );
	double T1 = T1_0 / ( 1.0 - q2 / ( mA2 ) );
	double T2 = T2_0 / ( 1.0 - q2 / ( mA2 ) );

	// construct amplitudes of (non)resonance
	- double F = getF2( m, m0, mPi, mK, rBW );
	- double width = getWidth2( m, m0, mPi, mK, width0, rBW );
	+ double F = getF2( m, m0, m_mPi, m_mK, rBW );
	+ double width = getWidth2( m, m0, m_mPi, m_mK, width0, rBW );
	EvtComplex C( m0 * width0 * F, 0.0 );
	double AA = m02 - m2;
	double BB = -m0 * width;
	@@ -423,10 +426,10 @@
	amplitude = abs( amp );
	delta = atan2( imag( amp ), real( amp ) );

	- F12 = amp * mD * pKPi / 3. *
	+ F12 = amp * m_mD * pKPi / 3. *
	( ( mD2 - m2 - q2 ) * summDm * T1 - mD2 * pKPi * pKPi / summDm * T2 );
	- F22 = amp * root2d3 * mD * m * q * pKPi * summDm * T1;
	- F32 = amp * root2d3 * 2. * mD2 * m * q * pKPi * pKPi / summDm * TV;
	+ F22 = amp * m_root2d3 * m_mD * m * q * pKPi * summDm * T1;
	+ F32 = amp * m_root2d3 * 2. * mD2 * m * q * pKPi * pKPi / summDm * TV;
	}

	double EvtDToKpienu::getPStar( const double m, const double m1,
	diff --git a/src/EvtGenModels/EvtDalitzTable.cpp b/src/EvtGenModels/EvtDalitzTable.cpp
	--- a/src/EvtGenModels/EvtDalitzTable.cpp
	+++ b/src/EvtGenModels/EvtDalitzTable.cpp
	@@ -36,14 +36,14 @@

	EvtDalitzTable::EvtDalitzTable()
	{
	- _dalitztable.clear();
	- _readFiles.clear();
	+ m_dalitztable.clear();
	+ m_readFiles.clear();
	}

	EvtDalitzTable::~EvtDalitzTable()
	{
	- _dalitztable.clear();
	- _readFiles.clear();
	+ m_dalitztable.clear();
	+ m_readFiles.clear();
	}

	EvtDalitzTable* EvtDalitzTable::getInstance( const std::string dec_name,
	@@ -64,8 +64,8 @@

	bool EvtDalitzTable::fileHasBeenRead( const std::string dec_name )
	{
	- std::vector<std::string>::iterator i = _readFiles.begin();
	- for ( ; i != _readFiles.end(); i++ ) {
	+ std::vector<std::string>::iterator i = m_readFiles.begin();
	+ for ( ; i != m_readFiles.end(); i++ ) {
	if ( ( *i ).compare( dec_name ) == 0 ) {
	return true;
	}
	@@ -81,7 +81,7 @@
	<< endl;
	}

	- _readFiles.push_back( dec_name );
	+ m_readFiles.push_back( dec_name );

	EvtDalitzDecayInfo* dalitzDecay = nullptr;
	double probMax = 0;
	@@ -152,7 +152,6 @@

	} else if ( parser.getTagTitle() == "copyDalitz" ) {
	int nDaughters = 0;
	- EvtId daughter[3];
	int nCopyDaughters = 0;
	EvtId copyDaughter[3];

	@@ -443,10 +442,10 @@

	void EvtDalitzTable::addDecay( EvtId parent, const EvtDalitzDecayInfo& dec )
	{
	- if ( _dalitztable.find( parent ) != _dalitztable.end() ) {
	- _dalitztable[parent].push_back( dec );
	+ if ( m_dalitztable.find( parent ) != m_dalitztable.end() ) {
	+ m_dalitztable[parent].push_back( dec );
	} else {
	- _dalitztable[parent].push_back( dec );
	+ m_dalitztable[parent].push_back( dec );
	}
	}

	@@ -491,8 +490,8 @@
	std::vector<EvtDalitzDecayInfo> EvtDalitzTable::getDalitzTable( const EvtId& parent )
	{
	std::vector<EvtDalitzDecayInfo> table;
	- if ( _dalitztable.find( parent ) != _dalitztable.end() ) {
	- table = _dalitztable[parent];
	+ if ( m_dalitztable.find( parent ) != m_dalitztable.end() ) {
	+ table = m_dalitztable[parent];
	}

	if ( table.empty() ) {
	diff --git a/src/EvtGenModels/EvtFlatQ2.cpp b/src/EvtGenModels/EvtFlatQ2.cpp
	--- a/src/EvtGenModels/EvtFlatQ2.cpp
	+++ b/src/EvtGenModels/EvtFlatQ2.cpp
	@@ -91,15 +91,15 @@
	}

	// Specify if we want to use the phase space factor
	- _usePhsp = false;
	+ m_usePhsp = false;
	if ( getNArg() > 0 ) {
	if ( getArg( 0 ) != 0 ) {
	- _usePhsp = true;
	+ m_usePhsp = true;
	}
	}

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "EvtFlatQ2 usePhsp = " << int( _usePhsp ) << std::endl;
	+ << "EvtFlatQ2 usePhsp = " << int( m_usePhsp ) << std::endl;
	}

	void EvtFlatQ2::decay( EvtParticle* p )
	@@ -121,7 +121,7 @@
	}

	// Include the phase space factor if requested
	- if ( _usePhsp ) {
	+ if ( m_usePhsp ) {
	// Invariant mass of lepton pair
	double q = ( p4ell1 + p4ell2 ).mass();
	// Rest masses of the leptons
	diff --git a/src/EvtGenModels/EvtGenericDalitz.cpp b/src/EvtGenModels/EvtGenericDalitz.cpp
	--- a/src/EvtGenModels/EvtGenericDalitz.cpp
	+++ b/src/EvtGenModels/EvtGenericDalitz.cpp
	@@ -55,34 +55,34 @@
	EvtId daughter3 = ( *i ).daughter3();

	if ( d1 == daughter1 && d2 == daughter2 && d3 == daughter3 ) {
	- _d1 = 0;
	- _d2 = 1;
	- _d3 = 2;
	+ m_d1 = 0;
	+ m_d2 = 1;
	+ m_d3 = 2;
	} else if ( d1 == daughter1 && d2 == daughter3 && d3 == daughter2 ) {
	- _d1 = 0;
	- _d2 = 2;
	- _d3 = 1;
	+ m_d1 = 0;
	+ m_d2 = 2;
	+ m_d3 = 1;
	} else if ( d1 == daughter2 && d2 == daughter1 && d3 == daughter3 ) {
	- _d1 = 1;
	- _d2 = 0;
	- _d3 = 2;
	+ m_d1 = 1;
	+ m_d2 = 0;
	+ m_d3 = 2;
	} else if ( d1 == daughter2 && d2 == daughter3 && d3 == daughter1 ) {
	- _d1 = 1;
	- _d2 = 2;
	- _d3 = 0;
	+ m_d1 = 1;
	+ m_d2 = 2;
	+ m_d3 = 0;
	} else if ( d1 == daughter3 && d2 == daughter1 && d3 == daughter2 ) {
	- _d1 = 2;
	- _d2 = 0;
	- _d3 = 1;
	+ m_d1 = 2;
	+ m_d2 = 0;
	+ m_d3 = 1;
	} else if ( d1 == daughter3 && d2 == daughter2 && d3 == daughter1 ) {
	- _d1 = 2;
	- _d2 = 1;
	- _d3 = 0;
	+ m_d1 = 2;
	+ m_d2 = 1;
	+ m_d3 = 0;
	} else {
	continue;
	}

	- _resonances = ( *i ).getResonances();
	+ m_resonances = ( *i ).getResonances();
	setProbMax( ( *i ).getProbMax() );
	return;
	}
	@@ -92,13 +92,13 @@
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );

	- EvtVector4R p4_d1 = p->getDaug( _d1 )->getP4();
	- EvtVector4R p4_d2 = p->getDaug( _d2 )->getP4();
	- EvtVector4R p4_d3 = p->getDaug( _d3 )->getP4();
	+ EvtVector4R p4_d1 = p->getDaug( m_d1 )->getP4();
	+ EvtVector4R p4_d2 = p->getDaug( m_d2 )->getP4();
	+ EvtVector4R p4_d3 = p->getDaug( m_d3 )->getP4();

	- double mA = p->getDaug( _d1 )->mass();
	- double mB = p->getDaug( _d2 )->mass();
	- double mC = p->getDaug( _d3 )->mass();
	+ double mA = p->getDaug( m_d1 )->mass();
	+ double mB = p->getDaug( m_d2 )->mass();
	+ double mC = p->getDaug( m_d3 )->mass();

	double m2AB = ( p4_d1 + p4_d2 ).mass2();
	double m2CA = ( p4_d1 + p4_d3 ).mass2();
	@@ -108,8 +108,8 @@

	EvtComplex amp( 0, 0 );
	std::vector<std::pair<EvtComplex, EvtDalitzReso>>::iterator i =
	- _resonances.begin();
	- for ( ; i != _resonances.end(); i++ ) {
	+ m_resonances.begin();
	+ for ( ; i != m_resonances.end(); i++ ) {
	std::pair<EvtComplex, EvtDalitzReso> res = ( *i );
	amp += res.first * res.second.evaluate( point );
	}
	diff --git a/src/EvtGenModels/EvtHQET.cpp b/src/EvtGenModels/EvtHQET.cpp
	--- a/src/EvtGenModels/EvtHQET.cpp
	+++ b/src/EvtGenModels/EvtHQET.cpp
	@@ -48,7 +48,7 @@
	void EvtHQET::decay( EvtParticle* p )
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- calcamp->CalcAmp( p, _amp2, hqetffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_hqetffmodel.get() );
	}

	void EvtHQET::initProbMax()
	@@ -60,8 +60,8 @@
	lnum = getDaug( 1 );
	nunum = getDaug( 2 );

	- double mymaxprob = calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	- hqetffmodel.get() );
	+ double mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	+ m_hqetffmodel.get() );

	setProbMax( mymaxprob );
	}
	@@ -81,19 +81,20 @@
	if ( d1type == EvtSpinType::SCALAR ) {
	checkNArg( 1, 2 );
	if ( getNArg() == 1 )
	- hqetffmodel = std::make_unique<EvtHQETFF>( getArg( 0 ) );
	+ m_hqetffmodel = std::make_unique<EvtHQETFF>( getArg( 0 ) );
	else
	- hqetffmodel = std::make_unique<EvtHQETFF>( getArg( 0 ), getArg( 1 ) );
	- calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	+ m_hqetffmodel = std::make_unique<EvtHQETFF>( getArg( 0 ),
	+ getArg( 1 ) );
	+ m_calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	} else if ( d1type == EvtSpinType::VECTOR ) {
	checkNArg( 3, 4 );
	if ( getNArg() == 3 )
	- hqetffmodel = std::make_unique<EvtHQETFF>( getArg( 0 ), getArg( 1 ),
	- getArg( 2 ) );
	+ m_hqetffmodel = std::make_unique<EvtHQETFF>( getArg( 0 ), getArg( 1 ),
	+ getArg( 2 ) );
	else
	- hqetffmodel = std::make_unique<EvtHQETFF>( getArg( 0 ), getArg( 1 ),
	- getArg( 2 ), getArg( 3 ) );
	- calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_hqetffmodel = std::make_unique<EvtHQETFF>(
	+ getArg( 0 ), getArg( 1 ), getArg( 2 ), getArg( 3 ) );
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "HQET model handles only scalar and vector meson daughters. Sorry."
	diff --git a/src/EvtGenModels/EvtHQET2.cpp b/src/EvtGenModels/EvtHQET2.cpp
	--- a/src/EvtGenModels/EvtHQET2.cpp
	+++ b/src/EvtGenModels/EvtHQET2.cpp
	@@ -48,7 +48,7 @@
	void EvtHQET2::decay( EvtParticle* p )
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- calcamp->CalcAmp( p, _amp2, hqetffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_hqetffmodel.get() );
	}

	void EvtHQET2::initProbMax()
	@@ -60,8 +60,8 @@
	lnum = getDaug( 1 );
	nunum = getDaug( 2 );

	- double mymaxprob = calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	- hqetffmodel.get() );
	+ double mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	+ m_hqetffmodel.get() );

	setProbMax( mymaxprob );
	}
	@@ -80,13 +80,15 @@
	EvtSpinType::spintype d1type = EvtPDL::getSpinType( getDaug( 0 ) );
	if ( d1type == EvtSpinType::SCALAR ) {
	if ( getNArg() == 2 ) {
	- hqetffmodel = std::make_unique<EvtHQET2FF>( getArg( 0 ), getArg( 1 ) );
	- calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	+ m_hqetffmodel = std::make_unique<EvtHQET2FF>( getArg( 0 ),
	+ getArg( 1 ) );
	+ m_calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();

	} else if ( getNArg() == 3 ) {
	- hqetffmodel = std::make_unique<EvtHQET2FF>( getArg( 0 ), getArg( 1 ),
	- getArg( 2 ) );
	- calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	+ m_hqetffmodel = std::make_unique<EvtHQET2FF>( getArg( 0 ),
	+ getArg( 1 ),
	+ getArg( 2 ) );
	+ m_calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();

	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -97,15 +99,14 @@

	} else if ( d1type == EvtSpinType::VECTOR ) {
	if ( getNArg() == 4 ) {
	- hqetffmodel = std::make_unique<EvtHQET2FF>(
	+ m_hqetffmodel = std::make_unique<EvtHQET2FF>(
	getArg( 0 ), getArg( 1 ), getArg( 2 ), getArg( 3 ) );
	- calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();

	} else if ( getNArg() == 5 ) {
	- hqetffmodel = std::make_unique<EvtHQET2FF>( getArg( 0 ), getArg( 1 ),
	- getArg( 2 ), getArg( 3 ),
	- getArg( 4 ) );
	- calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_hqetffmodel = std::make_unique<EvtHQET2FF>(
	+ getArg( 0 ), getArg( 1 ), getArg( 2 ), getArg( 3 ), getArg( 4 ) );
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();

	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	diff --git a/src/EvtGenModels/EvtHQET2FF.cpp b/src/EvtGenModels/EvtHQET2FF.cpp
	--- a/src/EvtGenModels/EvtHQET2FF.cpp
	+++ b/src/EvtGenModels/EvtHQET2FF.cpp
	@@ -32,37 +32,37 @@
	EvtHQET2FF::EvtHQET2FF( double hqetrho2, double hqetha1_1, double hqetr1_1,
	double hqetr2_1 )
	{
	- rho2 = hqetrho2;
	- r1_1 = hqetr1_1;
	- r2_1 = hqetr2_1;
	- ha1_1 = hqetha1_1;
	- extended = false;
	+ m_rho2 = hqetrho2;
	+ m_r1_1 = hqetr1_1;
	+ m_r2_1 = hqetr2_1;
	+ m_ha1_1 = hqetha1_1;
	+ m_extended = false;
	}

	EvtHQET2FF::EvtHQET2FF( double hqetrho2, double hqetha1_1, double hqetr1_1,
	double hqetr2_1, double hqetr0_1 )
	{
	- rho2 = hqetrho2;
	- r0_1 = hqetr0_1;
	- r1_1 = hqetr1_1;
	- r2_1 = hqetr2_1;
	- ha1_1 = hqetha1_1;
	- extended = true;
	+ m_rho2 = hqetrho2;
	+ m_r0_1 = hqetr0_1;
	+ m_r1_1 = hqetr1_1;
	+ m_r2_1 = hqetr2_1;
	+ m_ha1_1 = hqetha1_1;
	+ m_extended = true;
	}

	EvtHQET2FF::EvtHQET2FF( double hqetrho2, double hqetv1_1 )
	{
	- rho2 = hqetrho2;
	- v1_1 = hqetv1_1;
	- extended = false;
	+ m_rho2 = hqetrho2;
	+ m_v1_1 = hqetv1_1;
	+ m_extended = false;
	}

	EvtHQET2FF::EvtHQET2FF( double hqetrho2, double hqetv1_1, double indelta )
	{
	- rho2 = hqetrho2;
	- v1_1 = hqetv1_1;
	- delta = indelta;
	- extended = true;
	+ m_rho2 = hqetrho2;
	+ m_v1_1 = hqetv1_1;
	+ m_delta = indelta;
	+ m_extended = true;
	}

	void EvtHQET2FF::getscalarff( EvtId parent, EvtId, double t, double mass,
	@@ -78,21 +78,21 @@
	// I.Caprini, L.Lelluch, M.Neubert, Nucl. Phys. B 530,153(1998)
	const double z = ( sqrt( w + 1 ) - sqrt( 2. ) ) /
	( sqrt( w + 1 ) + sqrt( 2. ) );
	- double v1 = v1_1 * ( 1. - 8. * rho2 * z + ( 51. * rho2 - 10. ) * z * z -
	- ( 252. * rho2 - 84. ) * z * z * z );
	+ double v1 = m_v1_1 * ( 1. - 8. * m_rho2 * z + ( 51. * m_rho2 - 10. ) * z * z -
	+ ( 252. * m_rho2 - 84. ) * z * z * z );

	*f0p = v1;
	*f0m = 0.0;

	- if ( extended ) {
	+ if ( m_extended ) {
	//if in extended mode, use helicity-suppressed FF using the result from
	//Tanaka and Watanabe, Phys. Rev. D 82 034027 (2010)

	double r = mass / mb;
	double r1 = r + 1.0;
	- double s1 = v1 * ( 1 + delta * ( -0.019 + 0.041 * ( w - 1 ) -
	- 0.015 * ( w - 1 ) *
	- ( w - 1 ) ) ); //as in ref
	+ double s1 = v1 * ( 1 + m_delta * ( -0.019 + 0.041 * ( w - 1 ) -
	+ 0.015 * ( w - 1 ) *
	+ ( w - 1 ) ) ); //as in ref
	f0m = s1 ( w + 1.0 ) * 2.0 * r /
	( r1 * r1 ); //convert to convention used by EvtGen with proper relative normalization
	}
	@@ -113,10 +113,11 @@
	// I.Caprini, L.Lelluch, M.Neubert, Nucl. Phys. B 530,153(1998)
	const double z = ( sqrt( w + 1 ) - sqrt( 2. ) ) /
	( sqrt( w + 1 ) + sqrt( 2. ) );
	- double ha1 = ha1_1 * ( 1. - 8. * rho2 * z + ( 53. * rho2 - 15. ) * z * z -
	- ( 231. * rho2 - 91. ) * z * z * z );
	- double r1 = r1_1 - 0.12 * ( w - 1 ) + 0.05 * ( w - 1 ) * ( w - 1 );
	- double r2 = r2_1 + 0.11 * ( w - 1 ) - 0.06 * ( w - 1 ) * ( w - 1 );
	+ double ha1 = m_ha1_1 *
	+ ( 1. - 8. * m_rho2 * z + ( 53. * m_rho2 - 15. ) * z * z -
	+ ( 231. * m_rho2 - 91. ) * z * z * z );
	+ double r1 = m_r1_1 - 0.12 * ( w - 1 ) + 0.05 * ( w - 1 ) * ( w - 1 );
	+ double r2 = m_r2_1 + 0.11 * ( w - 1 ) - 0.06 * ( w - 1 ) * ( w - 1 );

	a1f = ( 1.0 - ( t / ( ( mb + mass ) ( mb + mass ) ) ) ) * ha1;
	a1f = ( a1f ) / rstar;
	@@ -124,11 +125,11 @@
	vf = ( r1 / rstar ) ha1;
	*a0f = 0.0;

	- if ( extended ) {
	+ if ( m_extended ) {
	// Here we use the expectation for R_0(w) from
	// Fajfer et al, Phys. Rev. D 85 094025 (2012)

	- double r0 = r0_1 - 0.11 * ( w - 1 ) + 0.01 * ( w - 1 ) * ( w - 1 );
	+ double r0 = m_r0_1 - 0.11 * ( w - 1 ) + 0.01 * ( w - 1 ) * ( w - 1 );
	a0f = ( r0 / rstar ) ha1;
	}
	}
	diff --git a/src/EvtGenModels/EvtHQETFF.cpp b/src/EvtGenModels/EvtHQETFF.cpp
	--- a/src/EvtGenModels/EvtHQETFF.cpp
	+++ b/src/EvtGenModels/EvtHQETFF.cpp
	@@ -32,18 +32,18 @@
	EvtHQETFF::EvtHQETFF( double hqetrho2, double hqetr1, double hqetr2,
	double quadTerm )
	{
	- rho2 = hqetrho2;
	- r1 = hqetr1;
	- r2 = hqetr2;
	- c = quadTerm;
	+ m_rho2 = hqetrho2;
	+ m_r1 = hqetr1;
	+ m_r2 = hqetr2;
	+ m_c = quadTerm;

	return;
	}

	EvtHQETFF::EvtHQETFF( double hqetrho2, double quadTerm )
	{
	- rho2 = hqetrho2;
	- c = quadTerm;
	+ m_rho2 = hqetrho2;
	+ m_c = quadTerm;

	return;
	}
	@@ -57,7 +57,7 @@
	// Form factors have a general form, with parameters passed in
	// from the arguements.

	- double ha1 = 1 - rho2 * ( w - 1 ) + c * ( w - 1 ) * ( w - 1 );
	+ double ha1 = 1 - m_rho2 * ( w - 1 ) + m_c * ( w - 1 ) * ( w - 1 );

	*f0p = ha1;
	*f0m = 0.0;
	@@ -75,12 +75,12 @@
	// from the arguements.

	double rstar = ( 2.0 * sqrt( mb * mass ) ) / ( mb + mass );
	- double ha1 = 1 - rho2 * ( w - 1 );
	+ double ha1 = 1 - m_rho2 * ( w - 1 );

	a1f = ( 1.0 - ( t / ( ( mb + mass ) ( mb + mass ) ) ) ) * ha1;
	a1f = ( a1f ) / rstar;
	- a2f = ( r2 / rstar ) ha1;
	- vf = ( r1 / rstar ) ha1;
	+ a2f = ( m_r2 / rstar ) ha1;
	+ vf = ( m_r1 / rstar ) ha1;
	*a0f = 0.0;

	return;
	diff --git a/src/EvtGenModels/EvtHelAmp.cpp b/src/EvtGenModels/EvtHelAmp.cpp
	--- a/src/EvtGenModels/EvtHelAmp.cpp
	+++ b/src/EvtGenModels/EvtHelAmp.cpp
	@@ -136,8 +136,8 @@
	}
	}

	- _evalHelAmp = std::make_unique<EvtEvalHelAmp>( getParentId(), getDaug( 0 ),
	- getDaug( 1 ), _HBC );
	+ m_evalHelAmp = std::make_unique<EvtEvalHelAmp>( getParentId(), getDaug( 0 ),
	+ getDaug( 1 ), _HBC );

	// Note: these are not class data members but local variables.
	for ( int ib = 0; ib < _nB; ib++ ) {
	@@ -148,7 +148,7 @@

	void EvtHelAmp::initProbMax()
	{
	- double maxprob = _evalHelAmp->probMax();
	+ double maxprob = m_evalHelAmp->probMax();

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -163,7 +163,7 @@
	//first generate simple phase space
	p->initializePhaseSpace( getNDaug(), getDaugs() );

	- _evalHelAmp->evalAmp( p, _amp2 );
	+ m_evalHelAmp->evalAmp( p, m_amp2 );
	}

	void EvtHelAmp::fillHelicity( int* lambda2, int n, int J2, EvtId id )
	diff --git a/src/EvtGenModels/EvtHypNonLepton.cpp b/src/EvtGenModels/EvtHypNonLepton.cpp
	--- a/src/EvtGenModels/EvtHypNonLepton.cpp
	+++ b/src/EvtGenModels/EvtHypNonLepton.cpp
	@@ -153,7 +153,7 @@
	void EvtHypNonLepton::decay( EvtParticle* parent )
	{
	parent->initializePhaseSpace( getNDaug(), getDaugs() );
	- calcAmp( &_amp2, parent );
	+ calcAmp( &m_amp2, parent );
	}

	void EvtHypNonLepton::calcAmp( EvtAmp* amp, EvtParticle* parent )
	diff --git a/src/EvtGenModels/EvtISGW.cpp b/src/EvtGenModels/EvtISGW.cpp
	--- a/src/EvtGenModels/EvtISGW.cpp
	+++ b/src/EvtGenModels/EvtISGW.cpp
	@@ -48,7 +48,7 @@
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );

	- calcamp->CalcAmp( p, _amp2, isgwffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_isgwffmodel.get() );
	}

	void EvtISGW::init()
	@@ -65,17 +65,17 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::NEUTRINO );

	- isgwffmodel = std::make_unique<EvtISGWFF>();
	+ m_isgwffmodel = std::make_unique<EvtISGWFF>();

	switch ( mesontype ) {
	case EvtSpinType::SCALAR:
	- calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	break;
	case EvtSpinType::VECTOR:
	- calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	break;
	case EvtSpinType::TENSOR:
	- calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	break;
	default:;
	}
	diff --git a/src/EvtGenModels/EvtISGW2.cpp b/src/EvtGenModels/EvtISGW2.cpp
	--- a/src/EvtGenModels/EvtISGW2.cpp
	+++ b/src/EvtGenModels/EvtISGW2.cpp
	@@ -50,7 +50,7 @@
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );

	- calcamp->CalcAmp( p, _amp2, isgw2ffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_isgw2ffmodel.get() );
	}

	void EvtISGW2::initProbMax()
	@@ -716,17 +716,17 @@

	EvtSpinType::spintype mesontype = EvtPDL::getSpinType( getDaug( 0 ) );

	- isgw2ffmodel = std::make_unique<EvtISGW2FF>();
	+ m_isgw2ffmodel = std::make_unique<EvtISGW2FF>();

	switch ( mesontype ) {
	case EvtSpinType::SCALAR:
	- calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	break;
	case EvtSpinType::VECTOR:
	- calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	break;
	case EvtSpinType::TENSOR:
	- calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	;
	break;
	default:;
	diff --git a/src/EvtGenModels/EvtItgAbsFunction.cpp b/src/EvtGenModels/EvtItgAbsFunction.cpp
	--- a/src/EvtGenModels/EvtItgAbsFunction.cpp
	+++ b/src/EvtGenModels/EvtItgAbsFunction.cpp
	@@ -33,18 +33,18 @@
	using std::endl;

	EvtItgAbsFunction::EvtItgAbsFunction( double lowerRange, double upperRange ) :
	- _upperRange( upperRange ), _lowerRange( lowerRange )
	+ m_upperRange( upperRange ), m_lowerRange( lowerRange )
	{
	}

	double EvtItgAbsFunction::value( double x ) const
	{
	- if ( x >= _lowerRange && x <= _upperRange )
	+ if ( x >= m_lowerRange && x <= m_upperRange )
	return myFunction( x );
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Error in EvtItgAbsFunction::value. Given co-ordinate " << x
	- << " is outside of allowed range [" << _lowerRange << ", "
	- << _upperRange << "]. Returning 0.0" << endl;
	+ << " is outside of allowed range [" << m_lowerRange << ", "
	+ << m_upperRange << "]. Returning 0.0" << endl;
	return 0.0; // Never get here
	}

	diff --git a/src/EvtGenModels/EvtItgAbsIntegrator.cpp b/src/EvtGenModels/EvtItgAbsIntegrator.cpp
	--- a/src/EvtGenModels/EvtItgAbsIntegrator.cpp
	+++ b/src/EvtGenModels/EvtItgAbsIntegrator.cpp
	@@ -37,13 +37,13 @@
	using std::endl;

	EvtItgAbsIntegrator::EvtItgAbsIntegrator( const EvtItgAbsFunction& theFunction ) :
	- _myFunction( theFunction )
	+ m_myFunction( theFunction )
	{
	}

	double EvtItgAbsIntegrator::normalisation() const
	{
	- return evaluateIt( _myFunction.lowerRange(), _myFunction.upperRange() );
	+ return evaluateIt( m_myFunction.lowerRange(), m_myFunction.upperRange() );
	}

	double EvtItgAbsIntegrator::evaluate( double lower, double upper ) const
	@@ -60,7 +60,7 @@
	{
	if ( n == 1 )
	return 0.5 * ( higher - lower ) *
	- ( _myFunction( lower ) + _myFunction( higher ) );
	+ ( m_myFunction( lower ) + m_myFunction( higher ) );

	int it, j;

	@@ -76,7 +76,7 @@
	double x( lower + 0.5 * deltaX );

	for ( j = 1; j <= it; j++ ) {
	- sum += _myFunction( x );
	+ sum += m_myFunction( x );
	x += deltaX;
	}

	@@ -87,23 +87,23 @@

	void EvtItgAbsIntegrator::boundsCheck( double& lower, double& upper ) const
	{
	- if ( lower < _myFunction.lowerRange() ) {
	+ if ( lower < m_myFunction.lowerRange() ) {
	EvtGenReport( EVTGEN_WARNING, "EvtGen" )
	<< "Warning in EvtItgAbsIntegrator::evaluate. Lower bound "
	<< lower << " of integral "
	- << " is less than lower bound " << _myFunction.lowerRange()
	+ << " is less than lower bound " << m_myFunction.lowerRange()
	<< " of function. No contribution from this range will be counted."
	<< endl;
	- lower = _myFunction.lowerRange();
	+ lower = m_myFunction.lowerRange();
	}

	- if ( upper > _myFunction.upperRange() ) {
	+ if ( upper > m_myFunction.upperRange() ) {
	EvtGenReport( EVTGEN_WARNING, "EvtGen" )
	<< "Warning in EvtItgAbsIntegrator::evaluate. Upper bound "
	<< upper << " of integral "
	- << " is greater than upper bound " << _myFunction.upperRange()
	+ << " is greater than upper bound " << m_myFunction.upperRange()
	<< " of function. No contribution from this range will be counted."
	<< endl;
	- upper = _myFunction.upperRange();
	+ upper = m_myFunction.upperRange();
	}
	}
	diff --git a/src/EvtGenModels/EvtItgFourCoeffFcn.cpp b/src/EvtGenModels/EvtItgFourCoeffFcn.cpp
	--- a/src/EvtGenModels/EvtItgFourCoeffFcn.cpp
	+++ b/src/EvtGenModels/EvtItgFourCoeffFcn.cpp
	@@ -37,41 +37,41 @@
	const std::vector<double>& coeffs2, const std::vector<double>& coeffs3,
	const std::vector<double>& coeffs4 ) :
	EvtItgAbsFunction( lowerRange, upperRange ),
	- _myFunction( theFunction ),
	- _coeffs1( coeffs1 ),
	- _coeffs2( coeffs2 ),
	- _coeffs3( coeffs3 ),
	- _coeffs4( coeffs4 )
	+ m_myFunction( theFunction ),
	+ m_coeffs1( coeffs1 ),
	+ m_coeffs2( coeffs2 ),
	+ m_coeffs3( coeffs3 ),
	+ m_coeffs4( coeffs4 )
	{
	}

	double EvtItgFourCoeffFcn::myFunction( double x ) const
	{
	- return _myFunction( x, _coeffs1, _coeffs2, _coeffs3, _coeffs4 );
	+ return m_myFunction( x, m_coeffs1, m_coeffs2, m_coeffs3, m_coeffs4 );
	}

	void EvtItgFourCoeffFcn::setCoeff( int vect, int which, double value )
	{
	if ( vect == 1 )
	- _coeffs1[which] = value;
	+ m_coeffs1[which] = value;
	else if ( vect == 2 )
	- _coeffs2[which] = value;
	+ m_coeffs2[which] = value;
	else if ( vect == 3 )
	- _coeffs3[which] = value;
	+ m_coeffs3[which] = value;
	else if ( vect == 4 )
	- _coeffs4[which] = value;
	+ m_coeffs4[which] = value;
	}

	double EvtItgFourCoeffFcn::getCoeff( int vect, int which )
	{
	if ( vect == 1 )
	- return _coeffs1[which];
	+ return m_coeffs1[which];
	else if ( vect == 2 )
	- return _coeffs2[which];
	+ return m_coeffs2[which];
	else if ( vect == 3 )
	- return _coeffs3[which];
	+ return m_coeffs3[which];
	else if ( vect == 4 )
	- return _coeffs4[which];
	+ return m_coeffs4[which];
	else {
	return 0;
	}
	diff --git a/src/EvtGenModels/EvtItgFunction.cpp b/src/EvtGenModels/EvtItgFunction.cpp
	--- a/src/EvtGenModels/EvtItgFunction.cpp
	+++ b/src/EvtGenModels/EvtItgFunction.cpp
	@@ -33,11 +33,11 @@
	//----------------
	EvtItgFunction::EvtItgFunction( double ( *theFunction )( double ),
	double lowerRange, double upperRange ) :
	- EvtItgAbsFunction( lowerRange, upperRange ), _myFunction( theFunction )
	+ EvtItgAbsFunction( lowerRange, upperRange ), m_myFunction( theFunction )
	{
	}

	double EvtItgFunction::myFunction( double x ) const
	{
	- return _myFunction( x );
	+ return m_myFunction( x );
	}
	diff --git a/src/EvtGenModels/EvtItgPtrFunction.cpp b/src/EvtGenModels/EvtItgPtrFunction.cpp
	--- a/src/EvtGenModels/EvtItgPtrFunction.cpp
	+++ b/src/EvtGenModels/EvtItgPtrFunction.cpp
	@@ -35,26 +35,26 @@
	double ( *theFunction )( double, const std::vector<double>& ),
	double lowerRange, double upperRange, const std::vector<double>& coeffs1 ) :
	EvtItgAbsFunction( lowerRange, upperRange ),
	- _myFunction( theFunction ),
	- _coeffs1( coeffs1 )
	+ m_myFunction( theFunction ),
	+ m_coeffs1( coeffs1 )
	{
	}

	double EvtItgPtrFunction::myFunction( double x ) const
	{
	- return _myFunction( x, _coeffs1 );
	+ return m_myFunction( x, m_coeffs1 );
	}

	void EvtItgPtrFunction::setCoeff( int vect, int which, double value )
	{
	if ( vect == 1 )
	- _coeffs1[which] = value;
	+ m_coeffs1[which] = value;
	}

	double EvtItgPtrFunction::getCoeff( int vect, int which )
	{
	if ( vect == 1 )
	- return _coeffs1[which];
	+ return m_coeffs1[which];
	else {
	return 0;
	}
	diff --git a/src/EvtGenModels/EvtItgSimpsonIntegrator.cpp b/src/EvtGenModels/EvtItgSimpsonIntegrator.cpp
	--- a/src/EvtGenModels/EvtItgSimpsonIntegrator.cpp
	+++ b/src/EvtGenModels/EvtItgSimpsonIntegrator.cpp
	@@ -46,8 +46,8 @@
	EvtItgSimpsonIntegrator::EvtItgSimpsonIntegrator(
	const EvtItgAbsFunction& theFunction, double precision, int maxLoop ) :
	EvtItgAbsIntegrator( theFunction ),
	- _precision( precision ),
	- _maxLoop( maxLoop )
	+ m_precision( precision ),
	+ m_maxLoop( maxLoop )
	{
	}

	@@ -67,17 +67,17 @@
	st = trapezoid( lower, higher, j, result );
	s = ( 4.0 * st - ost ) / 3.0;

	- if ( fabs( s - olds ) < _precision * fabs( olds ) \|\|
	+ if ( fabs( s - olds ) < m_precision * fabs( olds ) \|\|
	( s == 0.0 && olds == 0.0 ) )
	return s;

	ost = st;

	- for ( j = 5; j < _maxLoop; j++ ) {
	+ for ( j = 5; j < m_maxLoop; j++ ) {
	st = trapezoid( lower, higher, j, result );
	s = ( 4.0 * st - ost ) / 3.0;

	- if ( fabs( s - olds ) < _precision * fabs( olds ) \|\|
	+ if ( fabs( s - olds ) < m_precision * fabs( olds ) \|\|
	( s == 0.0 && olds == 0.0 ) )
	return s;
	olds = s;
	@@ -86,7 +86,7 @@

	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Severe error in EvtItgSimpsonIntegrator. Failed to converge after loop with 2**"
	- << _maxLoop << " calls to the integrand in." << endl;
	+ << m_maxLoop << " calls to the integrand in." << endl;

	return 0.0;
	}
	diff --git a/src/EvtGenModels/EvtItgThreeCoeffFcn.cpp b/src/EvtGenModels/EvtItgThreeCoeffFcn.cpp
	--- a/src/EvtGenModels/EvtItgThreeCoeffFcn.cpp
	+++ b/src/EvtGenModels/EvtItgThreeCoeffFcn.cpp
	@@ -35,36 +35,36 @@
	double lowerRange, double upperRange, const std::vector<double>& coeffs1,
	const std::vector<double>& coeffs2, const std::vector<double>& coeffs3 ) :
	EvtItgAbsFunction( lowerRange, upperRange ),
	- _myFunction( theFunction ),
	- _coeffs1( coeffs1 ),
	- _coeffs2( coeffs2 ),
	- _coeffs3( coeffs3 )
	+ m_myFunction( theFunction ),
	+ m_coeffs1( coeffs1 ),
	+ m_coeffs2( coeffs2 ),
	+ m_coeffs3( coeffs3 )
	{
	}

	double EvtItgThreeCoeffFcn::myFunction( double x ) const
	{
	- return _myFunction( x, _coeffs1, _coeffs2, _coeffs3 );
	+ return m_myFunction( x, m_coeffs1, m_coeffs2, m_coeffs3 );
	}

	void EvtItgThreeCoeffFcn::setCoeff( int vect, int which, double value )
	{
	if ( vect == 1 )
	- _coeffs1[which] = value;
	+ m_coeffs1[which] = value;
	else if ( vect == 2 )
	- _coeffs2[which] = value;
	+ m_coeffs2[which] = value;
	else if ( vect == 3 )
	- _coeffs3[which] = value;
	+ m_coeffs3[which] = value;
	}

	double EvtItgThreeCoeffFcn::getCoeff( int vect, int which )
	{
	if ( vect == 1 )
	- return _coeffs1[which];
	+ return m_coeffs1[which];
	else if ( vect == 2 )
	- return _coeffs2[which];
	+ return m_coeffs2[which];
	else if ( vect == 3 )
	- return _coeffs3[which];
	+ return m_coeffs3[which];
	else {
	return 0;
	}
	diff --git a/src/EvtGenModels/EvtItgTwoCoeffFcn.cpp b/src/EvtGenModels/EvtItgTwoCoeffFcn.cpp
	--- a/src/EvtGenModels/EvtItgTwoCoeffFcn.cpp
	+++ b/src/EvtGenModels/EvtItgTwoCoeffFcn.cpp
	@@ -34,31 +34,31 @@
	double lowerRange, double upperRange, const std::vector<double>& coeffs1,
	const std::vector<double>& coeffs2 ) :
	EvtItgAbsFunction( lowerRange, upperRange ),
	- _myFunction( theFunction ),
	- _coeffs1( coeffs1 ),
	- _coeffs2( coeffs2 )
	+ m_myFunction( theFunction ),
	+ m_coeffs1( coeffs1 ),
	+ m_coeffs2( coeffs2 )
	{
	}

	double EvtItgTwoCoeffFcn::myFunction( double x ) const
	{
	- return _myFunction( x, _coeffs1, _coeffs2 );
	+ return m_myFunction( x, m_coeffs1, m_coeffs2 );
	}

	void EvtItgTwoCoeffFcn::setCoeff( int vect, int which, double value )
	{
	if ( vect == 1 )
	- _coeffs1[which] = value;
	+ m_coeffs1[which] = value;
	else if ( vect == 2 )
	- _coeffs2[which] = value;
	+ m_coeffs2[which] = value;
	}

	double EvtItgTwoCoeffFcn::getCoeff( int vect, int which )
	{
	if ( vect == 1 )
	- return _coeffs1[which];
	+ return m_coeffs1[which];
	else if ( vect == 2 )
	- return _coeffs2[which];
	+ return m_coeffs2[which];
	else {
	return 0;
	}
	diff --git a/src/EvtGenModels/EvtKKLambdaC.cpp b/src/EvtGenModels/EvtKKLambdaC.cpp
	--- a/src/EvtGenModels/EvtKKLambdaC.cpp
	+++ b/src/EvtGenModels/EvtKKLambdaC.cpp
	@@ -46,7 +46,7 @@
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );

	- _calcamp->CalcAmp( p, _amp2, _ffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_ffmodel.get() );
	}

	void EvtKKLambdaC::initProbMax()
	@@ -58,8 +58,8 @@
	lnum = getDaug( 1 );
	nunum = getDaug( 2 );

	- //double mymaxprob = _calcamp->CalcMaxProb(parnum,mesnum,
	- // lnum,nunum,_ffmodel);
	+ //double mymaxprob = m_calcamp->CalcMaxProb(parnum,mesnum,
	+ // lnum,nunum,m_ffmodel);
	double mymaxprob = 1e3;
	setProbMax( mymaxprob );
	}
	@@ -76,7 +76,7 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::NEUTRINO );

	- _ffmodel = std::make_unique<EvtKKLambdaCFF>( getNArg(), getArgs() );
	+ m_ffmodel = std::make_unique<EvtKKLambdaCFF>( getNArg(), getArgs() );

	- _calcamp = std::make_unique<EvtSemiLeptonicBaryonAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicBaryonAmp>();
	}
	diff --git a/src/EvtGenModels/EvtKKLambdaCFF.cpp b/src/EvtGenModels/EvtKKLambdaCFF.cpp
	--- a/src/EvtGenModels/EvtKKLambdaCFF.cpp
	+++ b/src/EvtGenModels/EvtKKLambdaCFF.cpp
	@@ -30,9 +30,9 @@

	EvtKKLambdaCFF::EvtKKLambdaCFF( int numarg, double* arglist )
	{
	- _nargs = numarg;
	+ m_nargs = numarg;
	for ( int i = 0; i < numarg; i++ ) {
	- _args[i] = arglist[i];
	+ m_args[i] = arglist[i];
	}

	return;
	@@ -42,7 +42,7 @@
	double /mass/, double* f1v, double* f1a,
	double* f2v, double* f2a )
	{
	- f1v = ( _args[0] ) / ( 1.0 - ( t / ( _args[1] _args[1] ) ) );
	+ f1v = ( m_args[0] ) / ( 1.0 - ( t / ( m_args[1] m_args[1] ) ) );

	*f2v = 0.;
	*f2a = 0.;
	diff --git a/src/EvtGenModels/EvtLNuGamma.cpp b/src/EvtGenModels/EvtLNuGamma.cpp
	--- a/src/EvtGenModels/EvtLNuGamma.cpp
	+++ b/src/EvtGenModels/EvtLNuGamma.cpp
	@@ -55,12 +55,12 @@
	// Argv[3] is a flag set to 0 if abs(f_a/f_v) is 1
	// and not set to 0 if f_a/f_v is set to 0.
	if ( getArg( 3 ) > 0 ) {
	- _fafvzero = true;
	+ m_fafvzero = true;
	} else {
	- _fafvzero = false;
	+ m_fafvzero = false;
	}
	} else {
	- _fafvzero = false;
	+ m_fafvzero = false;
	}

	checkSpinParent( EvtSpinType::SCALAR );
	@@ -113,7 +113,7 @@
	double fv, fa;

	fv = getFormFactor( photE );
	- if ( _fafvzero ) {
	+ if ( m_fafvzero ) {
	fa = 0.0;
	} else if ( p->getId() == BM \|\| p->getId() == DM ) {
	fa = -fv;
	diff --git a/src/EvtGenModels/EvtLambdaP_BarGamma.cpp b/src/EvtGenModels/EvtLambdaP_BarGamma.cpp
	--- a/src/EvtGenModels/EvtLambdaP_BarGamma.cpp
	+++ b/src/EvtGenModels/EvtLambdaP_BarGamma.cpp
	@@ -32,20 +32,20 @@
	using std::endl;

	EvtLambdaP_BarGamma::EvtLambdaP_BarGamma() :
	- _mLambdab( 5.624 ), // Lambda_b mass
	- _mLambda0( 1.115684 ), // Lambda0 mass
	- _c7Eff( -0.31 ), // Wilson coefficient
	- _mb( 4.4 ), // running b mass
	- _mV( 5.42 ), // pole mass vector current
	- _mA( 5.86 ), // pole mass axial current
	- _GF( 1.166E-5 ), // Fermi constant
	- _gLambdab( 16 ), // coupling constant Lambda_b -> B- p
	- _e0( 1 ), // electromagnetic coupling (+1)
	- _g1( 0.64 ), // heavy-light form factors at q_mSqare
	- _g2( -0.10 ),
	- _f1( 0.64 ),
	- _f2( -0.31 ),
	- _VtbVtsStar( 0.038 ) // \|V_tb V_ts^*\|
	+ m_mLambdab( 5.624 ), // Lambda_b mass
	+ m_mLambda0( 1.115684 ), // Lambda0 mass
	+ m_c7Eff( -0.31 ), // Wilson coefficient
	+ m_mb( 4.4 ), // running b mass
	+ m_mV( 5.42 ), // pole mass vector current
	+ m_mA( 5.86 ), // pole mass axial current
	+ m_GF( 1.166E-5 ), // Fermi constant
	+ m_gLambdab( 16 ), // coupling constant Lambda_b -> B- p
	+ m_e0( 1 ), // electromagnetic coupling (+1)
	+ m_g1( 0.64 ), // heavy-light form factors at q_mSqare
	+ m_g2( -0.10 ),
	+ m_f1( 0.64 ),
	+ m_f2( -0.31 ),
	+ m_VtbVtsStar( 0.038 ) // \|V_tb V_ts^*\|
	{
	}

	@@ -104,16 +104,16 @@
	photonPol.get( mu ) *
	photonMomentum.get( nu );

	- EvtComplex amp = -I * _gLambdab * lambdaPol.adjoint() *
	+ EvtComplex amp = -I * m_gLambdab * lambdaPol.adjoint() *
	( ( constA() * EvtGammaMatrix::id() +
	constB() * EvtGammaMatrix::g5() ) *
	photonGamma *
	( EvtGenFunctions::slash( lambdaMomentum ) +
	EvtGenFunctions::slash( photonMomentum ) +
	- _mLambdab * EvtGammaMatrix::id() ) /
	+ m_mLambdab * EvtGammaMatrix::id() ) /
	( ( lambdaMomentum + photonMomentum ) *
	( lambdaMomentum + photonMomentum ) -
	- _mLambdab * _mLambdab ) *
	+ m_mLambdab * m_mLambdab ) *
	EvtGammaMatrix::g5() * antiP_Pol );
	// use of parentheses so I do not have to define EvtDiracSpinor*EvtGammaMatrix, which shouldn't be defined to prevent errors in indexing

	@@ -132,24 +132,26 @@
	// form factors at 0
	double EvtLambdaP_BarGamma::f0( double fqm, int n ) const
	{
	- return fqm * pow( 1 - pow( _mLambdab - _mLambda0, 2 ) / ( _mV * _mV ), n );
	+ return fqm *
	+ pow( 1 - pow( m_mLambdab - m_mLambda0, 2 ) / ( m_mV * m_mV ), n );
	}

	double EvtLambdaP_BarGamma::g0( double gqm, int n ) const
	{
	- return gqm * pow( 1 - pow( _mLambdab - _mLambda0, 2 ) / ( _mA * _mA ), n );
	+ return gqm *
	+ pow( 1 - pow( m_mLambdab - m_mLambda0, 2 ) / ( m_mA * m_mA ), n );
	}

	double EvtLambdaP_BarGamma::constA() const
	{
	- return _GF / sqrt( 2. ) * _e0 / ( 8 * EvtConst::pi * EvtConst::pi ) * 2 *
	- _c7Eff * _mb * _VtbVtsStar * ( f0( _f1 ) - f0( _f2 ) );
	+ return m_GF / sqrt( 2. ) * m_e0 / ( 8 * EvtConst::pi * EvtConst::pi ) * 2 *
	+ m_c7Eff * m_mb * m_VtbVtsStar * ( f0( m_f1 ) - f0( m_f2 ) );
	}

	double EvtLambdaP_BarGamma::constB() const
	{
	- return _GF / sqrt( 2. ) * _e0 / ( 8 * EvtConst::pi * EvtConst::pi ) * 2 *
	- _c7Eff * _mb * _VtbVtsStar *
	- ( g0( _g1 ) - ( _mLambdab - _mLambda0 ) / ( _mLambdab + _mLambda0 ) *
	- g0( _g2 ) );
	+ return m_GF / sqrt( 2. ) * m_e0 / ( 8 * EvtConst::pi * EvtConst::pi ) * 2 *
	+ m_c7Eff * m_mb * m_VtbVtsStar *
	+ ( g0( m_g1 ) - ( m_mLambdab - m_mLambda0 ) /
	+ ( m_mLambdab + m_mLambda0 ) * g0( m_g2 ) );
	}
	diff --git a/src/EvtGenModels/EvtLambdacPHH.cpp b/src/EvtGenModels/EvtLambdacPHH.cpp
	--- a/src/EvtGenModels/EvtLambdacPHH.cpp
	+++ b/src/EvtGenModels/EvtLambdacPHH.cpp
	@@ -35,51 +35,51 @@
	#include <utility>

	EvtLambdacPHH::EvtLambdacPHH() :
	- _d1( 0 ),
	- _d2( 1 ),
	- _d3( 3 ),
	- _Nplusplus( 0.46 ),
	- _Nplusminus( 1.0 ),
	- _Nminusplus( 0.18 ),
	- _Nminusminus( 0.94 ),
	- _phiNplusplus( 3.48 ),
	- _phiNplusminus( 0.00 ),
	- _phiNminusplus( 0.75 ),
	- _phiNminusminus( 1.13 ),
	- _E1( 0.52 ),
	- _phiE1( -1.01 ),
	- _E2( 0.20 ),
	- _phiE2( 2.35 ),
	- _E3( 0.21 ),
	- _phiE3( 3.46 ),
	- _E4( 0.16 ),
	- _phiE4( 5.29 ),
	- _F1( 0.17 ),
	- _phiF1( 4.98 ),
	- _F2( 0.38 ),
	- _phiF2( 4.88 ),
	- _H1( 0.18 ),
	- _phiH1( 5.93 ),
	- _H2( 0.20 ),
	- _phiH2( -0.06 ),
	- _NRNorm( 1.0 ),
	- _KstarNorm( 1.0 ),
	- _DeltaNorm( 1.0 ),
	- _LambdaNorm( 1.0 ),
	- _KstarM( 0.890 ),
	- _KstarW( 0.0498 ),
	- _KstarR( 3.40 ),
	- _DeltaM( 1.232 ),
	- _DeltaW( 0.1120 ),
	- _DeltaR( 5.22 ),
	- _LambdaM( 1.520 ),
	- _LambdaW( 0.0156 ),
	- _LambdaR( 6.29 ),
	- _Lambda_cR( 5.07 ),
	- _zprime(),
	- _p4_Lambda_c(),
	- _zpMag( 0.0 ),
	- _p4_Lambdac_Mag( 0.0 )
	+ m_d1( 0 ),
	+ m_d2( 1 ),
	+ m_d3( 3 ),
	+ m_Nplusplus( 0.46 ),
	+ m_Nplusminus( 1.0 ),
	+ m_Nminusplus( 0.18 ),
	+ m_Nminusminus( 0.94 ),
	+ m_phiNplusplus( 3.48 ),
	+ m_phiNplusminus( 0.00 ),
	+ m_phiNminusplus( 0.75 ),
	+ m_phiNminusminus( 1.13 ),
	+ m_E1( 0.52 ),
	+ m_phiE1( -1.01 ),
	+ m_E2( 0.20 ),
	+ m_phiE2( 2.35 ),
	+ m_E3( 0.21 ),
	+ m_phiE3( 3.46 ),
	+ m_E4( 0.16 ),
	+ m_phiE4( 5.29 ),
	+ m_F1( 0.17 ),
	+ m_phiF1( 4.98 ),
	+ m_F2( 0.38 ),
	+ m_phiF2( 4.88 ),
	+ m_H1( 0.18 ),
	+ m_phiH1( 5.93 ),
	+ m_H2( 0.20 ),
	+ m_phiH2( -0.06 ),
	+ m_NRNorm( 1.0 ),
	+ m_KstarNorm( 1.0 ),
	+ m_DeltaNorm( 1.0 ),
	+ m_LambdaNorm( 1.0 ),
	+ m_KstarM( 0.890 ),
	+ m_KstarW( 0.0498 ),
	+ m_KstarR( 3.40 ),
	+ m_DeltaM( 1.232 ),
	+ m_DeltaW( 0.1120 ),
	+ m_DeltaR( 5.22 ),
	+ m_LambdaM( 1.520 ),
	+ m_LambdaW( 0.0156 ),
	+ m_LambdaR( 6.29 ),
	+ m_Lambda_cR( 5.07 ),
	+ m_zprime(),
	+ m_p4_Lambda_c(),
	+ m_zpMag( 0.0 ),
	+ m_p4_Lambdac_Mag( 0.0 )
	{
	// Fermilab E791 values from MINUIT fit arXiv:hep-ex/9912003v1
	}
	@@ -146,9 +146,9 @@
	if ( parnum == LAMBDAC \|\| parnum == LAMBDACB ) {
	if ( daughters[0].first == KM && daughters[1].first == PIP &&
	daughters[2].first == PROTON ) {
	- _d1 = daughters[0].second;
	- _d2 = daughters[1].second;
	- _d3 = daughters[2].second;
	+ m_d1 = daughters[0].second;
	+ m_d2 = daughters[1].second;
	+ m_d3 = daughters[2].second;
	}
	}

	@@ -183,15 +183,15 @@
	// Generate uniform 4 momenta
	EvtGenKine::PhaseSpace( nDaug, mDaug, p4Daug, mParent );

	- EvtResonance2 LambdacpKpi1( p0, p4Daug[0], p4Daug[1], 1.0, 0.0, _KstarW,
	- _KstarM, 1, true, _KstarR,
	- _Lambda_cR ); // K*0 -> K- and pi+; L = 1
	- EvtResonance2 LambdacpKpi2( p0, p4Daug[2], p4Daug[1], 1.0, 0.0, _DeltaW,
	- _DeltaM, 1, true, _DeltaR,
	- _Lambda_cR ); // Delta++ -> p and pi+; L = 1
	+ EvtResonance2 LambdacpKpi1( p0, p4Daug[0], p4Daug[1], 1.0, 0.0,
	+ m_KstarW, m_KstarM, 1, true, m_KstarR,
	+ m_Lambda_cR ); // K*0 -> K- and pi+; L = 1
	+ EvtResonance2 LambdacpKpi2( p0, p4Daug[2], p4Daug[1], 1.0, 0.0,
	+ m_DeltaW, m_DeltaM, 1, true, m_DeltaR,
	+ m_Lambda_cR ); // Delta++ -> p and pi+; L = 1
	EvtResonance2 LambdacpKpi3(
	- p0, p4Daug[2], p4Daug[0], 1.0, 0.0, _LambdaW, _LambdaM, 2, true,
	- _LambdaR, _Lambda_cR ); // Lambda(1520) -> K- and p; L = 2
	+ p0, p4Daug[2], p4Daug[0], 1.0, 0.0, m_LambdaW, m_LambdaM, 2, true,
	+ m_LambdaR, m_Lambda_cR ); // Lambda(1520) -> K- and p; L = 2

	// Sum amplitude magnitude squared
	norm[0] += abs2( LambdacpKpi1.resAmpl() );
	@@ -203,20 +203,20 @@
	double N0( N * 1.0 );

	// Scale NR to get sensible relative fit fractions
	- _NRNorm = 1.0 / 3.0;
	+ m_NRNorm = 1.0 / 3.0;
	// Set this using a decay file parameter if required
	if ( getNArg() > 1 ) {
	- _NRNorm = getArg( 1 );
	+ m_NRNorm = getArg( 1 );
	}

	if ( norm[0] > 0.0 ) {
	- _KstarNorm = sqrt( N0 / norm[0] );
	+ m_KstarNorm = sqrt( N0 / norm[0] );
	}
	if ( norm[1] > 0.0 ) {
	- _DeltaNorm = sqrt( N0 / norm[1] );
	+ m_DeltaNorm = sqrt( N0 / norm[1] );
	}
	if ( norm[2] > 0.0 ) {
	- _LambdaNorm = sqrt( N0 / norm[2] );
	+ m_LambdaNorm = sqrt( N0 / norm[2] );
	}
	}

	@@ -247,24 +247,24 @@

	EvtResonance2 LambdacpKpi0( p0, p4Daug[0], p4Daug[1], 1.0, 0.0, 0.0, 0.0,
	0, true, 0.0, 0.0 ); // Non resonant (NR)
	- EvtResonance2 LambdacpKpi1( p0, p4Daug[0], p4Daug[1], 1.0, 0.0, _KstarW,
	- _KstarM, 1, true, _KstarR,
	- _Lambda_cR ); // K*0 -> K- and pi+; L = 1
	- EvtResonance2 LambdacpKpi2( p0, p4Daug[2], p4Daug[1], 1.0, 0.0, _DeltaW,
	- _DeltaM, 1, true, _DeltaR,
	- _Lambda_cR ); // Delta++ -> p and pi+; L = 1
	+ EvtResonance2 LambdacpKpi1( p0, p4Daug[0], p4Daug[1], 1.0, 0.0,
	+ m_KstarW, m_KstarM, 1, true, m_KstarR,
	+ m_Lambda_cR ); // K*0 -> K- and pi+; L = 1
	+ EvtResonance2 LambdacpKpi2( p0, p4Daug[2], p4Daug[1], 1.0, 0.0,
	+ m_DeltaW, m_DeltaM, 1, true, m_DeltaR,
	+ m_Lambda_cR ); // Delta++ -> p and pi+; L = 1
	EvtResonance2 LambdacpKpi3(
	- p0, p4Daug[2], p4Daug[0], 1.0, 0.0, _LambdaW, _LambdaM, 2, true,
	- _LambdaR, _Lambda_cR ); // Lambda(1520) -> K- and p; L = 2
	+ p0, p4Daug[2], p4Daug[0], 1.0, 0.0, m_LambdaW, m_LambdaM, 2, true,
	+ m_LambdaR, m_Lambda_cR ); // Lambda(1520) -> K- and p; L = 2

	std::vector<EvtComplex> ampNonRes =
	- calcResAmpTerms( EvtLambdacPHH::NonReson, LambdacpKpi0, _NRNorm );
	+ calcResAmpTerms( LcResLabel::NonReson, LambdacpKpi0, m_NRNorm );
	std::vector<EvtComplex> ampKstar =
	- calcResAmpTerms( EvtLambdacPHH::Kstar, LambdacpKpi1, _KstarNorm );
	+ calcResAmpTerms( LcResLabel::Kstar, LambdacpKpi1, m_KstarNorm );
	std::vector<EvtComplex> ampDelta =
	- calcResAmpTerms( EvtLambdacPHH::Delta, LambdacpKpi2, _DeltaNorm );
	+ calcResAmpTerms( LcResLabel::Delta, LambdacpKpi2, m_DeltaNorm );
	std::vector<EvtComplex> ampLambda =
	- calcResAmpTerms( EvtLambdacPHH::Lambda, LambdacpKpi3, _LambdaNorm );
	+ calcResAmpTerms( LcResLabel::Lambda, LambdacpKpi3, m_LambdaNorm );

	// Combine resonance amplitudes for a given spin configuration
	EvtComplex amp00 = ampNonRes[0] + ampKstar[0] + ampDelta[0] +
	@@ -316,23 +316,23 @@

	// 4-momenta in the rest frame of the Lambda_c
	EvtVector4R p4_p( p->mass(), 0.0, 0.0, 0.0 );
	- EvtVector4R moms1 = p->getDaug( _d1 )->getP4();
	- EvtVector4R moms2 = p->getDaug( _d2 )->getP4();
	- EvtVector4R moms3 = p->getDaug( _d3 )->getP4();
	+ EvtVector4R moms1 = p->getDaug( m_d1 )->getP4();
	+ EvtVector4R moms2 = p->getDaug( m_d2 )->getP4();
	+ EvtVector4R moms3 = p->getDaug( m_d3 )->getP4();

	// Lambda_c decay mode resonances. Spin L values from strong decay parity conservation:
	// parity(resonance) = parity(daug1)parity(daug2)(-1)^L
	EvtResonance2 LambdacpKpi0( p4_p, moms1, moms2, 1.0, 0.0, 0.0, 0.0, 0, true,
	0.0, 0.0 ); // Non-resonant L = 0
	- EvtResonance2 LambdacpKpi1( p4_p, moms1, moms2, 1.0, 0.0, _KstarW, _KstarM,
	- 1, true, _KstarR,
	- _Lambda_cR ); // K*0 -> K- and pi+; L = 1
	- EvtResonance2 LambdacpKpi2( p4_p, moms3, moms2, 1.0, 0.0, _DeltaW, _DeltaM,
	- 1, true, _DeltaR,
	- _Lambda_cR ); // Delta++ -> p and pi+; L = 1
	- EvtResonance2 LambdacpKpi3( p4_p, moms3, moms1, 1.0, 0.0, _LambdaW,
	- _LambdaM, 2, true, _LambdaR,
	- _Lambda_cR ); // Lambda(1520) -> K- and p; L = 2
	+ EvtResonance2 LambdacpKpi1( p4_p, moms1, moms2, 1.0, 0.0, m_KstarW,
	+ m_KstarM, 1, true, m_KstarR,
	+ m_Lambda_cR ); // K*0 -> K- and pi+; L = 1
	+ EvtResonance2 LambdacpKpi2( p4_p, moms3, moms2, 1.0, 0.0, m_DeltaW,
	+ m_DeltaM, 1, true, m_DeltaR,
	+ m_Lambda_cR ); // Delta++ -> p and pi+; L = 1
	+ EvtResonance2 LambdacpKpi3( p4_p, moms3, moms1, 1.0, 0.0, m_LambdaW,
	+ m_LambdaM, 2, true, m_LambdaR,
	+ m_Lambda_cR ); // Lambda(1520) -> K- and p; L = 2

	// Define the "beam" direction, used in Fig 1 of hep-ex/9912003v1
	EvtVector4R beam( 0.0, 0.0, 0.0, 1.0 );
	@@ -344,34 +344,34 @@
	beam = p4_Lambda_c_mother;
	}

	- _p4_Lambda_c = p->getP4Lab();
	- _p4_Lambdac_Mag = _p4_Lambda_c.d3mag();
	+ m_p4_Lambda_c = p->getP4Lab();
	+ m_p4_Lambdac_Mag = m_p4_Lambda_c.d3mag();

	// Define the unit vector denoting the "z" axis in Fig 1
	- _zprime = -1.0 * _p4_Lambda_c.cross( beam );
	- _zprime.applyBoostTo( _p4_Lambda_c, true ); // From lab frame to Lambda_c
	+ m_zprime = -1.0 * m_p4_Lambda_c.cross( beam );
	+ m_zprime.applyBoostTo( m_p4_Lambda_c, true ); // From lab frame to Lambda_c

	- _zpMag = _zprime.d3mag();
	+ m_zpMag = m_zprime.d3mag();
	// Check if zprime magnitude is non-zero
	- if ( _zpMag > 0.0 ) {
	+ if ( m_zpMag > 0.0 ) {
	// Normalise
	- _zprime /= _zpMag;
	+ m_zprime /= m_zpMag;
	} else {
	// Set as the z direction
	- _zprime.set( 0.0, 0.0, 0.0, 1.0 );
	+ m_zprime.set( 0.0, 0.0, 0.0, 1.0 );
	}
	// Update normalised \|z'\|
	- _zpMag = 1.0;
	+ m_zpMag = 1.0;

	// Get the amplitudes: non-resonant, K*, Delta and Lambda
	- std::vector<EvtComplex> ampNonRes = calcResAmpTerms( EvtLambdacPHH::NonReson,
	- LambdacpKpi0, _NRNorm );
	+ std::vector<EvtComplex> ampNonRes =
	+ calcResAmpTerms( LcResLabel::NonReson, LambdacpKpi0, m_NRNorm );
	std::vector<EvtComplex> ampKstar =
	- calcResAmpTerms( EvtLambdacPHH::Kstar, LambdacpKpi1, _KstarNorm );
	+ calcResAmpTerms( LcResLabel::Kstar, LambdacpKpi1, m_KstarNorm );
	std::vector<EvtComplex> ampDelta =
	- calcResAmpTerms( EvtLambdacPHH::Delta, LambdacpKpi2, _DeltaNorm );
	+ calcResAmpTerms( LcResLabel::Delta, LambdacpKpi2, m_DeltaNorm );
	std::vector<EvtComplex> ampLambda =
	- calcResAmpTerms( EvtLambdacPHH::Lambda, LambdacpKpi3, _LambdaNorm );
	+ calcResAmpTerms( LcResLabel::Lambda, LambdacpKpi3, m_LambdaNorm );

	// Combine resonance amplitudes for a given spin configuration
	EvtComplex amp00 = ampNonRes[0] + ampKstar[0] + ampDelta[0] + ampLambda[0];
	@@ -404,7 +404,7 @@
	EvtComplex resAmp( norm, 0.0 );

	// Angles are not needed for the non-resonant amplitude
	- if ( resIndex != EvtLambdacPHH::NonReson ) {
	+ if ( resIndex != LcResLabel::NonReson ) {
	resAmp = res.resAmpl() * norm;
	// Resonance and daughter 4 momenta
	EvtVector4R p4d1 = res.p4_d1();
	@@ -415,7 +415,7 @@
	double p4ResMag = p4Res.d3mag();

	// 4-momenta for theta' and phi' angles
	- EvtVector4R yRes = -1.0 * p4_d3.cross( _zprime );
	+ EvtVector4R yRes = -1.0 * p4_d3.cross( m_zprime );

	EvtVector4R res_d1 = p4d1;
	res_d1.applyBoostTo( p4Res, true );
	@@ -435,10 +435,10 @@
	double Lc_atproton_mag = Lc_atproton.d3mag();

	// Check that the momentum of the Lambda_c is not zero, as well as a valid zprime vector
	- if ( _p4_Lambdac_Mag > 0.0 && _zpMag > 0.0 ) {
	- thetaRes = getACos( -1.0 * p4Res.dot( _zprime ), p4ResMag );
	- phiRes = getASin( -1.0 * p4Res.dot( _p4_Lambda_c ),
	- sin( thetaRes ) * _p4_Lambdac_Mag * p4ResMag );
	+ if ( m_p4_Lambdac_Mag > 0.0 && m_zpMag > 0.0 ) {
	+ thetaRes = getACos( -1.0 * p4Res.dot( m_zprime ), p4ResMag );
	+ phiRes = getASin( -1.0 * p4Res.dot( m_p4_Lambda_c ),
	+ sin( thetaRes ) * m_p4_Lambdac_Mag * p4ResMag );
	phiPrimeDaug = getASin( res_d1.dot( yRes ), sin( thetaPrimeDaug ) *
	res_d1_Mag *
	yRes.d3mag() );
	@@ -463,8 +463,7 @@
	}

	// Find the spin-dependent amplitudes
	- if ( resIndex == EvtLambdacPHH::NonReson \|\|
	- resIndex == EvtLambdacPHH::Kstar ) {
	+ if ( resIndex == LcResLabel::NonReson \|\| resIndex == LcResLabel::Kstar ) {
	term1 = resAmp * DecayAmp3( resIndex, 1, 1, thetaRes, phiRes,
	thetaPrimeDaug, phiPrimeDaug );
	term2 = resAmp * DecayAmp3( resIndex, 1, -1, thetaRes, phiRes,
	@@ -515,111 +514,111 @@
	// Wigner d-functions use 2*spin, e.g. d(1/2, 1/2, 1/2) -> d(1, 1, 1)
	EvtComplex term1( 0.0, 0.0 ), term2( 0.0, 0.0 );

	- if ( resonance == EvtLambdacPHH::NonReson ) {
	+ if ( resonance == LcResLabel::NonReson ) {
	// Non-resonant: table 6
	if ( m == 1 && mprime == 1 ) {
	- term1 = _Nplusplus *
	- EvtComplex( cos( _phiNplusplus ), sin( _phiNplusplus ) );
	+ term1 = m_Nplusplus *
	+ EvtComplex( cos( m_phiNplusplus ), sin( m_phiNplusplus ) );

	} else if ( m == 1 && mprime == -1 ) {
	- term1 = _Nplusminus *
	- EvtComplex( cos( _phiNplusminus ), sin( _phiNplusminus ) );
	+ term1 = m_Nplusminus * EvtComplex( cos( m_phiNplusminus ),
	+ sin( m_phiNplusminus ) );

	} else if ( m == -1 && mprime == 1 ) {
	- term1 = _Nminusplus *
	- EvtComplex( cos( _phiNminusplus ), sin( _phiNminusplus ) );
	+ term1 = m_Nminusplus * EvtComplex( cos( m_phiNminusplus ),
	+ sin( m_phiNminusplus ) );

	} else if ( m == -1 && mprime == -1 ) {
	- term1 = _Nminusminus * EvtComplex( cos( _phiNminusminus ),
	- sin( _phiNminusminus ) );
	+ term1 = m_Nminusminus * EvtComplex( cos( m_phiNminusminus ),
	+ sin( m_phiNminusminus ) );
	}

	- } else if ( resonance == EvtLambdacPHH::Kstar ) {
	+ } else if ( resonance == LcResLabel::Kstar ) {
	// K*0(1-) resonance: table 3
	if ( m == 1 && mprime == 1 ) {
	- term1 = fampl3( _E1, _phiE1, 1, 1, 1, theta_res, 2, 2, 0,
	+ term1 = fampl3( m_E1, m_phiE1, 1, 1, 1, theta_res, 2, 2, 0,
	theta_prime_daughter_res, phi_prime_daughter_res );
	- term2 = fampl3( _E2, _phiE2, 1, 1, -1, theta_res, 2, 0, 0,
	+ term2 = fampl3( m_E2, m_phiE2, 1, 1, -1, theta_res, 2, 0, 0,
	theta_prime_daughter_res, phi_res );

	} else if ( m == 1 && mprime == -1 ) {
	- term1 = fampl3( _E3, _phiE3, 1, 1, 1, theta_res, 2, 0, 0,
	+ term1 = fampl3( m_E3, m_phiE3, 1, 1, 1, theta_res, 2, 0, 0,
	theta_prime_daughter_res, 0.0 );
	- term2 = fampl3( _E4, _phiE4, 1, 1, -1, theta_res, 2, -2, 0,
	+ term2 = fampl3( m_E4, m_phiE4, 1, 1, -1, theta_res, 2, -2, 0,
	theta_prime_daughter_res,
	phi_res - phi_prime_daughter_res );

	} else if ( m == -1 && mprime == 1 ) {
	- term1 = fampl3( _E1, _phiE1, 1, -1, 1, theta_res, 2, 2, 0,
	+ term1 = fampl3( m_E1, m_phiE1, 1, -1, 1, theta_res, 2, 2, 0,
	theta_prime_daughter_res,
	-( phi_res - phi_prime_daughter_res ) );
	- term2 = fampl3( _E2, _phiE2, 1, -1, -1, theta_res, 2, 0, 0,
	+ term2 = fampl3( m_E2, m_phiE2, 1, -1, -1, theta_res, 2, 0, 0,
	theta_prime_daughter_res, 0.0 );

	} else if ( m == -1 && mprime == -1 ) {
	- term1 = fampl3( _E3, _phiE3, 1, -1, 1, theta_res, 2, 0, 0,
	+ term1 = fampl3( m_E3, m_phiE3, 1, -1, 1, theta_res, 2, 0, 0,
	theta_prime_daughter_res, -phi_res );
	- term2 = fampl3( _E4, _phiE4, 1, -1, -1, theta_res, 2, -2, 0,
	+ term2 = fampl3( m_E4, m_phiE4, 1, -1, -1, theta_res, 2, -2, 0,
	theta_prime_daughter_res, -phi_prime_daughter_res );
	}

	- } else if ( resonance == EvtLambdacPHH::Delta ) {
	+ } else if ( resonance == LcResLabel::Delta ) {
	// Delta++(3/2+) resonance: table 4
	if ( m == 1 && mprime == 1 ) {
	- term1 = fampl3( _F1, _phiF1, 1, 1, 1, theta_res, 3, 1, 1,
	+ term1 = fampl3( m_F1, m_phiF1, 1, 1, 1, theta_res, 3, 1, 1,
	theta_prime_daughter_res, 0.0 );
	- term2 = fampl3( _F2, _phiF2, 1, 1, -1, theta_res, 3, -1, 1,
	+ term2 = fampl3( m_F2, m_phiF2, 1, 1, -1, theta_res, 3, -1, 1,
	theta_prime_daughter_res,
	phi_res - phi_prime_daughter_res );

	} else if ( m == 1 && mprime == -1 ) {
	- term1 = fampl3( _F1, _phiF1, 1, 1, 1, theta_res, 3, 1, -1,
	+ term1 = fampl3( m_F1, m_phiF1, 1, 1, 1, theta_res, 3, 1, -1,
	theta_prime_daughter_res, phi_prime_daughter_res );
	- term2 = fampl3( _F2, _phiF2, 1, 1, -1, theta_res, 3, -1, -1,
	+ term2 = fampl3( m_F2, m_phiF2, 1, 1, -1, theta_res, 3, -1, -1,
	theta_prime_daughter_res, phi_res );

	} else if ( m == -1 && mprime == 1 ) {
	- term1 = fampl3( _F1, _phiF1, 1, -1, 1, theta_res, 3, 1, 1,
	+ term1 = fampl3( m_F1, m_phiF1, 1, -1, 1, theta_res, 3, 1, 1,
	theta_prime_daughter_res, -phi_res );
	- term2 = fampl3( _F2, _phiF2, 1, -1, -1, theta_res, 3, -1, 1,
	+ term2 = fampl3( m_F2, m_phiF2, 1, -1, -1, theta_res, 3, -1, 1,
	theta_prime_daughter_res, -phi_prime_daughter_res );

	} else if ( m == -1 && mprime == -1 ) {
	- term1 = fampl3( _F1, _phiF1, 1, -1, 1, theta_res, 3, 1, -1,
	+ term1 = fampl3( m_F1, m_phiF1, 1, -1, 1, theta_res, 3, 1, -1,
	theta_prime_daughter_res,
	-( phi_res - phi_prime_daughter_res ) );
	- term2 = fampl3( _F2, _phiF2, 1, -1, -1, theta_res, 3, -1, -1,
	+ term2 = fampl3( m_F2, m_phiF2, 1, -1, -1, theta_res, 3, -1, -1,
	theta_prime_daughter_res, 0.0 );
	}

	- } else if ( resonance == EvtLambdacPHH::Lambda ) {
	+ } else if ( resonance == LcResLabel::Lambda ) {
	// Lambda(1520)(3/2-) resonance: table 5
	if ( m == 1 && mprime == 1 ) {
	- term1 = fampl3( _H1, _phiH1, 1, 1, 1, theta_res, 3, 1, 1,
	+ term1 = fampl3( m_H1, m_phiH1, 1, 1, 1, theta_res, 3, 1, 1,
	theta_prime_daughter_res, 0.0 );
	- term2 = fampl3( _H2, _phiH2, 1, 1, -1, theta_res, 3, -1, 1,
	+ term2 = fampl3( m_H2, m_phiH2, 1, 1, -1, theta_res, 3, -1, 1,
	theta_prime_daughter_res,
	phi_res - phi_prime_daughter_res );

	} else if ( m == 1 && mprime == -1 ) {
	- term1 = -1.0 * fampl3( _H1, _phiH1, 1, 1, 1, theta_res, 3, 1, -1,
	+ term1 = -1.0 * fampl3( m_H1, m_phiH1, 1, 1, 1, theta_res, 3, 1, -1,
	theta_prime_daughter_res,
	phi_prime_daughter_res );
	- term2 = -1.0 * fampl3( _H2, _phiH2, 1, 1, -1, theta_res, 3, -1, -1,
	- theta_prime_daughter_res, phi_res );
	+ term2 = -1.0 * fampl3( m_H2, m_phiH2, 1, 1, -1, theta_res, 3, -1,
	+ -1, theta_prime_daughter_res, phi_res );

	} else if ( m == -1 && mprime == 1 ) {
	- term1 = fampl3( _H1, _phiH1, 1, -1, 1, theta_res, 3, 1, 1,
	+ term1 = fampl3( m_H1, m_phiH1, 1, -1, 1, theta_res, 3, 1, 1,
	theta_prime_daughter_res, -phi_res );
	- term2 = fampl3( _H2, _phiH2, 1, -1, -1, theta_res, 3, -1, 1,
	+ term2 = fampl3( m_H2, m_phiH2, 1, -1, -1, theta_res, 3, -1, 1,
	theta_prime_daughter_res, -phi_prime_daughter_res );

	} else if ( m == -1 && mprime == -1 ) {
	- term1 = -1.0 * fampl3( _H1, _phiH1, 1, -1, 1, theta_res, 3, 1, -1,
	+ term1 = -1.0 * fampl3( m_H1, m_phiH1, 1, -1, 1, theta_res, 3, 1, -1,
	theta_prime_daughter_res,
	-( phi_res - phi_prime_daughter_res ) );
	- term2 = -1.0 * fampl3( _H2, _phiH2, 1, -1, -1, theta_res, 3, -1, -1,
	- theta_prime_daughter_res, 0.0 );
	+ term2 = -1.0 * fampl3( m_H2, m_phiH2, 1, -1, -1, theta_res, 3, -1,
	+ -1, theta_prime_daughter_res, 0.0 );
	}
	}

	diff --git a/src/EvtGenModels/EvtLb2Baryonlnu.cpp b/src/EvtGenModels/EvtLb2Baryonlnu.cpp
	--- a/src/EvtGenModels/EvtLb2Baryonlnu.cpp
	+++ b/src/EvtGenModels/EvtLb2Baryonlnu.cpp
	@@ -37,16 +37,16 @@
	#ifdef D0
	#undef D0
	#endif
	-EvtLb2Baryonlnu::EvtLb2Baryonlnu() : ffmodel( nullptr ), calcamp( nullptr )
	+EvtLb2Baryonlnu::EvtLb2Baryonlnu() : m_ffmodel( nullptr ), m_calcamp( nullptr )
	{
	}

	EvtLb2Baryonlnu::~EvtLb2Baryonlnu()
	{
	- delete ffmodel;
	- ffmodel = nullptr;
	- delete calcamp;
	- calcamp = nullptr;
	+ delete m_ffmodel;
	+ m_ffmodel = nullptr;
	+ delete m_calcamp;
	+ m_calcamp = nullptr;
	}

	std::string EvtLb2Baryonlnu::getName()
	@@ -77,7 +77,7 @@
	EvtComplex r10( getArg( 2 ), 0.0 );
	EvtComplex r11( getArg( 3 ), 0.0 );

	- calcamp->CalcAmp( p, _amp2, ffmodel, r00, r01, r10, r11 );
	+ m_calcamp->CalcAmp( p, m_amp2, m_ffmodel, r00, r01, r10, r11 );
	}

	void EvtLb2Baryonlnu::initProbMax()
	@@ -207,12 +207,12 @@
	::abort();
	}

	- //set ffmodel
	- ffmodel = new EvtLb2BaryonlnuFF;
	+ //set m_ffmodel
	+ m_ffmodel = new EvtLb2BaryonlnuFF;

	if ( baryontype == EvtSpinType::DIRAC \|\|
	baryontype == EvtSpinType::RARITASCHWINGER ) {
	- calcamp = new EvtSLBaryonAmp;
	+ m_calcamp = new EvtSLBaryonAmp;
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Wrong baryon spin type in EvtLb2Baryonlnu.cc "
	diff --git a/src/EvtGenModels/EvtLb2plnuLCSR.cpp b/src/EvtGenModels/EvtLb2plnuLCSR.cpp
	--- a/src/EvtGenModels/EvtLb2plnuLCSR.cpp
	+++ b/src/EvtGenModels/EvtLb2plnuLCSR.cpp
	@@ -37,16 +37,16 @@
	#ifdef D0
	#undef D0
	#endif
	-EvtLb2plnuLCSR::EvtLb2plnuLCSR() : ffmodel( nullptr ), calcamp( nullptr )
	+EvtLb2plnuLCSR::EvtLb2plnuLCSR() : m_ffmodel( nullptr ), m_calcamp( nullptr )
	{
	}

	EvtLb2plnuLCSR::~EvtLb2plnuLCSR()
	{
	- delete ffmodel;
	- ffmodel = nullptr;
	- delete calcamp;
	- calcamp = nullptr;
	+ delete m_ffmodel;
	+ m_ffmodel = nullptr;
	+ delete m_calcamp;
	+ m_calcamp = nullptr;
	}

	std::string EvtLb2plnuLCSR::getName()
	@@ -77,7 +77,7 @@
	EvtComplex r10( getArg( 2 ), 0.0 );
	EvtComplex r11( getArg( 3 ), 0.0 );

	- calcamp->CalcAmp( p, _amp2, ffmodel, r00, r01, r10, r11 );
	+ m_calcamp->CalcAmp( p, m_amp2, m_ffmodel, r00, r01, r10, r11 );
	}

	void EvtLb2plnuLCSR::initProbMax()
	@@ -158,11 +158,11 @@
	::abort();
	}

	- //set ffmodel
	- ffmodel = new EvtLb2plnuLCSRFF;
	+ //set m_ffmodel
	+ m_ffmodel = new EvtLb2plnuLCSRFF;

	if ( baryontype == EvtSpinType::DIRAC ) {
	- calcamp = new EvtSLBaryonAmp;
	+ m_calcamp = new EvtSLBaryonAmp;
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Wrong baryon spin type in EvtLb2plnuLCSR.cc "
	diff --git a/src/EvtGenModels/EvtLb2plnuLQCD.cpp b/src/EvtGenModels/EvtLb2plnuLQCD.cpp
	--- a/src/EvtGenModels/EvtLb2plnuLQCD.cpp
	+++ b/src/EvtGenModels/EvtLb2plnuLQCD.cpp
	@@ -37,16 +37,16 @@
	#ifdef D0
	#undef D0
	#endif
	-EvtLb2plnuLQCD::EvtLb2plnuLQCD() : ffmodel( nullptr ), calcamp( nullptr )
	+EvtLb2plnuLQCD::EvtLb2plnuLQCD() : m_ffmodel( nullptr ), m_calcamp( nullptr )
	{
	}

	EvtLb2plnuLQCD::~EvtLb2plnuLQCD()
	{
	- delete ffmodel;
	- ffmodel = nullptr;
	- delete calcamp;
	- calcamp = nullptr;
	+ delete m_ffmodel;
	+ m_ffmodel = nullptr;
	+ delete m_calcamp;
	+ m_calcamp = nullptr;
	}

	std::string EvtLb2plnuLQCD::getName()
	@@ -77,7 +77,7 @@
	EvtComplex r10( getArg( 2 ), 0.0 );
	EvtComplex r11( getArg( 3 ), 0.0 );

	- calcamp->CalcAmp( p, _amp2, ffmodel, r00, r01, r10, r11 );
	+ m_calcamp->CalcAmp( p, m_amp2, m_ffmodel, r00, r01, r10, r11 );
	}

	void EvtLb2plnuLQCD::initProbMax()
	@@ -158,11 +158,11 @@
	::abort();
	}

	- //set ffmodel
	- ffmodel = new EvtLb2plnuLQCDFF;
	+ //set m_ffmodel
	+ m_ffmodel = new EvtLb2plnuLQCDFF;

	if ( baryontype == EvtSpinType::DIRAC ) {
	- calcamp = new EvtSLBaryonAmp;
	+ m_calcamp = new EvtSLBaryonAmp;
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Wrong baryon spin type in EvtLb2plnuLQCD.cc "
	diff --git a/src/EvtGenModels/EvtMelikhov.cpp b/src/EvtGenModels/EvtMelikhov.cpp
	--- a/src/EvtGenModels/EvtMelikhov.cpp
	+++ b/src/EvtGenModels/EvtMelikhov.cpp
	@@ -45,7 +45,7 @@
	void EvtMelikhov::decay( EvtParticle* p )
	{
	p->initializePhaseSpace( getNDaug(), getDaugs() );
	- calcamp->CalcAmp( p, _amp2, Melikhovffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_Melikhovffmodel.get() );
	}

	void EvtMelikhov::init()
	@@ -62,8 +62,8 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::NEUTRINO );

	- Melikhovffmodel = std::make_unique<EvtMelikhovFF>( getArg( 0 ) );
	- calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_Melikhovffmodel = std::make_unique<EvtMelikhovFF>( getArg( 0 ) );
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	}

	void EvtMelikhov::initProbMax()
	diff --git a/src/EvtGenModels/EvtMelikhovFF.cpp b/src/EvtGenModels/EvtMelikhovFF.cpp
	--- a/src/EvtGenModels/EvtMelikhovFF.cpp
	+++ b/src/EvtGenModels/EvtMelikhovFF.cpp
	@@ -31,7 +31,7 @@

	EvtMelikhovFF::EvtMelikhovFF( double arg1 )
	{
	- whichfit = int( arg1 + 0.1 );
	+ m_whichfit = int( arg1 + 0.1 );
	}

	void EvtMelikhovFF::getvectorff( EvtId parent, EvtId, double t, double mass,
	@@ -42,7 +42,7 @@
	double ma2( 0.0 ), ra2( 0.0 ), na2( 0.0 );
	double mv( 0.0 ), rv( 0.0 ), nv( 0.0 );

	- if ( whichfit == 1 ) {
	+ if ( m_whichfit == 1 ) {
	ma1 = 7.07;
	ra1 = 0.27;
	na1 = 2.65;
	@@ -53,7 +53,7 @@
	rv = 0.30;
	nv = 2.36;
	}
	- if ( whichfit == 2 ) {
	+ if ( m_whichfit == 2 ) {
	ma1 = 6.78;
	ra1 = 0.20;
	na1 = 2.65;
	@@ -64,7 +64,7 @@
	rv = 0.20;
	nv = 2.46;
	}
	- if ( whichfit == 3 ) {
	+ if ( m_whichfit == 3 ) {
	ma1 = 6.50;
	ra1 = 0.21;
	na1 = 2.70;
	@@ -75,7 +75,7 @@
	rv = 0.21;
	nv = 2.35;
	}
	- if ( whichfit == 4 ) {
	+ if ( m_whichfit == 4 ) {
	ma1 = 5.68;
	ra1 = 0.29;
	na1 = 1.67;
	diff --git a/src/EvtGenModels/EvtPFermi.cpp b/src/EvtGenModels/EvtPFermi.cpp
	--- a/src/EvtGenModels/EvtPFermi.cpp
	+++ b/src/EvtGenModels/EvtPFermi.cpp
	@@ -33,16 +33,16 @@
	//for DFN model
	EvtPFermi::EvtPFermi( const double& a, const double& mB, const double& mb )
	{
	- _a = a;
	- _mb = mb;
	- _mB = mB;
	+ m_a = a;
	+ m_mb = mb;
	+ m_mB = mB;
	}

	// for BLNP modell
	EvtPFermi::EvtPFermi( const double& Lambda, const double& b )
	{
	- _Lambda = Lambda;
	- _b = b;
	+ m_Lambda = Lambda;
	+ m_b = b;
	}

	//-----------
	@@ -52,14 +52,14 @@
	double EvtPFermi::getFPFermi( const double& kplus )
	{
	double FKplus;
	- double x = kplus / ( _mB - _mb );
	+ double x = kplus / ( m_mB - m_mb );

	if ( x >= 1 )
	return 0;
	- if ( kplus <= -_mb )
	+ if ( kplus <= -m_mb )
	return 0;

	- FKplus = pow( 1 - x, _a ) * exp( ( 1 + _a ) * x );
	+ FKplus = pow( 1 - x, m_a ) * exp( ( 1 + m_a ) * x );

	return FKplus;
	}
	@@ -82,8 +82,8 @@
	<< "Presumably, you are getting the wrong answer, so I abort..";
	::abort();
	#else
	- SF = pow( _b, _b ) / ( tgamma( _b ) * _Lambda ) *
	- pow( what / _Lambda, _b - 1 ) * exp( -_b * what / _Lambda );
	+ SF = pow( m_b, m_b ) / ( tgamma( m_b ) * m_Lambda ) *
	+ pow( what / m_Lambda, m_b - 1 ) * exp( -m_b * what / m_Lambda );
	#endif

	return SF;
	diff --git a/src/EvtGenModels/EvtPVVCPLH.cpp b/src/EvtGenModels/EvtPVVCPLH.cpp
	--- a/src/EvtGenModels/EvtPVVCPLH.cpp
	+++ b/src/EvtGenModels/EvtPVVCPLH.cpp
	@@ -171,7 +171,7 @@
	AP = ( cG1P + cG1M ) / sqrt( 2.0 );
	AM = ( cG1P - cG1M ) / sqrt( 2.0 );

	- EvtSVVHelAmp::SVVHel( p, _amp2, getDaug( 0 ), getDaug( 1 ), AP, A0, AM );
	+ EvtSVVHelAmp::SVVHel( p, m_amp2, getDaug( 0 ), getDaug( 1 ), AP, A0, AM );

	return;
	}
	diff --git a/src/EvtGenModels/EvtPartWave.cpp b/src/EvtGenModels/EvtPartWave.cpp
	--- a/src/EvtGenModels/EvtPartWave.cpp
	+++ b/src/EvtGenModels/EvtPartWave.cpp
	@@ -52,93 +52,87 @@
	checkNDaug( 2 );

	//find out how many states each particle have
	- int _nA = EvtSpinType::getSpinStates( EvtPDL::getSpinType( getParentId() ) );
	- int _nB = EvtSpinType::getSpinStates( EvtPDL::getSpinType( getDaug( 0 ) ) );
	- int _nC = EvtSpinType::getSpinStates( EvtPDL::getSpinType( getDaug( 1 ) ) );
	+ int nA = EvtSpinType::getSpinStates( EvtPDL::getSpinType( getParentId() ) );
	+ int nB = EvtSpinType::getSpinStates( EvtPDL::getSpinType( getDaug( 0 ) ) );
	+ int nC = EvtSpinType::getSpinStates( EvtPDL::getSpinType( getDaug( 1 ) ) );

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "_nA,_nB,_nC:" << _nA << "," << _nB << "," << _nC << endl;
	+ << "nA,nB,nC:" << nA << "," << nB << "," << nC << endl;
	}

	//find out what 2 times the spin is
	- int _JA2 = EvtSpinType::getSpin2( EvtPDL::getSpinType( getParentId() ) );
	- int _JB2 = EvtSpinType::getSpin2( EvtPDL::getSpinType( getDaug( 0 ) ) );
	- int _JC2 = EvtSpinType::getSpin2( EvtPDL::getSpinType( getDaug( 1 ) ) );
	+ int JA2 = EvtSpinType::getSpin2( EvtPDL::getSpinType( getParentId() ) );
	+ int JB2 = EvtSpinType::getSpin2( EvtPDL::getSpinType( getDaug( 0 ) ) );
	+ int JC2 = EvtSpinType::getSpin2( EvtPDL::getSpinType( getDaug( 1 ) ) );

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "_JA2,_JB2,_JC2:" << _JA2 << "," << _JB2 << "," << _JC2 << endl;
	+ << "JA2,JB2,JC2:" << JA2 << "," << JB2 << "," << JC2 << endl;
	}

	//allocate memory
	- int* _lambdaA2 = new int[_nA];
	- int* _lambdaB2 = new int[_nB];
	- int* _lambdaC2 = new int[_nC];
	-
	- EvtComplexPtr* _HBC = new EvtComplexPtr[_nB];
	- int ib, ic;
	- for ( ib = 0; ib < _nB; ib++ ) {
	- _HBC[ib] = new EvtComplex[_nC];
	+ int* lambdaA2 = new int[nA];
	+ int* lambdaB2 = new int[nB];
	+ int* lambdaC2 = new int[nC];
	+
	+ EvtComplexPtr* HBC = new EvtComplexPtr[nB];
	+ for ( int ib = 0; ib < nB; ib++ ) {
	+ HBC[ib] = new EvtComplex[nC];
	}

	- int i;
	//find the allowed helicities (actually 2*times the helicity!)

	- fillHelicity( _lambdaA2, _nA, _JA2 );
	- fillHelicity( _lambdaB2, _nB, _JB2 );
	- fillHelicity( _lambdaC2, _nC, _JC2 );
	+ fillHelicity( lambdaA2, nA, JA2 );
	+ fillHelicity( lambdaB2, nB, JB2 );
	+ fillHelicity( lambdaC2, nC, JC2 );

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Helicity states of particle A:" << endl;
	- for ( i = 0; i < _nA; i++ ) {
	- EvtGenReport( EVTGEN_INFO, "EvtGen" ) << _lambdaA2[i] << endl;
	+ for ( int i = 0; i < nA; i++ ) {
	+ EvtGenReport( EVTGEN_INFO, "EvtGen" ) << lambdaA2[i] << endl;
	}

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Helicity states of particle B:" << endl;
	- for ( i = 0; i < _nB; i++ ) {
	- EvtGenReport( EVTGEN_INFO, "EvtGen" ) << _lambdaB2[i] << endl;
	+ for ( int i = 0; i < nB; i++ ) {
	+ EvtGenReport( EVTGEN_INFO, "EvtGen" ) << lambdaB2[i] << endl;
	}

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Helicity states of particle C:" << endl;
	- for ( i = 0; i < _nC; i++ ) {
	- EvtGenReport( EVTGEN_INFO, "EvtGen" ) << _lambdaC2[i] << endl;
	+ for ( int i = 0; i < nC; i++ ) {
	+ EvtGenReport( EVTGEN_INFO, "EvtGen" ) << lambdaC2[i] << endl;
	}

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "Will now figure out the valid (M_LS) states:" << endl;
	}

	- int Lmin = std::max( _JA2 - _JB2 - _JC2,
	- std::max( _JB2 - _JA2 - _JC2, _JC2 - _JA2 - _JB2 ) );
	+ int Lmin = std::max( JA2 - JB2 - JC2,
	+ std::max( JB2 - JA2 - JC2, JC2 - JA2 - JB2 ) );
	if ( Lmin < 0 )
	Lmin = 0;
	- //int Lmin=_JA2-_JB2-_JC2;
	- int Lmax = _JA2 + _JB2 + _JC2;
	-
	- int L;
	+ int Lmax = JA2 + JB2 + JC2;

	- int _nPartialWaveAmp = 0;
	+ int nPartialWaveAmp = 0;

	- int _nL[50];
	- int _nS[50];
	+ int nL[50];
	+ int nS[50];

	- for ( L = Lmin; L <= Lmax; L += 2 ) {
	- int Smin = abs( L - _JA2 );
	- if ( Smin < abs( _JB2 - _JC2 ) )
	- Smin = abs( _JB2 - _JC2 );
	- int Smax = L + _JA2;
	- if ( Smax > abs( _JB2 + _JC2 ) )
	- Smax = abs( _JB2 + _JC2 );
	- int S;
	- for ( S = Smin; S <= Smax; S += 2 ) {
	- _nL[_nPartialWaveAmp] = L;
	- _nS[_nPartialWaveAmp] = S;
	+ for ( int L = Lmin; L <= Lmax; L += 2 ) {
	+ int Smin = abs( L - JA2 );
	+ if ( Smin < abs( JB2 - JC2 ) )
	+ Smin = abs( JB2 - JC2 );
	+ int Smax = L + JA2;
	+ if ( Smax > abs( JB2 + JC2 ) )
	+ Smax = abs( JB2 + JC2 );
	+ for ( int S = Smin; S <= Smax; S += 2 ) {
	+ nL[nPartialWaveAmp] = L;
	+ nS[nPartialWaveAmp] = S;

	- _nPartialWaveAmp++;
	+ nPartialWaveAmp++;
	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "M[" << L << "][" << S << "]" << endl;
	@@ -146,23 +140,23 @@
	}
	}

	- checkNArg( _nPartialWaveAmp * 2 );
	+ checkNArg( nPartialWaveAmp * 2 );

	int argcounter = 0;

	- EvtComplex _M[50];
	+ EvtComplex M[50];

	double partampsqtot = 0.0;

	- for ( i = 0; i < _nPartialWaveAmp; i++ ) {
	- _M[i] = getArg( argcounter ) *
	- exp( EvtComplex( 0.0, getArg( argcounter + 1 ) ) );
	+ for ( int i = 0; i < nPartialWaveAmp; i++ ) {
	+ M[i] = getArg( argcounter ) *
	+ exp( EvtComplex( 0.0, getArg( argcounter + 1 ) ) );
	;
	argcounter += 2;
	- partampsqtot += abs2( _M[i] );
	+ partampsqtot += abs2( M[i] );
	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "M[" << _nL[i] << "][" << _nS[i] << "]=" << _M[i] << endl;
	+ << "M[" << nL[i] << "][" << nS[i] << "]=" << M[i] << endl;
	}
	}

	@@ -170,18 +164,18 @@

	double helampsqtot = 0.0;

	- for ( ib = 0; ib < _nB; ib++ ) {
	- for ( ic = 0; ic < _nC; ic++ ) {
	- _HBC[ib][ic] = 0.0;
	- if ( abs( _lambdaB2[ib] - _lambdaC2[ic] ) <= _JA2 ) {
	- for ( i = 0; i < _nPartialWaveAmp; i++ ) {
	- int L = _nL[i];
	- int S = _nS[i];
	- int lambda2 = _lambdaB2[ib];
	- int lambda3 = _lambdaC2[ic];
	- int s1 = _JA2;
	- int s2 = _JB2;
	- int s3 = _JC2;
	+ for ( int ib = 0; ib < nB; ib++ ) {
	+ for ( int ic = 0; ic < nC; ic++ ) {
	+ HBC[ib][ic] = 0.0;
	+ if ( abs( lambdaB2[ib] - lambdaC2[ic] ) <= JA2 ) {
	+ for ( int i = 0; i < nPartialWaveAmp; i++ ) {
	+ int L = nL[i];
	+ int S = nS[i];
	+ int lambda2 = lambdaB2[ib];
	+ int lambda3 = lambdaC2[ic];
	+ int s1 = JA2;
	+ int s2 = JB2;
	+ int s3 = JC2;
	int m1 = lambda2 - lambda3;
	EvtCGCoefSingle c1( s2, s3 );
	EvtCGCoefSingle c2( L, S );
	@@ -197,17 +191,17 @@
	EvtComplex tmp = sqrt( fkwTmp ) *
	c1.coef( S, m1, s2, s3, lambda2,
	-lambda3 ) *
	- c2.coef( s1, m1, L, S, 0, m1 ) * _M[i];
	- _HBC[ib][ic] += tmp;
	+ c2.coef( s1, m1, L, S, 0, m1 ) * M[i];
	+ HBC[ib][ic] += tmp;
	}
	}
	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << "_HBC[" << ib << "][" << ic << "]=" << _HBC[ib][ic]
	+ << "HBC[" << ib << "][" << ic << "]=" << HBC[ib][ic]
	<< endl;
	}
	}
	- helampsqtot += abs2( _HBC[ib][ic] );
	+ helampsqtot += abs2( HBC[ib][ic] );
	}
	}

	@@ -218,12 +212,12 @@
	<< " -> " << EvtPDL::name( getDaug( 0 ) ) << " "
	<< EvtPDL::name( getDaug( 1 ) ) << std::endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "With arguments: " << std::endl;
	- for ( i = 0; i * 2 < getNArg(); i++ ) {
	+ for ( int i = 0; i * 2 < getNArg(); i++ ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "M(" << _nL[i] << "," << _nS[i]
	+ << "M(" << nL[i] << "," << nS[i]
	<< ")="
	// <<getArg(2i)<<" "<<getArg(2i+1)<<std::endl;
	- << _M[i] << std::endl;
	+ << M[i] << std::endl;
	}
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "The total probability in the partwave basis is: " << partampsqtot
	@@ -242,13 +236,13 @@
	<< std::endl;
	}

	- _evalHelAmp = std::make_unique<EvtEvalHelAmp>( getParentId(), getDaug( 0 ),
	- getDaug( 1 ), _HBC );
	+ m_evalHelAmp = std::make_unique<EvtEvalHelAmp>( getParentId(), getDaug( 0 ),
	+ getDaug( 1 ), HBC );
	}

	void EvtPartWave::initProbMax()
	{
	- double maxprob = _evalHelAmp->probMax();
	+ double maxprob = m_evalHelAmp->probMax();

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -263,15 +257,13 @@
	//first generate simple phase space
	p->initializePhaseSpace( getNDaug(), getDaugs() );

	- _evalHelAmp->evalAmp( p, _amp2 );
	+ m_evalHelAmp->evalAmp( p, m_amp2 );

	return;
	}

	void EvtPartWave::fillHelicity( int* lambda2, int n, int J2 )
	{
	- int i;
	-
	//photon is special case!
	if ( n == 2 && J2 == 2 ) {
	lambda2[0] = 2;
	@@ -281,7 +273,7 @@

	assert( n == J2 + 1 );

	- for ( i = 0; i < n; i++ ) {
	+ for ( int i = 0; i < n; i++ ) {
	lambda2[i] = n - i * 2 - 1;
	}

	diff --git a/src/EvtGenModels/EvtPsi2JpsiPiPi.cpp b/src/EvtGenModels/EvtPsi2JpsiPiPi.cpp
	--- a/src/EvtGenModels/EvtPsi2JpsiPiPi.cpp
	+++ b/src/EvtGenModels/EvtPsi2JpsiPiPi.cpp
	@@ -29,12 +29,12 @@
	#include <cmath>

	EvtPsi2JpsiPiPi::EvtPsi2JpsiPiPi() :
	- tree( false ),
	- phi( 0.0 ),
	- cosPhi( 1.0 ),
	- cos2Phi( 1.0 ),
	- sinPhi( 0.0 ),
	- sin2Phi( 0.0 )
	+ m_tree( false ),
	+ m_phi( 0.0 ),
	+ m_cosPhi( 1.0 ),
	+ m_cos2Phi( 1.0 ),
	+ m_sinPhi( 0.0 ),
	+ m_sin2Phi( 0.0 )
	{
	this->setNLOArrays();
	}
	@@ -43,40 +43,40 @@
	{
	// Parameters for NLO corrections obtained by fitting distributions
	// shown in Fig 2 of the article
	- c0[0] = 1.21214;
	- c0[1] = -2.517;
	- c0[2] = 4.66947;
	- c0[3] = 15.0853;
	- c0[4] = -49.7381;
	- c0[5] = 35.5604;
	-
	- c1[0] = -6.74237;
	- c1[1] = 84.2391;
	- c1[2] = -389.74;
	- c1[3] = 823.902;
	- c1[4] = -808.538;
	- c1[5] = 299.1;
	-
	- c2[0] = -1.25073;
	- c2[1] = 16.2666;
	- c2[2] = -74.6453;
	- c2[3] = 156.789;
	- c2[4] = -154.185;
	- c2[5] = 57.5711;
	-
	- s1[0] = -8.01579;
	- s1[1] = 93.9513;
	- s1[2] = -451.713;
	- s1[3] = 1049.67;
	- s1[4] = -1162.9;
	- s1[5] = 492.364;
	-
	- s2[0] = 3.04459;
	- s2[1] = -26.0901;
	- s2[2] = 81.1557;
	- s2[3] = -112.875;
	- s2[4] = 66.0432;
	- s2[5] = -10.0446;
	+ m_c0[0] = 1.21214;
	+ m_c0[1] = -2.517;
	+ m_c0[2] = 4.66947;
	+ m_c0[3] = 15.0853;
	+ m_c0[4] = -49.7381;
	+ m_c0[5] = 35.5604;
	+
	+ m_c1[0] = -6.74237;
	+ m_c1[1] = 84.2391;
	+ m_c1[2] = -389.74;
	+ m_c1[3] = 823.902;
	+ m_c1[4] = -808.538;
	+ m_c1[5] = 299.1;
	+
	+ m_c2[0] = -1.25073;
	+ m_c2[1] = 16.2666;
	+ m_c2[2] = -74.6453;
	+ m_c2[3] = 156.789;
	+ m_c2[4] = -154.185;
	+ m_c2[5] = 57.5711;
	+
	+ m_s1[0] = -8.01579;
	+ m_s1[1] = 93.9513;
	+ m_s1[2] = -451.713;
	+ m_s1[3] = 1049.67;
	+ m_s1[4] = -1162.9;
	+ m_s1[5] = 492.364;
	+
	+ m_s2[0] = 3.04459;
	+ m_s2[1] = -26.0901;
	+ m_s2[2] = 81.1557;
	+ m_s2[3] = -112.875;
	+ m_s2[4] = 66.0432;
	+ m_s2[5] = -10.0446;
	}

	std::string EvtPsi2JpsiPiPi::getName()
	@@ -91,7 +91,7 @@

	void EvtPsi2JpsiPiPi::initProbMax()
	{
	- // Should be OK for all phi values
	+ // Should be OK for all m_phi values
	setProbMax( 1.1 );
	}

	@@ -100,19 +100,19 @@
	checkNArg( 0, 1 );

	if ( getNArg() == 0 ) {
	- tree = true;
	- phi = 0.0;
	+ m_tree = true;
	+ m_phi = 0.0;

	} else {
	- tree = false;
	- phi = getArg( 0 ); // LO vs NLO mixing angle in radians
	+ m_tree = false;
	+ m_phi = getArg( 0 ); // LO vs NLO mixing angle in radians
	}

	- double twoPhi = 2.0 * phi;
	- cosPhi = cos( phi );
	- cos2Phi = cos( twoPhi );
	- sinPhi = sin( phi );
	- sin2Phi = sin( twoPhi );
	+ double twoPhi = 2.0 * m_phi;
	+ m_cosPhi = cos( m_phi );
	+ m_cos2Phi = cos( twoPhi );
	+ m_sinPhi = sin( m_phi );
	+ m_sin2Phi = sin( twoPhi );
	}

	void EvtPsi2JpsiPiPi::decay( EvtParticle* root )
	@@ -130,12 +130,12 @@
	double mpipi = p3.mass();
	double corr( 1.0 );

	- if ( !tree ) {
	+ if ( !m_tree ) {
	// Calculate NLO corrections
	corr = 0.0;
	- for ( int iq = 0; iq < nQ; ++iq ) {
	- corr += ( c0[iq] + c1[iq] * cosPhi + c2[iq] * cos2Phi +
	- s1[iq] * sinPhi + s2[iq] * sin2Phi ) *
	+ for ( int iq = 0; iq < m_nQ; ++iq ) {
	+ corr += ( m_c0[iq] + m_c1[iq] * m_cosPhi + m_c2[iq] * m_cos2Phi +
	+ m_s1[iq] * m_sinPhi + m_s2[iq] * m_sin2Phi ) *
	std::pow( mpipi, iq );
	}
	}
	diff --git a/src/EvtGenModels/EvtRareLbToLll.cpp b/src/EvtGenModels/EvtRareLbToLll.cpp
	--- a/src/EvtGenModels/EvtRareLbToLll.cpp
	+++ b/src/EvtGenModels/EvtRareLbToLll.cpp
	@@ -82,20 +82,20 @@
	model = getArgStr( 0 );
	}
	if ( model == "Gutsche" ) {
	- ffmodel_ = std::make_unique<EvtRareLbToLllFFGutsche>();
	+ m_ffmodel = std::make_unique<EvtRareLbToLllFFGutsche>();
	} else if ( model == "LQCD" ) {
	- ffmodel_ = std::make_unique<EvtRareLbToLllFFlQCD>();
	+ m_ffmodel = std::make_unique<EvtRareLbToLllFFlQCD>();
	} else if ( model == "MR" ) {
	- ffmodel_ = std::make_unique<EvtRareLbToLllFF>();
	+ m_ffmodel = std::make_unique<EvtRareLbToLllFF>();
	} else {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< " Unknown form-factor model, valid options are MR, LQCD, Gutsche."
	<< " Assuming LQCD form-factors... " << std::endl;
	- ffmodel_ = std::make_unique<EvtRareLbToLllFFlQCD>();
	+ m_ffmodel = std::make_unique<EvtRareLbToLllFFlQCD>();
	}
	- wcmodel_ = std::make_unique<EvtRareLbToLllWC>();
	+ m_wcmodel = std::make_unique<EvtRareLbToLllWC>();

	- ffmodel_->init();
	+ m_ffmodel->init();

	return;
	}
	@@ -209,7 +209,7 @@
	} else {
	parent->initializePhaseSpace( getNDaug(), getDaugs() );
	}
	- calcAmp( _amp2, *parent );
	+ calcAmp( m_amp2, *parent );
	}

	bool EvtRareLbToLll::isParticle( const EvtParticle& parent ) const
	@@ -268,11 +268,11 @@

	EvtRareLbToLllFF::FormFactors FF;
	//F, G, FT and GT
	- ffmodel_->getFF( parent, *lambda, FF );
	+ m_ffmodel->getFF( parent, *lambda, FF );

	- EvtComplex C7eff = wcmodel_->GetC7Eff( qsq );
	- EvtComplex C9eff = wcmodel_->GetC9Eff( qsq );
	- EvtComplex C10eff = wcmodel_->GetC10Eff( qsq );
	+ EvtComplex C7eff = m_wcmodel->GetC7Eff( qsq );
	+ EvtComplex C9eff = m_wcmodel->GetC9Eff( qsq );
	+ EvtComplex C10eff = m_wcmodel->GetC10Eff( qsq );

	EvtComplex AC[4];
	EvtComplex BC[4];
	@@ -280,7 +280,7 @@
	EvtComplex EC[4];

	// check to see if particle is same or opposite parity to Lb
	- const int parity = ffmodel_->isNatural( *lambda ) ? 1 : -1;
	+ const int parity = m_ffmodel->isNatural( *lambda ) ? 1 : -1;

	// Lambda spin type
	const EvtSpinType::spintype spin = EvtPDL::getSpinType( lambda->getId() );
	@@ -290,15 +290,15 @@
	// Eq. 48 + 49
	for ( unsigned int i = 0; i < 4; ++i ) {
	if ( parity > 0 ) {
	- AC[i] = -2. * mb * C7eff * FF.FT_[i] / qsq + C9eff * FF.F_[i];
	- BC[i] = -2. * mb * C7eff * FF.GT_[i] / qsq - C9eff * FF.G_[i];
	- DC[i] = C10eff * FF.F_[i];
	- EC[i] = -C10eff * FF.G_[i];
	+ AC[i] = -2. * mb * C7eff * FF.m_FT[i] / qsq + C9eff * FF.m_F[i];
	+ BC[i] = -2. * mb * C7eff * FF.m_GT[i] / qsq - C9eff * FF.m_G[i];
	+ DC[i] = C10eff * FF.m_F[i];
	+ EC[i] = -C10eff * FF.m_G[i];
	} else {
	- AC[i] = -2. * mb * C7eff * FF.GT_[i] / qsq - C9eff * FF.G_[i];
	- BC[i] = -2. * mb * C7eff * FF.FT_[i] / qsq + C9eff * FF.F_[i];
	- DC[i] = -C10eff * FF.G_[i];
	- EC[i] = C10eff * FF.F_[i];
	+ AC[i] = -2. * mb * C7eff * FF.m_GT[i] / qsq - C9eff * FF.m_G[i];
	+ BC[i] = -2. * mb * C7eff * FF.m_FT[i] / qsq + C9eff * FF.m_F[i];
	+ DC[i] = -C10eff * FF.m_G[i];
	+ EC[i] = C10eff * FF.m_F[i];
	}
	}

	@@ -459,8 +459,8 @@

	EvtDiracSpinor Sprime;

	- for ( int i = 0; i < 4; i++ ) {
	- Sprime.set_spinor( i, Sfinal.getVector( i ) * P );
	+ for ( int ii = 0; ii < 4; ii++ ) {
	+ Sprime.set_spinor( ii, Sfinal.getVector( ii ) * P );
	}

	const double Pmsq = P.mass2();
	@@ -469,9 +469,9 @@

	EvtVector4C V1, V2;

	- for ( int i = 0; i < 4; i++ ) {
	- V1.set( i, EvtLeptonSCurrent( Sfinal.getSpinor( i ), Sinit ) );
	- V2.set( i, EvtLeptonPCurrent( Sfinal.getSpinor( i ), Sinit ) );
	+ for ( int ii = 0; ii < 4; ii++ ) {
	+ V1.set( ii, EvtLeptonSCurrent( Sfinal.getSpinor( ii ), Sinit ) );
	+ V2.set( ii, EvtLeptonPCurrent( Sfinal.getSpinor( ii ), Sinit ) );
	}

	// \bar{u}_{alpha} v^{\alpha} \gamma^{\mu} u
	diff --git a/src/EvtGenModels/EvtRareLbToLllFF.cpp b/src/EvtGenModels/EvtRareLbToLllFF.cpp
	--- a/src/EvtGenModels/EvtRareLbToLllFF.cpp
	+++ b/src/EvtGenModels/EvtRareLbToLllFF.cpp
	@@ -35,13 +35,13 @@
	//=============================================================================

	EvtRareLbToLllFF::FormFactorDependence::FormFactorDependence() :
	- a0_( 0 ), a2_( 0 ), a4_( 0 ), al_( 0 ), ap_( 0 )
	+ m_a0( 0 ), m_a2( 0 ), m_a4( 0 ), m_al( 0 ), m_ap( 0 )
	{
	}

	EvtRareLbToLllFF::FormFactorDependence::FormFactorDependence( const double al,
	const double ap ) :
	- a0_( 0 ), a2_( 0 ), a4_( 0 ), al_( al ), ap_( ap )
	+ m_a0( 0 ), m_a2( 0 ), m_a4( 0 ), m_al( al ), m_ap( ap )
	{
	}

	@@ -50,24 +50,25 @@
	const double a4,
	const double al,
	const double ap ) :
	- a0_( a0 ), a2_( a2 ), a4_( a4 ), al_( al ), ap_( ap )
	+ m_a0( a0 ), m_a2( a2 ), m_a4( a4 ), m_al( al ), m_ap( ap )
	{
	}

	EvtRareLbToLllFF::FormFactorDependence::FormFactorDependence(
	const EvtRareLbToLllFF::FormFactorDependence& other ) :
	- a0_( other.a0_ ),
	- a2_( other.a2_ ),
	- a4_( other.a4_ ),
	- al_( other.al_ ),
	- ap_( other.ap_ )
	+ m_a0( other.m_a0 ),
	+ m_a2( other.m_a2 ),
	+ m_a4( other.m_a4 ),
	+ m_al( other.m_al ),
	+ m_ap( other.m_ap )
	{
	}

	EvtRareLbToLllFF::FormFactorDependence*
	EvtRareLbToLllFF::FormFactorDependence::clone() const
	{
	- return new EvtRareLbToLllFF::FormFactorDependence( a0_, a2_, a4_, al_, ap_ );
	+ return new EvtRareLbToLllFF::FormFactorDependence( m_a0, m_a2, m_a4, m_al,
	+ m_ap );
	}

	EvtRareLbToLllFF::FormFactorSet::FormFactorSet()
	@@ -76,28 +77,28 @@

	EvtRareLbToLllFF::FormFactorSet::FormFactorSet(
	const EvtRareLbToLllFF::FormFactorSet& other ) :
	- F1( other.F1 ),
	- F2( other.F2 ),
	- F3( other.F3 ),
	- F4( other.F4 ),
	- G1( other.G1 ),
	- G2( other.G2 ),
	- G3( other.G3 ),
	- G4( other.G4 ),
	- H1( other.H1 ),
	- H2( other.H2 ),
	- H3( other.H3 ),
	- H4( other.H4 ),
	- H5( other.H5 ),
	- H6( other.H6 )
	+ m_F1( other.m_F1 ),
	+ m_F2( other.m_F2 ),
	+ m_F3( other.m_F3 ),
	+ m_F4( other.m_F4 ),
	+ m_G1( other.m_G1 ),
	+ m_G2( other.m_G2 ),
	+ m_G3( other.m_G3 ),
	+ m_G4( other.m_G4 ),
	+ m_H1( other.m_H1 ),
	+ m_H2( other.m_H2 ),
	+ m_H3( other.m_H3 ),
	+ m_H4( other.m_H4 ),
	+ m_H5( other.m_H5 ),
	+ m_H6( other.m_H6 )
	{
	}

	void EvtRareLbToLllFF::FormFactorDependence::param( const double al,
	const double ap )
	{
	- al_ = al;
	- ap_ = ap;
	+ m_al = al;
	+ m_ap = ap;
	}

	void EvtRareLbToLllFF::FormFactorDependence::param( const double a0,
	@@ -106,55 +107,55 @@
	const double al,
	const double ap )
	{
	- a0_ = a0;
	- a2_ = a2;
	- a4_ = a4;
	- al_ = al;
	- ap_ = ap;
	+ m_a0 = a0;
	+ m_a2 = a2;
	+ m_a4 = a4;
	+ m_al = al;
	+ m_ap = ap;
	}

	void EvtRareLbToLllFF::init()
	{
	// Parameters for Lambda0
	auto L1115 = std::make_unique<EvtRareLbToLllFF::FormFactorSet>();
	- L1115->F1.param( 1.21, 0.319, -0.0177, 0.387, 0.372 );
	- L1115->F2.param( -0.202, -0.219, 0.0103, 0.387, 0.372 );
	- L1115->F3.param( -0.0615, 0.00102, -0.00139, 0.387, 0.372 );
	- L1115->F4.param( 0.387, 0.372 );
	- L1115->G1.param( 0.927, 0.104, -0.00553, 0.387, 0.372 );
	- L1115->G2.param( -0.236, -0.233, 0.0110, 0.387, 0.372 );
	- L1115->G3.param( 0.0756, 0.0195, -0.00115, 0.387, 0.372 );
	- L1115->G4.param( 0.387, 0.372 );
	- L1115->H1.param( 0.936, 0.0722, -0.00643, 0.387, 0.372 );
	- L1115->H2.param( 0.227, 0.265, -0.0101, 0.387, 0.372 );
	- L1115->H3.param( -0.0757, -0.0195, 0.00116, 0.387, 0.372 );
	- L1115->H4.param( -0.0174, -0.00986, -0.000524, 0.387, 0.372 );
	- L1115->H5.param( 0.387, 0.372 );
	- L1115->H6.param( 0.387, 0.372 );
	+ L1115->m_F1.param( 1.21, 0.319, -0.0177, 0.387, 0.372 );
	+ L1115->m_F2.param( -0.202, -0.219, 0.0103, 0.387, 0.372 );
	+ L1115->m_F3.param( -0.0615, 0.00102, -0.00139, 0.387, 0.372 );
	+ L1115->m_F4.param( 0.387, 0.372 );
	+ L1115->m_G1.param( 0.927, 0.104, -0.00553, 0.387, 0.372 );
	+ L1115->m_G2.param( -0.236, -0.233, 0.0110, 0.387, 0.372 );
	+ L1115->m_G3.param( 0.0756, 0.0195, -0.00115, 0.387, 0.372 );
	+ L1115->m_G4.param( 0.387, 0.372 );
	+ L1115->m_H1.param( 0.936, 0.0722, -0.00643, 0.387, 0.372 );
	+ L1115->m_H2.param( 0.227, 0.265, -0.0101, 0.387, 0.372 );
	+ L1115->m_H3.param( -0.0757, -0.0195, 0.00116, 0.387, 0.372 );
	+ L1115->m_H4.param( -0.0174, -0.00986, -0.000524, 0.387, 0.372 );
	+ L1115->m_H5.param( 0.387, 0.372 );
	+ L1115->m_H6.param( 0.387, 0.372 );

	// Parameters for Lambda(Lambda(1520)0)
	auto L1520 = std::make_unique<EvtRareLbToLllFF::FormFactorSet>();
	- L1520->F1.param( -1.66, -0.295, 0.00924, 0.333, 0.308 );
	- L1520->F2.param( 0.544, 0.194, -0.00420, 0.333, 0.308 );
	- L1520->F3.param( 0.126, 0.00799, -0.000635, 0.333, 0.308 );
	- L1520->F4.param( -0.0330, -0.00977, 0.00211, 0.303, 0.308 );
	- L1520->G1.param( -0.964, -0.100, 0.00264, 0.333, 0.308 );
	- L1520->G2.param( 0.625, 0.219, -0.00508, 0.333, 0.308 );
	- L1520->G3.param( -0.183, -0.0380, 0.00351, 0.333, 0.308 );
	- L1520->G4.param( 0.0530, 0.0161, -0.00221, 0.333, 0.308 );
	- L1520->H1.param( -1.08, -0.0732, 0.00464, 0.333, 0.308 );
	- L1520->H2.param( -0.507, -0.246, 0.00309, 0.333, 0.308 );
	- L1520->H3.param( 0.187, 0.0295, -0.00107, 0.333, 0.308 );
	- L1520->H4.param( 0.0772, 0.0267, -0.00217, 0.333, 0.308 );
	- L1520->H5.param( -0.0517, -0.0173, 0.00259, 0.333, 0.308 );
	- L1520->H6.param( 0.0206, 0.00679, -0.000220, 0.333, 0.308 );
	-
	- FFMap_[EvtPDL::getId( "Lambda0" ).getId()] = L1115.get();
	- FFMap_[EvtPDL::getId( "anti-Lambda0" ).getId()] = L1115.get();
	- FFMap_[EvtPDL::getId( "Lambda(1520)0" ).getId()] = L1520.get();
	- FFMap_[EvtPDL::getId( "anti-Lambda(1520)0" ).getId()] = L1520.get();
	-
	- FF_ = { std::move( L1115 ), std::move( L1520 ) };
	+ L1520->m_F1.param( -1.66, -0.295, 0.00924, 0.333, 0.308 );
	+ L1520->m_F2.param( 0.544, 0.194, -0.00420, 0.333, 0.308 );
	+ L1520->m_F3.param( 0.126, 0.00799, -0.000635, 0.333, 0.308 );
	+ L1520->m_F4.param( -0.0330, -0.00977, 0.00211, 0.303, 0.308 );
	+ L1520->m_G1.param( -0.964, -0.100, 0.00264, 0.333, 0.308 );
	+ L1520->m_G2.param( 0.625, 0.219, -0.00508, 0.333, 0.308 );
	+ L1520->m_G3.param( -0.183, -0.0380, 0.00351, 0.333, 0.308 );
	+ L1520->m_G4.param( 0.0530, 0.0161, -0.00221, 0.333, 0.308 );
	+ L1520->m_H1.param( -1.08, -0.0732, 0.00464, 0.333, 0.308 );
	+ L1520->m_H2.param( -0.507, -0.246, 0.00309, 0.333, 0.308 );
	+ L1520->m_H3.param( 0.187, 0.0295, -0.00107, 0.333, 0.308 );
	+ L1520->m_H4.param( 0.0772, 0.0267, -0.00217, 0.333, 0.308 );
	+ L1520->m_H5.param( -0.0517, -0.0173, 0.00259, 0.333, 0.308 );
	+ L1520->m_H6.param( 0.0206, 0.00679, -0.000220, 0.333, 0.308 );
	+
	+ m_FFMap[EvtPDL::getId( "Lambda0" ).getId()] = L1115.get();
	+ m_FFMap[EvtPDL::getId( "anti-Lambda0" ).getId()] = L1115.get();
	+ m_FFMap[EvtPDL::getId( "Lambda(1520)0" ).getId()] = L1520.get();
	+ m_FFMap[EvtPDL::getId( "anti-Lambda(1520)0" ).getId()] = L1520.get();
	+
	+ m_FF = { std::move( L1115 ), std::move( L1520 ) };

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< " EvtRareLbToLll is using form factors from arXiv:1108.6129 "
	@@ -169,10 +170,10 @@
	static const double mq = 0.2848;
	static const double mtilde = 1.122;

	- const double asq = 0.5 * ( dep.al_ * dep.al_ + dep.ap_ * dep.ap_ );
	+ const double asq = 0.5 * ( dep.m_al * dep.m_al + dep.m_ap * dep.m_ap );
	const double psq = p * p;

	- return ( dep.a0_ + dep.a2_ * psq + dep.a4_ * psq * psq ) *
	+ return ( dep.m_a0 + dep.m_a2 * psq + dep.m_a4 * psq * psq ) *
	exp( -( 3. * mq * mq * psq ) / ( 2. * mtilde * mtilde * asq ) );
	}

	@@ -187,39 +188,39 @@
	const double vdotv = calculateVdotV( parent, lambda );
	const double p = lambda.getP4().d3mag();

	- FF.F_[0] = func( p, dep.F1 );
	- FF.F_[1] = func( p, dep.F2 );
	- FF.F_[2] = func( p, dep.F3 );
	+ FF.m_F[0] = func( p, dep.m_F1 );
	+ FF.m_F[1] = func( p, dep.m_F2 );
	+ FF.m_F[2] = func( p, dep.m_F3 );

	- FF.G_[0] = func( p, dep.G1 );
	- FF.G_[1] = func( p, dep.G2 );
	- FF.G_[2] = func( p, dep.G3 );
	+ FF.m_G[0] = func( p, dep.m_G1 );
	+ FF.m_G[1] = func( p, dep.m_G2 );
	+ FF.m_G[2] = func( p, dep.m_G3 );

	- const double H1 = func( p, dep.H1 );
	- const double H2 = func( p, dep.H2 );
	- const double H3 = func( p, dep.H3 );
	- const double H4 = func( p, dep.H4 );
	+ const double H1 = func( p, dep.m_H1 );
	+ const double H2 = func( p, dep.m_H2 );
	+ const double H3 = func( p, dep.m_H3 );
	+ const double H4 = func( p, dep.m_H4 );

	if ( isNatural( lambda ) ) {
	- FF.FT_[0] = -( MB + M ) * H1 - ( MB - M * vdotv ) * H2 -
	- ( MB * vdotv - M ) * H3;
	- FF.FT_[1] = MB * H1 + ( MB - M ) * H2 + ( MB * vdotv - M ) * H4;
	- FF.FT_[2] = M * H1 + ( MB - M ) * H3 - ( MB - M * vdotv ) * H4;
	-
	- FF.GT_[0] = ( MB - M ) * H1 - M * ( 1. - vdotv ) * H2 -
	- MB * ( 1. - vdotv ) * H3;
	- FF.GT_[1] = MB * H1 - M * H2 - MB * H3;
	- FF.GT_[2] = M * H1 + M * H2 + MB * H3;
	+ FF.m_FT[0] = -( MB + M ) * H1 - ( MB - M * vdotv ) * H2 -
	+ ( MB * vdotv - M ) * H3;
	+ FF.m_FT[1] = MB * H1 + ( MB - M ) * H2 + ( MB * vdotv - M ) * H4;
	+ FF.m_FT[2] = M * H1 + ( MB - M ) * H3 - ( MB - M * vdotv ) * H4;
	+
	+ FF.m_GT[0] = ( MB - M ) * H1 - M * ( 1. - vdotv ) * H2 -
	+ MB * ( 1. - vdotv ) * H3;
	+ FF.m_GT[1] = MB * H1 - M * H2 - MB * H3;
	+ FF.m_GT[2] = M * H1 + M * H2 + MB * H3;
	} else {
	- FF.FT_[0] = ( MB - M ) * H1 - ( MB - M * vdotv ) * H2 -
	- ( MB * vdotv - M ) * H3;
	- FF.FT_[1] = MB * H1 - ( MB + M ) * H2 + ( MB * vdotv - M ) * H4;
	- FF.FT_[2] = M * H1 - ( MB + M ) * H3 - ( MB - M * vdotv ) * H4;
	-
	- FF.GT_[0] = -( MB + M ) * H1 + M * ( 1. + vdotv ) * H2 +
	- MB * ( 1. + vdotv ) * H3;
	- FF.GT_[1] = MB * H1 - M * H2 - MB * H3;
	- FF.GT_[2] = M * H1 - M * H2 - MB * H3;
	+ FF.m_FT[0] = ( MB - M ) * H1 - ( MB - M * vdotv ) * H2 -
	+ ( MB * vdotv - M ) * H3;
	+ FF.m_FT[1] = MB * H1 - ( MB + M ) * H2 + ( MB * vdotv - M ) * H4;
	+ FF.m_FT[2] = M * H1 - ( MB + M ) * H3 - ( MB - M * vdotv ) * H4;
	+
	+ FF.m_GT[0] = -( MB + M ) * H1 + M * ( 1. + vdotv ) * H2 +
	+ MB * ( 1. + vdotv ) * H3;
	+ FF.m_GT[1] = MB * H1 - M * H2 - MB * H3;
	+ FF.m_GT[2] = M * H1 - M * H2 - MB * H3;
	}
	}

	@@ -234,47 +235,49 @@
	const double vdotv = calculateVdotV( parent, lambda );
	const double p = lambda.getP4().d3mag();

	- FF.F_[0] = func( p, FFset.F1 );
	- FF.F_[1] = func( p, FFset.F2 );
	- FF.F_[2] = func( p, FFset.F3 );
	- FF.F_[3] = func( p, FFset.F4 );
	+ FF.m_F[0] = func( p, FFset.m_F1 );
	+ FF.m_F[1] = func( p, FFset.m_F2 );
	+ FF.m_F[2] = func( p, FFset.m_F3 );
	+ FF.m_F[3] = func( p, FFset.m_F4 );

	- FF.G_[0] = func( p, FFset.G1 );
	- FF.G_[1] = func( p, FFset.G2 );
	- FF.G_[2] = func( p, FFset.G3 );
	- FF.G_[3] = func( p, FFset.G4 );
	+ FF.m_G[0] = func( p, FFset.m_G1 );
	+ FF.m_G[1] = func( p, FFset.m_G2 );
	+ FF.m_G[2] = func( p, FFset.m_G3 );
	+ FF.m_G[3] = func( p, FFset.m_G4 );

	- const double H1 = func( p, FFset.H1 );
	- const double H2 = func( p, FFset.H2 );
	- const double H3 = func( p, FFset.H3 );
	- const double H4 = func( p, FFset.H4 );
	- const double H5 = func( p, FFset.H5 );
	- const double H6 = func( p, FFset.H6 );
	+ const double H1 = func( p, FFset.m_H1 );
	+ const double H2 = func( p, FFset.m_H2 );
	+ const double H3 = func( p, FFset.m_H3 );
	+ const double H4 = func( p, FFset.m_H4 );
	+ const double H5 = func( p, FFset.m_H5 );
	+ const double H6 = func( p, FFset.m_H6 );

	if ( isNatural( lambda ) ) {
	- FF.FT_[0] = -( MB + M ) * H1 - ( MB - M * vdotv ) * H2 -
	- ( MB * vdotv - M ) * H3 - MB * H5;
	- FF.FT_[1] = MB * H1 + ( MB - M ) * H2 + ( MB * vdotv - M ) * H4 - MB * H6;
	- FF.FT_[2] = M * H1 + ( MB - M ) * H3 - ( MB - M * vdotv ) * H4;
	- FF.FT_[3] = ( MB - M ) * H5 + ( MB - M * vdotv ) * H6;
	-
	- FF.GT_[0] = ( MB - M ) * H1 - M * ( 1. - vdotv ) * H2 -
	- MB * ( 1. - vdotv ) * H3 + MB * H5 + M * H6;
	- FF.GT_[1] = MB * H1 - M * H2 - MB * H3;
	- FF.GT_[2] = M * H1 + M * H2 + MB * H3 - M * H6;
	- FF.GT_[3] = ( MB + M ) * H5 + M * ( 1. + vdotv ) * H6;
	+ FF.m_FT[0] = -( MB + M ) * H1 - ( MB - M * vdotv ) * H2 -
	+ ( MB * vdotv - M ) * H3 - MB * H5;
	+ FF.m_FT[1] = MB * H1 + ( MB - M ) * H2 + ( MB * vdotv - M ) * H4 -
	+ MB * H6;
	+ FF.m_FT[2] = M * H1 + ( MB - M ) * H3 - ( MB - M * vdotv ) * H4;
	+ FF.m_FT[3] = ( MB - M ) * H5 + ( MB - M * vdotv ) * H6;
	+
	+ FF.m_GT[0] = ( MB - M ) * H1 - M * ( 1. - vdotv ) * H2 -
	+ MB * ( 1. - vdotv ) * H3 + MB * H5 + M * H6;
	+ FF.m_GT[1] = MB * H1 - M * H2 - MB * H3;
	+ FF.m_GT[2] = M * H1 + M * H2 + MB * H3 - M * H6;
	+ FF.m_GT[3] = ( MB + M ) * H5 + M * ( 1. + vdotv ) * H6;
	} else {
	- FF.FT_[0] = ( MB - M ) * H1 - ( MB - M * vdotv ) * H2 -
	- ( MB * vdotv - M ) * H3 - MB * H5;
	- FF.FT_[1] = MB * H1 - ( MB + M ) * H2 + ( MB * vdotv - M ) * H4 - MB * H6;
	- FF.FT_[2] = M * H1 - ( MB + M ) * H3 - ( MB - M * vdotv ) * H4;
	- FF.FT_[3] = -( MB + M ) * H5 + ( MB - M * vdotv ) * H6;
	-
	- FF.GT_[0] = -( MB + M ) * H1 + M * ( 1. + vdotv ) * H2 +
	- MB * ( 1. + vdotv ) * H3 + MB * H5 + M * H6;
	- FF.GT_[1] = MB * H1 - M * H2 - MB * H3;
	- FF.GT_[2] = M * H1 - M * H2 - MB * H3 - M * H6;
	- FF.GT_[3] = -( MB - M ) * H5 - M * ( 1. - vdotv ) * H6;
	+ FF.m_FT[0] = ( MB - M ) * H1 - ( MB - M * vdotv ) * H2 -
	+ ( MB * vdotv - M ) * H3 - MB * H5;
	+ FF.m_FT[1] = MB * H1 - ( MB + M ) * H2 + ( MB * vdotv - M ) * H4 -
	+ MB * H6;
	+ FF.m_FT[2] = M * H1 - ( MB + M ) * H3 - ( MB - M * vdotv ) * H4;
	+ FF.m_FT[3] = -( MB + M ) * H5 + ( MB - M * vdotv ) * H6;
	+
	+ FF.m_GT[0] = -( MB + M ) * H1 + M * ( 1. + vdotv ) * H2 +
	+ MB * ( 1. + vdotv ) * H3 + MB * H5 + M * H6;
	+ FF.m_GT[1] = MB * H1 - M * H2 - MB * H3;
	+ FF.m_GT[2] = M * H1 - M * H2 - MB * H3 - M * H6;
	+ FF.m_GT[3] = -( MB - M ) * H5 - M * ( 1. - vdotv ) * H6;
	}
	}

	@@ -286,9 +289,9 @@
	FF.areZero();

	// Are the FF's for the particle known?
	- auto it = FFMap_.find( lambda.getId().getId() );
	+ auto it = m_FFMap.find( lambda.getId().getId() );

	- if ( it == FFMap_.end() ) {
	+ if ( it == m_FFMap.end() ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< " EvtRareLbToLll does not contain FF for " << lambda.getId()
	<< std::endl;
	diff --git a/src/EvtGenModels/EvtRareLbToLllFFBase.cpp b/src/EvtGenModels/EvtRareLbToLllFFBase.cpp
	--- a/src/EvtGenModels/EvtRareLbToLllFFBase.cpp
	+++ b/src/EvtGenModels/EvtRareLbToLllFFBase.cpp
	@@ -28,23 +28,23 @@
	void EvtRareLbToLllFFBase::FormFactors::areZero()
	{
	for ( unsigned int i = 0; i < 4; ++i ) {
	- F_[i] = 0;
	- G_[i] = 0;
	- FT_[i] = 0;
	- GT_[i] = 0;
	+ m_F[i] = 0;
	+ m_G[i] = 0;
	+ m_FT[i] = 0;
	+ m_GT[i] = 0;
	}
	}

	EvtRareLbToLllFFBase::EvtRareLbToLllFFBase() :
	- natural_{ "Lambda0", "anti-Lambda0",
	- "Lambda(1520)0", "anti-Lambda(1520)0",
	- "Lambda(1600)0", "anti-Lambda(1600)0" }
	+ m_natural{ "Lambda0", "anti-Lambda0",
	+ "Lambda(1520)0", "anti-Lambda(1520)0",
	+ "Lambda(1600)0", "anti-Lambda(1600)0" }
	{
	}

	bool EvtRareLbToLllFFBase::isNatural( const EvtParticle& lambda ) const
	{
	- return natural_.contains( lambda.getId() );
	+ return m_natural.contains( lambda.getId() );
	}

	double EvtRareLbToLllFFBase::calculateVdotV( const EvtParticle& parent,
	diff --git a/src/EvtGenModels/EvtRareLbToLllFFGutsche.cpp b/src/EvtGenModels/EvtRareLbToLllFFGutsche.cpp
	--- a/src/EvtGenModels/EvtRareLbToLllFFGutsche.cpp
	+++ b/src/EvtGenModels/EvtRareLbToLllFFGutsche.cpp
	@@ -36,45 +36,45 @@

	void EvtRareLbToLllFFGutsche::init()
	{
	- fVconsts[0][0] = 0.107;
	- fVconsts[0][1] = 2.27;
	- fVconsts[0][2] = 1.367;
	- fVconsts[1][0] = 0.043;
	- fVconsts[1][1] = 2.411;
	- fVconsts[1][2] = 1.531;
	- fVconsts[2][0] = -0.003;
	- fVconsts[2][1] = 2.815;
	- fVconsts[2][2] = 2.041;
	-
	- fAconsts[0][0] = 0.104;
	- fAconsts[0][1] = 2.232;
	- fAconsts[0][2] = 1.328;
	- fAconsts[1][0] = -0.003;
	- fAconsts[1][1] = 2.955;
	- fAconsts[1][2] = 3.620;
	- fAconsts[2][0] = -0.052;
	- fAconsts[2][1] = 2.437;
	- fAconsts[2][2] = 1.559;
	-
	- fTVconsts[0][0] = -0.043;
	- fTVconsts[0][1] = 2.411;
	- fTVconsts[0][2] = 1.531;
	- fTVconsts[1][0] = -0.105;
	- fTVconsts[1][1] = 2.27118;
	- fTVconsts[1][2] = 1.36776;
	- fTVconsts[2][0] = 0; // Not used anywhere
	- fTVconsts[2][1] = 0;
	- fTVconsts[2][2] = 0;
	-
	- fTAconsts[0][0] = 0.003;
	- fTAconsts[0][1] = 2.955;
	- fTAconsts[0][2] = 3.620;
	- fTAconsts[1][0] = -0.105;
	- fTAconsts[1][1] = 2.233;
	- fTAconsts[1][2] = 1.328;
	- fTAconsts[2][0] = 0; // Not used anywhere
	- fTAconsts[2][1] = 0;
	- fTAconsts[2][2] = 0;
	+ m_Vconsts[0][0] = 0.107;
	+ m_Vconsts[0][1] = 2.27;
	+ m_Vconsts[0][2] = 1.367;
	+ m_Vconsts[1][0] = 0.043;
	+ m_Vconsts[1][1] = 2.411;
	+ m_Vconsts[1][2] = 1.531;
	+ m_Vconsts[2][0] = -0.003;
	+ m_Vconsts[2][1] = 2.815;
	+ m_Vconsts[2][2] = 2.041;
	+
	+ m_Aconsts[0][0] = 0.104;
	+ m_Aconsts[0][1] = 2.232;
	+ m_Aconsts[0][2] = 1.328;
	+ m_Aconsts[1][0] = -0.003;
	+ m_Aconsts[1][1] = 2.955;
	+ m_Aconsts[1][2] = 3.620;
	+ m_Aconsts[2][0] = -0.052;
	+ m_Aconsts[2][1] = 2.437;
	+ m_Aconsts[2][2] = 1.559;
	+
	+ m_TVconsts[0][0] = -0.043;
	+ m_TVconsts[0][1] = 2.411;
	+ m_TVconsts[0][2] = 1.531;
	+ m_TVconsts[1][0] = -0.105;
	+ m_TVconsts[1][1] = 2.27118;
	+ m_TVconsts[1][2] = 1.36776;
	+ m_TVconsts[2][0] = 0; // Not used anywhere
	+ m_TVconsts[2][1] = 0;
	+ m_TVconsts[2][2] = 0;
	+
	+ m_TAconsts[0][0] = 0.003;
	+ m_TAconsts[0][1] = 2.955;
	+ m_TAconsts[0][2] = 3.620;
	+ m_TAconsts[1][0] = -0.105;
	+ m_TAconsts[1][1] = 2.233;
	+ m_TAconsts[1][2] = 1.328;
	+ m_TAconsts[2][0] = 0; // Not used anywhere
	+ m_TAconsts[2][1] = 0;
	+ m_TAconsts[2][2] = 0;

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< " EvtRareLbToLll is using form factors from arXiv:1301.3737 "
	@@ -91,8 +91,8 @@
	FF.areZero();

	/*
	- if ( ! ( fParents.contains(parent->getId()) &&
	- fDaughters.contains(lambda->getId()) ) )
	+ if ( ! ( m_Parents.contains(parent->getId()) &&
	+ m_Daughters.contains(lambda->getId()) ) )
	{
	EvtGenReport(EVTGEN_ERROR,"EvtGen") << " EvtRareLbToLllFFGutsche: Unknown mother and/or daughter. " << std::endl;
	return;
	@@ -110,36 +110,36 @@
	double fV[3];
	double fA[3];
	for ( int i = 0; i <= 2; ++i ) {
	- fV[i] = formFactorParametrization( shat, fVconsts[i][0], fVconsts[i][1],
	- fVconsts[i][2] );
	- fA[i] = formFactorParametrization( shat, fAconsts[i][0], fAconsts[i][1],
	- fAconsts[i][2] );
	+ fV[i] = formFactorParametrization( shat, m_Vconsts[i][0],
	+ m_Vconsts[i][1], m_Vconsts[i][2] );
	+ fA[i] = formFactorParametrization( shat, m_Aconsts[i][0],
	+ m_Aconsts[i][1], m_Aconsts[i][2] );
	}
	double fTV[2];
	double fTA[2];
	for ( int i = 0; i <= 1; ++i ) {
	- fTV[i] = formFactorParametrization( shat, fTVconsts[i][0],
	- fTVconsts[i][1], fTVconsts[i][2] );
	- fTA[i] = formFactorParametrization( shat, fTAconsts[i][0],
	- fTAconsts[i][1], fTAconsts[i][2] );
	+ fTV[i] = formFactorParametrization( shat, m_TVconsts[i][0],
	+ m_TVconsts[i][1], m_TVconsts[i][2] );
	+ fTA[i] = formFactorParametrization( shat, m_TAconsts[i][0],
	+ m_TAconsts[i][1], m_TAconsts[i][2] );
	}

	// Both v^2==v'^2==1 by definition
	- FF.F_[0] = fV[0] + fV[1] * ( 1 + m21 );
	- FF.F_[1] = fV[2] - fV[1];
	- FF.F_[2] = -m21 * ( fV[1] + fV[2] );
	+ FF.m_F[0] = fV[0] + fV[1] * ( 1 + m21 );
	+ FF.m_F[1] = fV[2] - fV[1];
	+ FF.m_F[2] = -m21 * ( fV[1] + fV[2] );

	- FF.G_[0] = fA[0] - fA[1] * ( 1 - m21 );
	- FF.G_[1] = fA[2] - fA[1];
	- FF.G_[2] = -m21 * ( +fA[1] + fA[2] );
	+ FF.m_G[0] = fA[0] - fA[1] * ( 1 - m21 );
	+ FF.m_G[1] = fA[2] - fA[1];
	+ FF.m_G[2] = -m21 * ( +fA[1] + fA[2] );

	- FF.FT_[0] = fTV[1] * ( m1 + m2 ) + fTV[0] * ( q2 / m1 );
	- FF.FT_[1] = +fTV[0] * ( m2 - m1 ) - fTV[1] * m1;
	- FF.FT_[2] = m2 * ( fTV[0] - fTV[1] ) - fTV[0] * m21 * m2;
	+ FF.m_FT[0] = fTV[1] * ( m1 + m2 ) + fTV[0] * ( q2 / m1 );
	+ FF.m_FT[1] = +fTV[0] * ( m2 - m1 ) - fTV[1] * m1;
	+ FF.m_FT[2] = m2 * ( fTV[0] - fTV[1] ) - fTV[0] * m21 * m2;

	- FF.GT_[0] = -fTA[1] * ( m1 - m2 ) + fTA[0] * ( q2 / m1 );
	- FF.GT_[1] = -fTA[1] * m1 + fTA[0] * ( m1 + m2 );
	- FF.GT_[2] = -fTA[0] * m2 * m21 - m2 * ( fTA[0] + fTA[1] );
	+ FF.m_GT[0] = -fTA[1] * ( m1 - m2 ) + fTA[0] * ( q2 / m1 );
	+ FF.m_GT[1] = -fTA[1] * m1 + fTA[0] * ( m1 + m2 );
	+ FF.m_GT[2] = -fTA[0] * m2 * m21 - m2 * ( fTA[0] + fTA[1] );

	return;
	}
	diff --git a/src/EvtGenModels/EvtRareLbToLllFFlQCD.cpp b/src/EvtGenModels/EvtRareLbToLllFFlQCD.cpp
	--- a/src/EvtGenModels/EvtRareLbToLllFFlQCD.cpp
	+++ b/src/EvtGenModels/EvtRareLbToLllFFlQCD.cpp
	@@ -47,48 +47,48 @@
	const double m2 = EvtPDL::getMass( LID );
	const double mB = EvtPDL::getMass( BID );
	const double mK = EvtPDL::getMass( KID );
	- t0 = ( m1 - m2 ) * ( m1 - m2 );
	- tplus = ( mB + mK ) * ( mB + mK );
	-
	- fconsts[0][0] = 0.4221;
	- fconsts[0][1] = -1.1386;
	- fconsts[0][2] = 5.416;
	- fconsts[1][0] = 0.5182;
	- fconsts[1][1] = -1.3495;
	- fconsts[1][2] = 5.416;
	- fconsts[2][0] = 0.3725;
	- fconsts[2][1] = -0.9389;
	- fconsts[2][2] = 5.711;
	-
	- gconsts[0][0] = 0.3563;
	- gconsts[0][1] = -1.0612;
	- gconsts[0][2] = 5.750;
	- gconsts[1][0] = 0.3563;
	- gconsts[1][1] = -1.1357;
	- gconsts[1][2] = 5.750;
	- gconsts[2][0] = 0.4028;
	- gconsts[2][1] = -1.0290;
	- gconsts[2][2] = 5.367;
	-
	- hconsts[0][0] = 0.4960;
	- hconsts[0][1] = -1.1275;
	- hconsts[0][2] = 5.416;
	- hconsts[1][0] = 0.3876;
	- hconsts[1][1] = -0.9623;
	- hconsts[1][2] = 5.416;
	- hconsts[2][0] = 0;
	- hconsts[2][1] = 0;
	- hconsts[2][2] = 0;
	-
	- htildaconsts[0][0] = 0.3403;
	- htildaconsts[0][1] = -0.7697;
	- htildaconsts[0][2] = 5.750;
	- htildaconsts[1][0] = 0.3403;
	- htildaconsts[1][1] = -0.8008;
	- htildaconsts[1][2] = 5.750;
	- htildaconsts[2][0] = 0;
	- htildaconsts[2][1] = 0;
	- htildaconsts[2][2] = 0;
	+ m_t0 = ( m1 - m2 ) * ( m1 - m2 );
	+ m_tplus = ( mB + mK ) * ( mB + mK );
	+
	+ m_fconsts[0][0] = 0.4221;
	+ m_fconsts[0][1] = -1.1386;
	+ m_fconsts[0][2] = 5.416;
	+ m_fconsts[1][0] = 0.5182;
	+ m_fconsts[1][1] = -1.3495;
	+ m_fconsts[1][2] = 5.416;
	+ m_fconsts[2][0] = 0.3725;
	+ m_fconsts[2][1] = -0.9389;
	+ m_fconsts[2][2] = 5.711;
	+
	+ m_gconsts[0][0] = 0.3563;
	+ m_gconsts[0][1] = -1.0612;
	+ m_gconsts[0][2] = 5.750;
	+ m_gconsts[1][0] = 0.3563;
	+ m_gconsts[1][1] = -1.1357;
	+ m_gconsts[1][2] = 5.750;
	+ m_gconsts[2][0] = 0.4028;
	+ m_gconsts[2][1] = -1.0290;
	+ m_gconsts[2][2] = 5.367;
	+
	+ m_hconsts[0][0] = 0.4960;
	+ m_hconsts[0][1] = -1.1275;
	+ m_hconsts[0][2] = 5.416;
	+ m_hconsts[1][0] = 0.3876;
	+ m_hconsts[1][1] = -0.9623;
	+ m_hconsts[1][2] = 5.416;
	+ m_hconsts[2][0] = 0;
	+ m_hconsts[2][1] = 0;
	+ m_hconsts[2][2] = 0;
	+
	+ m_htildaconsts[0][0] = 0.3403;
	+ m_htildaconsts[0][1] = -0.7697;
	+ m_htildaconsts[0][2] = 5.750;
	+ m_htildaconsts[1][0] = 0.3403;
	+ m_htildaconsts[1][1] = -0.8008;
	+ m_htildaconsts[1][2] = 5.750;
	+ m_htildaconsts[2][0] = 0;
	+ m_htildaconsts[2][1] = 0;
	+ m_htildaconsts[2][2] = 0;

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< " EvtRareLbToLll is using form factors from arXiv:1602.01399 "
	@@ -124,61 +124,61 @@
	double htilda[2];

	for ( int i = 0; i <= 2; ++i ) {
	- f[i] = formFactorParametrization( q2, fconsts[i][0], fconsts[i][1],
	- fconsts[i][2] );
	- g[i] = formFactorParametrization( q2, gconsts[i][0], gconsts[i][1],
	- gconsts[i][2] );
	+ f[i] = formFactorParametrization( q2, m_fconsts[i][0], m_fconsts[i][1],
	+ m_fconsts[i][2] );
	+ g[i] = formFactorParametrization( q2, m_gconsts[i][0], m_gconsts[i][1],
	+ m_gconsts[i][2] );
	}
	for ( int i = 0; i <= 1; ++i ) {
	- h[i] = formFactorParametrization( q2, hconsts[i][0], hconsts[i][1],
	- hconsts[i][2] );
	- htilda[i] = formFactorParametrization( q2, htildaconsts[i][0],
	- htildaconsts[i][1],
	- htildaconsts[i][2] );
	+ h[i] = formFactorParametrization( q2, m_hconsts[i][0], m_hconsts[i][1],
	+ m_hconsts[i][2] );
	+ htilda[i] = formFactorParametrization( q2, m_htildaconsts[i][0],
	+ m_htildaconsts[i][1],
	+ m_htildaconsts[i][2] );
	}

	// Both v^2==v'^2==1 by definition
	- FF.F_[0] = f[1];
	- FF.F_[1] = m1 *
	- ( ( f[1] - f[0] ) * massSum +
	- massDiff *
	- ( q2 * ( f[2] - f[1] ) - ( f[2] - f[0] ) * massSumSq ) /
	- q2 ) /
	- q2Sum;
	- FF.F_[2] = -m2 *
	- ( massSum * ( f[0] - f[1] ) +
	- massDiff *
	- ( q2 * ( f[2] - f[1] ) - massSumSq * ( f[2] - f[0] ) ) /
	- q2 ) /
	- q2Sum;
	-
	- FF.G_[0] = g[1];
	- FF.G_[1] = m1 / q2Diff *
	- ( massDiff * ( g[0] - g[1] ) +
	- massSum *
	- ( q2 * ( g[1] - g[2] ) + massDiffSq * ( g[2] - g[0] ) ) /
	- q2 );
	- FF.G_[2] = -m2 / q2Diff *
	- ( massDiff * ( g[1] - g[0] ) +
	- massSum *
	- ( q2 * ( g[1] - g[2] ) + massDiffSq * ( g[2] - g[0] ) ) /
	- q2 );
	-
	- FF.FT_[0] = -massSum * h[1];
	-
	- FF.FT_[1] = -m1 / q2Sum *
	- ( 2 * h[1] * m2 * massSum - h[0] * ( q2 - massSum * massDiff ) );
	- FF.FT_[2] = -m2 / q2Sum *
	- ( 2 * h[1] * m1 * massSum - h[0] * ( q2 + massSum * massDiff ) );
	-
	- FF.GT_[0] = massDiff * htilda[1];
	-
	- FF.GT_[1] = m1 / q2Diff *
	- ( 2 * htilda[1] * massDiff * m2 +
	- htilda[0] * ( q2 - massSum * massDiff ) );
	- FF.GT_[2] = m2 / q2Diff *
	- ( -2 * htilda[1] * massDiff * m1 +
	- htilda[0] * ( q2 + massSum * massDiff ) );
	+ FF.m_F[0] = f[1];
	+ FF.m_F[1] = m1 *
	+ ( ( f[1] - f[0] ) * massSum +
	+ massDiff *
	+ ( q2 * ( f[2] - f[1] ) - ( f[2] - f[0] ) * massSumSq ) /
	+ q2 ) /
	+ q2Sum;
	+ FF.m_F[2] = -m2 *
	+ ( massSum * ( f[0] - f[1] ) +
	+ massDiff *
	+ ( q2 * ( f[2] - f[1] ) - massSumSq * ( f[2] - f[0] ) ) /
	+ q2 ) /
	+ q2Sum;
	+
	+ FF.m_G[0] = g[1];
	+ FF.m_G[1] = m1 / q2Diff *
	+ ( massDiff * ( g[0] - g[1] ) +
	+ massSum *
	+ ( q2 * ( g[1] - g[2] ) + massDiffSq * ( g[2] - g[0] ) ) /
	+ q2 );
	+ FF.m_G[2] = -m2 / q2Diff *
	+ ( massDiff * ( g[1] - g[0] ) +
	+ massSum *
	+ ( q2 * ( g[1] - g[2] ) + massDiffSq * ( g[2] - g[0] ) ) /
	+ q2 );
	+
	+ FF.m_FT[0] = -massSum * h[1];
	+
	+ FF.m_FT[1] = -m1 / q2Sum *
	+ ( 2 * h[1] * m2 * massSum - h[0] * ( q2 - massSum * massDiff ) );
	+ FF.m_FT[2] = -m2 / q2Sum *
	+ ( 2 * h[1] * m1 * massSum - h[0] * ( q2 + massSum * massDiff ) );
	+
	+ FF.m_GT[0] = massDiff * htilda[1];
	+
	+ FF.m_GT[1] = m1 / q2Diff *
	+ ( 2 * htilda[1] * massDiff * m2 +
	+ htilda[0] * ( q2 - massSum * massDiff ) );
	+ FF.m_GT[2] = m2 / q2Diff *
	+ ( -2 * htilda[1] * massDiff * m1 +
	+ htilda[0] * ( q2 + massSum * massDiff ) );

	return;
	}
	@@ -194,8 +194,8 @@

	double EvtRareLbToLllFFlQCD::zvar( const double q2 ) const
	{
	- const double a = std::sqrt( tplus - q2 );
	- const double b = std::sqrt( tplus - t0 );
	+ const double a = std::sqrt( m_tplus - q2 );
	+ const double b = std::sqrt( m_tplus - m_t0 );

	return ( a - b ) / ( a + b );
	}
	diff --git a/src/EvtGenModels/EvtSLBKPole.cpp b/src/EvtGenModels/EvtSLBKPole.cpp
	--- a/src/EvtGenModels/EvtSLBKPole.cpp
	+++ b/src/EvtGenModels/EvtSLBKPole.cpp
	@@ -49,7 +49,7 @@

	p->initializePhaseSpace( getNDaug(), getDaugs() );

	- calcamp->CalcAmp( p, _amp2, SLBKPoleffmodel.get() ); //modified
	+ m_calcamp->CalcAmp( p, m_amp2, m_SLBKPoleffmodel.get() ); //modified
	return;
	}

	@@ -62,8 +62,8 @@
	lnum = getDaug( 1 );
	nunum = getDaug( 2 );

	- double mymaxprob = calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	- SLBKPoleffmodel.get() ); //modified
	+ double mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	+ m_SLBKPoleffmodel.get() ); //modified

	setProbMax( mymaxprob );
	}
	@@ -82,18 +82,18 @@

	EvtSpinType::spintype mesontype = EvtPDL::getSpinType( getDaug( 0 ) );

	- SLBKPoleffmodel = std::make_unique<EvtSLBKPoleFF>( getNArg(),
	- getArgs() ); //modified
	+ m_SLBKPoleffmodel = std::make_unique<EvtSLBKPoleFF>( getNArg(),
	+ getArgs() ); //modified

	switch ( mesontype ) {
	case EvtSpinType::SCALAR:
	- calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	break;
	case EvtSpinType::VECTOR:
	- calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	break;
	case EvtSpinType::TENSOR:
	- calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	break;
	default:;
	}
	diff --git a/src/EvtGenModels/EvtSLBKPoleFF.cpp b/src/EvtGenModels/EvtSLBKPoleFF.cpp
	--- a/src/EvtGenModels/EvtSLBKPoleFF.cpp
	+++ b/src/EvtGenModels/EvtSLBKPoleFF.cpp
	@@ -29,10 +29,10 @@
	#include <string>

	EvtSLBKPoleFF::EvtSLBKPoleFF( int numarg, double* arglist )
	-{ //modified
	- numSLBKPoleargs = numarg; //modified
	+{ //modified
	+ m_numSLBKPoleargs = numarg; //modified
	for ( int i = 0; i < numarg; i++ ) {
	- SLBKPoleargs[i] = arglist[i];
	+ m_SLBKPoleargs[i] = arglist[i];
	} //modified

	return;
	@@ -44,34 +44,30 @@
	// Form factors have a general form, with parameters passed in
	// from the arguments.

	- if ( numSLBKPoleargs != 4 ) { //modified
	+ if ( m_numSLBKPoleargs != 4 ) { //modified
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Problem in EvtSLBKPoleFF::getscalarff\n";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "wrong number of arguments!\n";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "number args:" << numSLBKPoleargs << " (expected 4)\n";
	+ << "number args:" << m_numSLBKPoleargs << " (expected 4)\n";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Parent:" << EvtPDL::name( parent ) << "\n";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Daughter:" << EvtPDL::name( daught ) << "\n";
	}

	- double f0, af, powf;
	+ double f0 = m_SLBKPoleargs[0]; //f0
	+ double af = m_SLBKPoleargs[1]; //alpha

	- //double a_0, a_1, a_2, a_3, a_4, a_5, a_6, a_7;
	-
	- f0 = SLBKPoleargs[0]; //f0
	- af = SLBKPoleargs[1]; //alpha
	- //bf = SLBKPoleargs[2];
	- double mass_star2 = SLBKPoleargs[3] * SLBKPoleargs[3];
	- powf = 1.0;
	+ double mass_star2 = m_SLBKPoleargs[3] * m_SLBKPoleargs[3];
	+ double powf = 1.0;
	fpf = f0 / ( pow( 1.0 - ( 1.0 + af ) ( t / mass_star2 ) +
	( af * ( ( t / mass_star2 ) * ( t / mass_star2 ) ) ),
	powf ) ); //modified

	- f0 = SLBKPoleargs[0]; //f0
	- af = SLBKPoleargs[2]; //beta
	- //bf = SLBKPoleargs[6];
	+ f0 = m_SLBKPoleargs[0]; //f0
	+ af = m_SLBKPoleargs[2]; //beta
	+
	powf = 1.0;

	*f0f = f0 / ( pow( 1.0 - ( t / mass_star2 / af ), powf ) ); //modified
	@@ -83,14 +79,13 @@
	double /mass/, double* a1f, double* a2f,
	double* vf, double* a0f )
	{
	- if ( numSLBKPoleargs != 8 ) { //modified
	+ if ( m_numSLBKPoleargs != 8 ) { //modified
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Problem in EvtSLBKPoleFF::getvectorff\n"; //modified
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "wrong number of arguements!!!\n";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << numSLBKPoleargs << "\n"; //modified
	- // printf("\n*******************%d*******************",numSLBKPoleargs);
	+ << m_numSLBKPoleargs << "\n"; //modified
	}

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -150,37 +145,35 @@
	}
	//modified-end

	- double f0, af, bf, powf;
	-
	- f0 = SLBKPoleargs[2]; //A1
	- af = SLBKPoleargs[6]; //b'
	- bf = 0; //0
	- powf = 1.0; //1.0
	+ double f0 = m_SLBKPoleargs[2]; //A1
	+ double af = m_SLBKPoleargs[6]; //b'
	+ double bf = 0; //0
	+ double powf = 1.0; //1.0
	a1f = f0 / ( pow( 1.0 - af t / mass_star2, powf ) ); //modified

	- f0 = SLBKPoleargs[3]; //A2
	- af = SLBKPoleargs[6]; //b'
	- bf = SLBKPoleargs[7]; //b''==0
	- powf = 1.0; //1.0
	+ f0 = m_SLBKPoleargs[3]; //A2
	+ af = m_SLBKPoleargs[6]; //b'
	+ bf = m_SLBKPoleargs[7]; //b''==0
	+ powf = 1.0; //1.0

	*a2f = f0 /
	( pow( 1.0 - ( af + bf ) * ( t / mass_star2 ) +
	( af * bf ) * ( ( t / mass_star2 ) * ( t / mass_star2 ) ),
	powf ) ); //modified

	- f0 = SLBKPoleargs[0]; //V0
	- af = SLBKPoleargs[4]; //a
	- bf = 0; //0
	- powf = 1.0; //1.0
	+ f0 = m_SLBKPoleargs[0]; //V0
	+ af = m_SLBKPoleargs[4]; //a
	+ bf = 0; //0
	+ powf = 1.0; //1.0

	vf = f0 / ( pow( 1.0 - ( 1.0 + af ) ( t / mass_star2 ) +
	af * ( t / mass_star2 ) * ( t / mass_star2 ),
	powf ) ); //modified

	- f0 = SLBKPoleargs[1]; //A0
	- af = SLBKPoleargs[5]; //a'
	- bf = 0; //0
	- powf = 1.0; //1.0
	+ f0 = m_SLBKPoleargs[1]; //A0
	+ af = m_SLBKPoleargs[5]; //a'
	+ bf = 0; //0
	+ powf = 1.0; //1.0

	a0f = f0 / ( pow( 1.0 - ( 1.0 + af ) ( t / mb2 ) +
	af * ( ( t / mb2 ) * ( t / mb2 ) ),
	@@ -192,7 +185,7 @@
	double /mass/, double* hf, double* kf,
	double* bpf, double* bmf )
	{
	- if ( numSLBKPoleargs != 16 ) {
	+ if ( m_numSLBKPoleargs != 16 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Problem in EvtSLBKPoleFF::gettensorff\n";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -205,38 +198,36 @@
	double mb = EvtPDL::getMeanMass( parent );
	double mb2 = mb * mb;

	- double f0, af, bf, powf;
	-
	- f0 = SLBKPoleargs[0];
	- af = SLBKPoleargs[1];
	- bf = SLBKPoleargs[2];
	- powf = SLBKPoleargs[3];
	+ double f0 = m_SLBKPoleargs[0];
	+ double af = m_SLBKPoleargs[1];
	+ double bf = m_SLBKPoleargs[2];
	+ double powf = m_SLBKPoleargs[3];
	*hf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLBKPoleargs[4];
	- af = SLBKPoleargs[5];
	- bf = SLBKPoleargs[6];
	- powf = SLBKPoleargs[7];
	+ f0 = m_SLBKPoleargs[4];
	+ af = m_SLBKPoleargs[5];
	+ bf = m_SLBKPoleargs[6];
	+ powf = m_SLBKPoleargs[7];

	*kf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLBKPoleargs[8];
	- af = SLBKPoleargs[9];
	- bf = SLBKPoleargs[10];
	- powf = SLBKPoleargs[11];
	+ f0 = m_SLBKPoleargs[8];
	+ af = m_SLBKPoleargs[9];
	+ bf = m_SLBKPoleargs[10];
	+ powf = m_SLBKPoleargs[11];

	*bpf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLBKPoleargs[12];
	- af = SLBKPoleargs[13];
	- bf = SLBKPoleargs[14];
	- powf = SLBKPoleargs[15];
	+ f0 = m_SLBKPoleargs[12];
	+ af = m_SLBKPoleargs[13];
	+ bf = m_SLBKPoleargs[14];
	+ powf = m_SLBKPoleargs[15];

	*bmf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	diff --git a/src/EvtGenModels/EvtSLBaryonAmp.cpp b/src/EvtGenModels/EvtSLBaryonAmp.cpp
	--- a/src/EvtGenModels/EvtSLBaryonAmp.cpp
	+++ b/src/EvtGenModels/EvtSLBaryonAmp.cpp
	@@ -586,8 +586,6 @@

	const double form_fact[8] = { f1, f2, f3, f4, g1, g2, g3, g4 };

	- EvtId l_num = parent->getDaug( 1 )->getId();
	-
	EvtVector4C b11, b12, b21, b22, b13, b23, b14, b24, l1, l2;

	// Lepton Current
	diff --git a/src/EvtGenModels/EvtSLDiBaryonAmp.cpp b/src/EvtGenModels/EvtSLDiBaryonAmp.cpp
	--- a/src/EvtGenModels/EvtSLDiBaryonAmp.cpp
	+++ b/src/EvtGenModels/EvtSLDiBaryonAmp.cpp
	@@ -30,7 +30,7 @@
	#include "EvtGenBase/EvtTensor4C.hh"

	EvtSLDiBaryonAmp::EvtSLDiBaryonAmp( const EvtBToDiBaryonlnupQCDFF& formFactors ) :
	- ffModel_( formFactors )
	+ m_ffModel( formFactors )
	{
	}

	@@ -146,31 +146,31 @@
	if ( type1 == EvtSpinType::DIRAC && type2 == EvtSpinType::DIRAC ) {
	// Form factor parameters
	EvtBToDiBaryonlnupQCDFF::FormFactors FF;
	- ffModel_.getDiracFF( parent, m_dibaryon, FF );
	+ m_ffModel.getDiracFF( parent, m_dibaryon, FF );

	if ( sameParity == 1 ) {
	- f1 = FF.F1;
	- f2 = FF.F2;
	- f3 = FF.F3;
	- f4 = FF.F4;
	- f5 = FF.F5;
	- g1 = FF.G1;
	- g2 = FF.G2;
	- g3 = FF.G3;
	- g4 = FF.G4;
	- g5 = FF.G5;
	+ f1 = FF.m_F1;
	+ f2 = FF.m_F2;
	+ f3 = FF.m_F3;
	+ f4 = FF.m_F4;
	+ f5 = FF.m_F5;
	+ g1 = FF.m_G1;
	+ g2 = FF.m_G2;
	+ g3 = FF.m_G3;
	+ g4 = FF.m_G4;
	+ g5 = FF.m_G5;
	} else {
	// Swap coeffs: f_i <--> g_i
	- f1 = FF.G1;
	- f2 = FF.G2;
	- f3 = FF.G3;
	- f4 = FF.G4;
	- f5 = FF.G5;
	- g1 = FF.F1;
	- g2 = FF.F2;
	- g3 = FF.F3;
	- g4 = FF.F4;
	- g5 = FF.F5;
	+ f1 = FF.m_G1;
	+ f2 = FF.m_G2;
	+ f3 = FF.m_G3;
	+ f4 = FF.m_G4;
	+ f5 = FF.m_G5;
	+ g1 = FF.m_F1;
	+ g2 = FF.m_F2;
	+ g3 = FF.m_F3;
	+ g4 = FF.m_F4;
	+ g5 = FF.m_F5;
	}

	EvtVector4R gMtmTerms = g3 * p + g4 * pSum + g5 * pDiff;
	@@ -223,31 +223,31 @@

	// Form factor parameters
	EvtBToDiBaryonlnupQCDFF::FormFactors FF;
	- ffModel_.getRaritaFF( parent, m_dibaryon, FF );
	+ m_ffModel.getRaritaFF( parent, m_dibaryon, FF );

	if ( sameParity == 1 ) {
	- f1 = FF.F1;
	- f2 = FF.F2;
	- f3 = FF.F3;
	- f4 = FF.F4;
	- f5 = FF.F5;
	- g1 = FF.G1;
	- g2 = FF.G2;
	- g3 = FF.G3;
	- g4 = FF.G4;
	- g5 = FF.G5;
	+ f1 = FF.m_F1;
	+ f2 = FF.m_F2;
	+ f3 = FF.m_F3;
	+ f4 = FF.m_F4;
	+ f5 = FF.m_F5;
	+ g1 = FF.m_G1;
	+ g2 = FF.m_G2;
	+ g3 = FF.m_G3;
	+ g4 = FF.m_G4;
	+ g5 = FF.m_G5;
	} else {
	// Swap coeffs: f_i <--> g_i
	- f1 = FF.G1;
	- f2 = FF.G2;
	- f3 = FF.G3;
	- f4 = FF.G4;
	- f5 = FF.G5;
	- g1 = FF.F1;
	- g2 = FF.F2;
	- g3 = FF.F3;
	- g4 = FF.F4;
	- g5 = FF.F5;
	+ f1 = FF.m_G1;
	+ f2 = FF.m_G2;
	+ f3 = FF.m_G3;
	+ f4 = FF.m_G4;
	+ f5 = FF.m_G5;
	+ g1 = FF.m_F1;
	+ g2 = FF.m_F2;
	+ g3 = FF.m_F3;
	+ g4 = FF.m_F4;
	+ g5 = FF.m_F5;
	}

	EvtVector4R gMtmTerms = g3 * p + g4 * pSum + g5 * pDiff;
	diff --git a/src/EvtGenModels/EvtSLPole.cpp b/src/EvtGenModels/EvtSLPole.cpp
	--- a/src/EvtGenModels/EvtSLPole.cpp
	+++ b/src/EvtGenModels/EvtSLPole.cpp
	@@ -46,8 +46,8 @@

	void EvtSLPole::decay( EvtParticle* p )
	{
	- p->initializePhaseSpace( getNDaug(), getDaugs(), _resetDaughterTree );
	- calcamp->CalcAmp( p, _amp2, SLPoleffmodel.get() );
	+ p->initializePhaseSpace( getNDaug(), getDaugs(), m_resetDaughterTree );
	+ m_calcamp->CalcAmp( p, m_amp2, m_SLPoleffmodel.get() );
	}

	void EvtSLPole::initProbMax()
	@@ -59,8 +59,8 @@
	lnum = getDaug( 1 );
	nunum = getDaug( 2 );

	- double mymaxprob = calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	- SLPoleffmodel.get() );
	+ double mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, lnum, nunum,
	+ m_SLPoleffmodel.get() );

	setProbMax( mymaxprob );
	}
	@@ -78,22 +78,22 @@

	EvtSpinType::spintype mesontype = EvtPDL::getSpinType( getDaug( 0 ) );

	- SLPoleffmodel = std::make_unique<EvtSLPoleFF>( getNArg(), getArgs() );
	+ m_SLPoleffmodel = std::make_unique<EvtSLPoleFF>( getNArg(), getArgs() );

	switch ( mesontype ) {
	case EvtSpinType::SCALAR:
	- calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicScalarAmp>();
	break;
	case EvtSpinType::VECTOR:
	- calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicVectorAmp>();
	break;
	case EvtSpinType::TENSOR:
	- calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	+ m_calcamp = std::make_unique<EvtSemiLeptonicTensorAmp>();
	break;
	default:;
	}

	- _resetDaughterTree = false;
	+ m_resetDaughterTree = false;
	if ( getArgStr( getNArg() - 1 ) == "true" )
	- _resetDaughterTree = true;
	+ m_resetDaughterTree = true;
	}
	diff --git a/src/EvtGenModels/EvtSLPoleFF.cpp b/src/EvtGenModels/EvtSLPoleFF.cpp
	--- a/src/EvtGenModels/EvtSLPoleFF.cpp
	+++ b/src/EvtGenModels/EvtSLPoleFF.cpp
	@@ -31,9 +31,9 @@
	EvtSLPoleFF::EvtSLPoleFF( int numarg, double* arglist )
	{
	//arg - maybe ignore the last argument - if odd ... Sigh
	- numSLPoleargs = numarg - ( numarg % 2 );
	- for ( int i = 0; i < numSLPoleargs; i++ ) {
	- SLPoleargs[i] = arglist[i];
	+ m_numSLPoleargs = numarg - ( numarg % 2 );
	+ for ( int i = 0; i < m_numSLPoleargs; i++ ) {
	+ m_SLPoleargs[i] = arglist[i];
	}

	return;
	@@ -45,7 +45,7 @@
	// Form factors have a general form, with parameters passed in
	// from the arguements.

	- if ( numSLPoleargs != 8 ) {
	+ if ( m_numSLPoleargs != 8 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Problem in EvtSLPoleFF::getscalarff\n";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -57,18 +57,18 @@

	double f0, af, bf, powf;

	- f0 = SLPoleargs[0];
	- af = SLPoleargs[1];
	- bf = SLPoleargs[2];
	- powf = SLPoleargs[3];
	+ f0 = m_SLPoleargs[0];
	+ af = m_SLPoleargs[1];
	+ bf = m_SLPoleargs[2];
	+ powf = m_SLPoleargs[3];
	*fpf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLPoleargs[4];
	- af = SLPoleargs[5];
	- bf = SLPoleargs[6];
	- powf = SLPoleargs[7];
	+ f0 = m_SLPoleargs[4];
	+ af = m_SLPoleargs[5];
	+ bf = m_SLPoleargs[6];
	+ powf = m_SLPoleargs[7];

	*f0f = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	@@ -80,12 +80,12 @@
	void EvtSLPoleFF::getvectorff( EvtId parent, EvtId, double t, double,
	double* a1f, double* a2f, double* vf, double* a0f )
	{
	- if ( numSLPoleargs != 16 ) {
	+ if ( m_numSLPoleargs != 16 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Problem in EvtSLPoleFF::getvectorff\n";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "wrong number of arguements!!!\n";
	- EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << numSLPoleargs << "\n";
	+ EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << m_numSLPoleargs << "\n";
	}

	double mb = EvtPDL::getMeanMass( parent );
	@@ -93,36 +93,36 @@

	double f0, af, bf, powf;

	- f0 = SLPoleargs[0];
	- af = SLPoleargs[1];
	- bf = SLPoleargs[2];
	- powf = SLPoleargs[3];
	+ f0 = m_SLPoleargs[0];
	+ af = m_SLPoleargs[1];
	+ bf = m_SLPoleargs[2];
	+ powf = m_SLPoleargs[3];
	*a1f = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLPoleargs[4];
	- af = SLPoleargs[5];
	- bf = SLPoleargs[6];
	- powf = SLPoleargs[7];
	+ f0 = m_SLPoleargs[4];
	+ af = m_SLPoleargs[5];
	+ bf = m_SLPoleargs[6];
	+ powf = m_SLPoleargs[7];

	*a2f = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLPoleargs[8];
	- af = SLPoleargs[9];
	- bf = SLPoleargs[10];
	- powf = SLPoleargs[11];
	+ f0 = m_SLPoleargs[8];
	+ af = m_SLPoleargs[9];
	+ bf = m_SLPoleargs[10];
	+ powf = m_SLPoleargs[11];

	*vf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLPoleargs[12];
	- af = SLPoleargs[13];
	- bf = SLPoleargs[14];
	- powf = SLPoleargs[15];
	+ f0 = m_SLPoleargs[12];
	+ af = m_SLPoleargs[13];
	+ bf = m_SLPoleargs[14];
	+ powf = m_SLPoleargs[15];

	*a0f = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	@@ -133,7 +133,7 @@
	void EvtSLPoleFF::gettensorff( EvtId parent, EvtId, double t, double,
	double* hf, double* kf, double* bpf, double* bmf )
	{
	- if ( numSLPoleargs != 16 ) {
	+ if ( m_numSLPoleargs != 16 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Problem in EvtSLPoleFF::gettensorff\n";
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -145,36 +145,36 @@

	double f0, af, bf, powf;

	- f0 = SLPoleargs[0];
	- af = SLPoleargs[1];
	- bf = SLPoleargs[2];
	- powf = SLPoleargs[3];
	+ f0 = m_SLPoleargs[0];
	+ af = m_SLPoleargs[1];
	+ bf = m_SLPoleargs[2];
	+ powf = m_SLPoleargs[3];
	*hf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLPoleargs[4];
	- af = SLPoleargs[5];
	- bf = SLPoleargs[6];
	- powf = SLPoleargs[7];
	+ f0 = m_SLPoleargs[4];
	+ af = m_SLPoleargs[5];
	+ bf = m_SLPoleargs[6];
	+ powf = m_SLPoleargs[7];

	*kf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLPoleargs[8];
	- af = SLPoleargs[9];
	- bf = SLPoleargs[10];
	- powf = SLPoleargs[11];
	+ f0 = m_SLPoleargs[8];
	+ af = m_SLPoleargs[9];
	+ bf = m_SLPoleargs[10];
	+ powf = m_SLPoleargs[11];

	*bpf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	powf ) );

	- f0 = SLPoleargs[12];
	- af = SLPoleargs[13];
	- bf = SLPoleargs[14];
	- powf = SLPoleargs[15];
	+ f0 = m_SLPoleargs[12];
	+ af = m_SLPoleargs[13];
	+ bf = m_SLPoleargs[14];
	+ powf = m_SLPoleargs[15];

	*bmf = f0 /
	( pow( 1.0 + ( af * t / mb2 ) + ( bf * ( ( t / mb2 ) * ( t / mb2 ) ) ),
	diff --git a/src/EvtGenModels/EvtSSDCP.cpp b/src/EvtGenModels/EvtSSDCP.cpp
	--- a/src/EvtGenModels/EvtSSDCP.cpp
	+++ b/src/EvtGenModels/EvtSSDCP.cpp
	@@ -83,23 +83,23 @@
	::abort();
	}

	- _dm = getArg( 0 ) / EvtConst::c; //units of 1/mm
	+ m_dm = getArg( 0 ) / EvtConst::c; //units of 1/mm

	- _dgog = getArg( 1 );
	+ m_dgog = getArg( 1 );

	- _qoverp = getArg( 2 ) * EvtComplex( cos( getArg( 3 ) ), sin( getArg( 3 ) ) );
	- _poverq = 1.0 / _qoverp;
	+ m_qoverp = getArg( 2 ) * EvtComplex( cos( getArg( 3 ) ), sin( getArg( 3 ) ) );
	+ m_poverq = 1.0 / m_qoverp;

	- _A_f = getArg( 4 ) * EvtComplex( cos( getArg( 5 ) ), sin( getArg( 5 ) ) );
	+ m_A_f = getArg( 4 ) * EvtComplex( cos( getArg( 5 ) ), sin( getArg( 5 ) ) );

	- _Abar_f = getArg( 6 ) * EvtComplex( cos( getArg( 7 ) ), sin( getArg( 7 ) ) );
	+ m_Abar_f = getArg( 6 ) * EvtComplex( cos( getArg( 7 ) ), sin( getArg( 7 ) ) );

	if ( getNArg() >= 12 ) {
	- _eigenstate = false;
	- _A_fbar = getArg( 8 ) *
	- EvtComplex( cos( getArg( 9 ) ), sin( getArg( 9 ) ) );
	- _Abar_fbar = getArg( 10 ) *
	- EvtComplex( cos( getArg( 11 ) ), sin( getArg( 11 ) ) );
	+ m_eigenstate = false;
	+ m_A_fbar = getArg( 8 ) *
	+ EvtComplex( cos( getArg( 9 ) ), sin( getArg( 9 ) ) );
	+ m_Abar_fbar = getArg( 10 ) *
	+ EvtComplex( cos( getArg( 11 ) ), sin( getArg( 11 ) ) );
	} else {
	//I'm somewhat confused about this. For a CP eigenstate set the
	//amplitudes to the same. For a non CP eigenstate CPT invariance
	@@ -108,37 +108,37 @@
	getDaug( 1 ) == EvtPDL::chargeConj( getDaug( 1 ) ) ) \|\|
	( getDaug( 0 ) == EvtPDL::chargeConj( getDaug( 1 ) ) &&
	getDaug( 1 ) == EvtPDL::chargeConj( getDaug( 0 ) ) ) ) {
	- _eigenstate = true;
	+ m_eigenstate = true;
	} else {
	- _eigenstate = false;
	- _A_fbar = conj( _Abar_f );
	- _Abar_fbar = conj( _A_f );
	+ m_eigenstate = false;
	+ m_A_fbar = conj( m_Abar_f );
	+ m_Abar_fbar = conj( m_A_f );
	}
	}

	//FS: new check for z
	- if ( getNArg() == 14 ) { //FS Set _z parameter if provided else set it 0
	- _z = EvtComplex( getArg( 12 ), getArg( 13 ) );
	+ if ( getNArg() == 14 ) { //FS Set m_z parameter if provided else set it 0
	+ m_z = EvtComplex( getArg( 12 ), getArg( 13 ) );
	} else {
	- _z = EvtComplex( 0.0, 0.0 );
	+ m_z = EvtComplex( 0.0, 0.0 );
	}

	// FS substituted next 2 lines...

	//
	- // _gamma=EvtPDL::getctau(EvtPDL::getId("B0")); //units of 1/mm
	- //_dgamma=_gamma0.5_dgog;
	+ // m_gamma=EvtPDL::getctau(EvtPDL::getId("B0")); //units of 1/mm
	+ //m_dgamma=m_gamma0.5m_dgog;
	//
	// ...with:

	if ( ( getParentId() == EvtPDL::getId( "B0" ) ) \|\|
	( getParentId() == EvtPDL::getId( "anti-B0" ) ) ) {
	- _gamma = 1. / EvtPDL::getctau( EvtPDL::getId( "B0" ) ); //gamma/c (1/mm)
	+ m_gamma = 1. / EvtPDL::getctau( EvtPDL::getId( "B0" ) ); //gamma/c (1/mm)
	} else {
	- _gamma = 1. / EvtPDL::getctau( EvtPDL::getId( "B_s0" ) );
	+ m_gamma = 1. / EvtPDL::getctau( EvtPDL::getId( "B_s0" ) );
	}

	- _dgamma = _gamma * _dgog; //dgamma/c (1/mm)
	+ m_dgamma = m_gamma * m_dgog; //dgamma/c (1/mm)

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -150,22 +150,22 @@
	<< endl
	<< "using parameters:" << endl
	<< endl
	- << " delta(m) = " << _dm << " hbar/ps" << endl
	- << "dGamma = " << _dgamma << " ps-1" << endl
	- << " q/p = " << _qoverp << endl
	- << " z = " << _z << endl
	- << " tau = " << 1. / _gamma << " ps" << endl;
	+ << " delta(m) = " << m_dm << " hbar/ps" << endl
	+ << "dGamma = " << m_dgamma << " ps-1" << endl
	+ << " q/p = " << m_qoverp << endl
	+ << " z = " << m_z << endl
	+ << " tau = " << 1. / m_gamma << " ps" << endl;
	}
	}

	void EvtSSDCP::initProbMax()
	{
	- double theProbMax = abs( _A_f ) * abs( _A_f ) +
	- abs( _Abar_f ) * abs( _Abar_f ) +
	- abs( _A_fbar ) * abs( _A_fbar ) +
	- abs( _Abar_fbar ) * abs( _Abar_fbar );
	+ double theProbMax = abs( m_A_f ) * abs( m_A_f ) +
	+ abs( m_Abar_f ) * abs( m_Abar_f ) +
	+ abs( m_A_fbar ) * abs( m_A_fbar ) +
	+ abs( m_Abar_fbar ) * abs( m_Abar_fbar );

	- if ( _eigenstate )
	+ if ( m_eigenstate )
	theProbMax *= 2;

	EvtSpinType::spintype d2type = EvtPDL::getSpinType( getDaug( 1 ) );
	@@ -189,7 +189,7 @@
	EvtId daugs[2];

	int flip = 0;
	- if ( !_eigenstate ) {
	+ if ( !m_eigenstate ) {
	if ( EvtRandom::Flat( 0.0, 1.0 ) < 0.5 )
	flip = 1;
	}
	@@ -213,51 +213,50 @@
	//if (flip) t=-t;

	//FS We assume DGamma=GammaLow-GammaHeavy and Dm=mHeavy-mLow
	- EvtComplex expH = exp( -EvtComplex( -0.25 * _dgamma * t, 0.5 * _dm * t ) );
	- EvtComplex expL = exp( EvtComplex( -0.25 * _dgamma * t, 0.5 * _dm * t ) );
	+ EvtComplex expH = exp( -EvtComplex( -0.25 * m_dgamma * t, 0.5 * m_dm * t ) );
	+ EvtComplex expL = exp( EvtComplex( -0.25 * m_dgamma * t, 0.5 * m_dm * t ) );
	//FS Definition of gp and gm
	EvtComplex gp = 0.5 * ( expL + expH );
	EvtComplex gm = 0.5 * ( expL - expH );
	//FS Calculation os sqrt(1-z^2)
	- EvtComplex sqz = sqrt( abs( 1 - _z * _z ) ) *
	- exp( EvtComplex( 0, arg( 1 - _z * _z ) / 2 ) );
	+ EvtComplex sqz = sqrt( abs( 1 - m_z * m_z ) ) *
	+ exp( EvtComplex( 0, arg( 1 - m_z * m_z ) / 2 ) );

	//EvtComplex BB=0.5*(expL+expH); // <B0\|B0(t)>
	- //EvtComplex barBB=_qoverp0.5(expL-expH); // <B0bar\|B0(t)>
	- //EvtComplex BbarB=_poverq0.5(expL-expH); // <B0\|B0bar(t)>
	+ //EvtComplex barBB=m_qoverp0.5(expL-expH); // <B0bar\|B0(t)>
	+ //EvtComplex BbarB=m_poverq0.5(expL-expH); // <B0\|B0bar(t)>
	//EvtComplex barBbarB=BB; // <B0bar\|B0bar(t)>
	// FS redefinition of these guys... (See BAD #188 eq.35 for ref.)
	// q/p is taken as in the BaBar Phys. Book (opposite sign wrt ref.)
	- EvtComplex BB = gp + _z * gm; // <B0\|B0(t)>
	- EvtComplex barBB = sqz * _qoverp * gm; // <B0bar\|B0(t)>
	- EvtComplex BbarB = sqz * _poverq * gm; // <B0\|B0bar(t)>
	- EvtComplex barBbarB = gp - _z * gm; // <B0bar\|B0bar(t)>
	+ EvtComplex BB = gp + m_z * gm; // <B0\|B0(t)>
	+ EvtComplex barBB = sqz * m_qoverp * gm; // <B0bar\|B0(t)>
	+ EvtComplex BbarB = sqz * m_poverq * gm; // <B0\|B0bar(t)>
	+ EvtComplex barBbarB = gp - m_z * gm; // <B0bar\|B0bar(t)>

	if ( !flip ) {
	if ( other_b == B0B \|\| other_b == B0Bs ) {
	//at t=0 we have a B0
	//EvtGenReport(EVTGEN_INFO,"EvtGen") << "B0B"<<endl;
	- amp = BB * _A_f + barBB * _Abar_f;
	+ amp = BB * m_A_f + barBB * m_Abar_f;
	//std::cout << "noflip B0B tag:"<<amp<<std::endl;
	//amp=0.0;
	}
	if ( other_b == B0 \|\| other_b == B0s ) {
	//EvtGenReport(EVTGEN_INFO,"EvtGen") << "B0"<<endl;
	- amp = BbarB * _A_f + barBbarB * _Abar_f;
	+ amp = BbarB * m_A_f + barBbarB * m_Abar_f;
	}
	} else {
	if ( other_b == B0 \|\| other_b == B0s ) {
	- amp = BbarB * _A_fbar + barBbarB * _Abar_fbar;
	+ amp = BbarB * m_A_fbar + barBbarB * m_Abar_fbar;
	//std::cout << "flip B0 tag:"<<amp<<std::endl;
	//amp=0.0;
	}
	if ( other_b == B0B \|\| other_b == B0Bs ) {
	- amp = BB * _A_fbar + barBB * _Abar_fbar;
	+ amp = BB * m_A_fbar + barBB * m_Abar_fbar;
	}
	}

	EvtVector4R p4_parent = p->getP4Restframe();
	- double m_parent = p4_parent.mass();

	EvtSpinType::spintype d2type = EvtPDL::getSpinType( getDaug( 1 ) );

	@@ -294,7 +293,8 @@

	if ( d2type == EvtSpinType::TENSOR ) {
	double norm = d->mass() * d->mass() /
	- ( m_parent * d->getP4().d3mag() * d->getP4().d3mag() );
	+ ( p4_parent.mass() * d->getP4().d3mag() *
	+ d->getP4().d3mag() );

	vertex( 0, amp * norm * d->epsTensorParent( 0 ).cont1( p4_parent ) *
	p4_parent );
	diff --git a/src/EvtGenModels/EvtSSD_DirectCP.cpp b/src/EvtGenModels/EvtSSD_DirectCP.cpp
	--- a/src/EvtGenModels/EvtSSD_DirectCP.cpp
	+++ b/src/EvtGenModels/EvtSSD_DirectCP.cpp
	@@ -72,7 +72,7 @@
	::abort();
	}

	- _acp = getArg( 0 ); // A_CP defined as A_CP = (BR(fbar)-BR(f))/(BR(fbar)+BR(f))
	+ m_acp = getArg( 0 ); // A_CP defined as A_CP = (BR(fbar)-BR(f))/(BR(fbar)+BR(f))
	}

	void EvtSSD_DirectCP::initProbMax()
	@@ -167,7 +167,7 @@
	EvtId daugs[2];

	// decide it is B or Bbar:
	- if ( EvtRandom::Flat( 0., 1. ) < ( ( 1. - _acp ) / 2. ) ) {
	+ if ( EvtRandom::Flat( 0., 1. ) < ( ( 1. - m_acp ) / 2. ) ) {
	// it is a B
	if ( EvtPDL::getStdHep( getParentId() ) < 0 )
	flip = true;
	@@ -194,7 +194,7 @@

	parent->initializePhaseSpace( 2, daugs );

	- calcAmp( *parent, _amp2 );
	+ calcAmp( *parent, m_amp2 );
	}

	bool EvtSSD_DirectCP::isB0Mixed( const EvtParticle& p )
	diff --git a/src/EvtGenModels/EvtSSSCPT.cpp b/src/EvtGenModels/EvtSSSCPT.cpp
	--- a/src/EvtGenModels/EvtSSSCPT.cpp
	+++ b/src/EvtGenModels/EvtSSSCPT.cpp
	@@ -54,21 +54,21 @@

	void EvtSSSCPT::setAmpCoeffs()
	{
	- P = EvtComplex( cos( -getArg( 0 ) ), sin( -getArg( 0 ) ) );
	- Q = EvtComplex( cos( getArg( 0 ) ), sin( getArg( 0 ) ) );
	- D = EvtComplex( getArg( 6 ) * cos( getArg( 7 ) ),
	- getArg( 6 ) * sin( getArg( 7 ) ) );
	- Im = EvtComplex( 0.0, 1.0 );
	-
	- A = EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ),
	- getArg( 2 ) * sin( getArg( 3 ) ) );
	- Abar = EvtComplex( getArg( 4 ) * cos( getArg( 5 ) ),
	- getArg( 4 ) * sin( getArg( 5 ) ) );
	+ m_P = EvtComplex( cos( -getArg( 0 ) ), sin( -getArg( 0 ) ) );
	+ m_Q = EvtComplex( cos( getArg( 0 ) ), sin( getArg( 0 ) ) );
	+ m_D = EvtComplex( getArg( 6 ) * cos( getArg( 7 ) ),
	+ getArg( 6 ) * sin( getArg( 7 ) ) );
	+ m_Im = EvtComplex( 0.0, 1.0 );
	+
	+ m_A = EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ),
	+ getArg( 2 ) * sin( getArg( 3 ) ) );
	+ m_Abar = EvtComplex( getArg( 4 ) * cos( getArg( 5 ) ),
	+ getArg( 4 ) * sin( getArg( 5 ) ) );
	}

	void EvtSSSCPT::initProbMax()
	{
	- const double maxProb = 2.0 * abs2( A ) + 4.0 * abs2( Abar ) * abs2( D );
	+ const double maxProb = 2.0 * abs2( m_A ) + 4.0 * abs2( m_Abar ) * abs2( m_D );
	setProbMax( maxProb );
	}

	@@ -88,14 +88,14 @@
	EvtComplex amp;

	if ( other_b == B0B ) {
	- amp = A * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	- Im * sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) *
	- ( Q / P * A + 2.0 * D * Abar );
	+ amp = m_A * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	+ m_Im * sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) *
	+ ( m_Q / m_P * m_A + 2.0 * m_D * m_Abar );
	}
	if ( other_b == B0 ) {
	- amp = Abar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	- Im * sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) *
	- ( P / Q * A - 2.0 * D * Abar );
	+ amp = m_Abar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	+ m_Im * sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) *
	+ ( m_P / m_Q * m_A - 2.0 * m_D * m_Abar );
	}

	vertex( amp );
	diff --git a/src/EvtGenModels/EvtSTS.cpp b/src/EvtGenModels/EvtSTS.cpp
	--- a/src/EvtGenModels/EvtSTS.cpp
	+++ b/src/EvtGenModels/EvtSTS.cpp
	@@ -71,9 +71,8 @@

	EvtVector4R p4_parent = momt + moms;

	- double m_parent = p4_parent.mass();
	-
	- double norm = masst * masst / ( m_parent * momt.d3mag() * momt.d3mag() );
	+ double norm = masst * masst /
	+ ( p4_parent.mass() * momt.d3mag() * momt.d3mag() );

	vertex( 0, norm * t1->epsTensorParent( 0 ).cont1( p4_parent ) * p4_parent );
	vertex( 1, norm * t1->epsTensorParent( 1 ).cont1( p4_parent ) * p4_parent );
	diff --git a/src/EvtGenModels/EvtSTSCP.cpp b/src/EvtGenModels/EvtSTSCP.cpp
	--- a/src/EvtGenModels/EvtSTSCP.cpp
	+++ b/src/EvtGenModels/EvtSTSCP.cpp
	@@ -82,8 +82,6 @@

	EvtCPUtil::getInstance()->OtherB( p, t, other_b, 0.5 );

	- double m_parent = p->mass();
	-
	EvtComplex amp;

	EvtComplex A, Abar;
	@@ -110,7 +108,7 @@

	p4_parent = momt + moms;

	- double norm = masst * masst / ( m_parent * momt.d3mag() * momt.d3mag() );
	+ double norm = masst * masst / ( p->mass() * momt.d3mag() * momt.d3mag() );

	vertex( 0, amp * norm * t1->epsTensorParent( 0 ).cont1( p4_parent ) *
	p4_parent );
	diff --git a/src/EvtGenModels/EvtSVP.cpp b/src/EvtGenModels/EvtSVP.cpp
	--- a/src/EvtGenModels/EvtSVP.cpp
	+++ b/src/EvtGenModels/EvtSVP.cpp
	@@ -104,7 +104,7 @@
	validAmp = false;
	}

	- double dSq = delta * delta;
	+ double dSq = m_delta * m_delta;
	double dSqDenom = dSq - kSq;
	if ( fabs( dSqDenom ) < 1e-10 ) {
	validAmp = false;
	@@ -164,7 +164,7 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::DIRAC );
	checkNArg( 1 );
	- delta = getArg( 0 );
	+ m_delta = getArg( 0 );
	}
	}

	diff --git a/src/EvtGenModels/EvtSVPHelAmp.cpp b/src/EvtGenModels/EvtSVPHelAmp.cpp
	--- a/src/EvtGenModels/EvtSVPHelAmp.cpp
	+++ b/src/EvtGenModels/EvtSVPHelAmp.cpp
	@@ -64,7 +64,7 @@

	void EvtSVPHelAmp::decay( EvtParticle* p )
	{
	- SVPHel( p, _amp2, getDaug( 0 ), getDaug( 1 ),
	+ SVPHel( p, m_amp2, getDaug( 0 ), getDaug( 1 ),
	EvtComplex( getArg( 0 ) * cos( getArg( 1 ) ),
	getArg( 0 ) * sin( getArg( 1 ) ) ),
	EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ),
	diff --git a/src/EvtGenModels/EvtSVPHelCPMix.cpp b/src/EvtGenModels/EvtSVPHelCPMix.cpp
	--- a/src/EvtGenModels/EvtSVPHelCPMix.cpp
	+++ b/src/EvtGenModels/EvtSVPHelCPMix.cpp
	@@ -146,7 +146,7 @@
	}

	//Compute the decay amplitudes from the time-dependent helicity amplitudes
	- EvtSVPHelAmp::SVPHel( p, _amp2, getDaug( 0 ), getDaug( 1 ), hp, hm );
	+ EvtSVPHelAmp::SVPHel( p, m_amp2, getDaug( 0 ), getDaug( 1 ), hp, hm );

	return;
	}
	diff --git a/src/EvtGenModels/EvtSVS.cpp b/src/EvtGenModels/EvtSVS.cpp
	--- a/src/EvtGenModels/EvtSVS.cpp
	+++ b/src/EvtGenModels/EvtSVS.cpp
	@@ -66,10 +66,9 @@
	double massv = v->mass();
	EvtVector4R momv = v->getP4();
	EvtVector4R moms = p->getDaug( 1 )->getP4();
	- double m_parent = p->mass();
	EvtVector4R p4_parent = momv + moms;

	- double norm = massv / ( momv.d3mag() * m_parent );
	+ double norm = massv / ( momv.d3mag() * p->mass() );
	p4_parent = norm * p4_parent;
	vertex( 0, p4_parent * ( v->epsParent( 0 ) ) );
	vertex( 1, p4_parent * ( v->epsParent( 1 ) ) );
	diff --git a/src/EvtGenModels/EvtSVSCPLH.cpp b/src/EvtGenModels/EvtSVSCPLH.cpp
	--- a/src/EvtGenModels/EvtSVSCPLH.cpp
	+++ b/src/EvtGenModels/EvtSVSCPLH.cpp
	@@ -58,25 +58,27 @@
	static double ctau = EvtPDL::getctau( EvtPDL::getId( "B0" ) );

	// hbar/s
	- _dm = getArg( 0 );
	- _dgamma = EvtConst::c * getArg( 1 ) / ctau;
	+ m_dm = getArg( 0 );
	+ m_dgamma = EvtConst::c * getArg( 1 ) / ctau;

	- _qop = getArg( 2 ) * exp( EvtComplex( 0.0, getArg( 3 ) ) );
	+ m_qop = getArg( 2 ) * exp( EvtComplex( 0.0, getArg( 3 ) ) );

	- _poq = 1.0 / _qop;
	+ m_poq = 1.0 / m_qop;

	- _Af = getArg( 4 ) * exp( EvtComplex( 0.0, getArg( 5 ) ) );
	- _Abarf = getArg( 6 ) * exp( EvtComplex( 0.0, getArg( 7 ) ) );
	+ m_Af = getArg( 4 ) * exp( EvtComplex( 0.0, getArg( 5 ) ) );
	+ m_Abarf = getArg( 6 ) * exp( EvtComplex( 0.0, getArg( 7 ) ) );

	if ( verbose() ) {
	- EvtGenReport( EVTGEN_INFO, "EvtGen" ) << ":EvtSVSCPLH:dm=" << _dm << endl;
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << ":EvtSVSCPLH:dGamma=" << _dgamma << endl;
	+ << ":EvtSVSCPLH:dm=" << m_dm << endl;
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << ":EvtSVSCPLH:q/p=" << _qop << endl;
	- EvtGenReport( EVTGEN_INFO, "EvtGen" ) << ":EvtSVSCPLH:Af=" << _Af << endl;
	+ << ":EvtSVSCPLH:dGamma=" << m_dgamma << endl;
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << ":EvtSVSCPLH:Abarf=" << _Abarf << endl;
	+ << ":EvtSVSCPLH:q/p=" << m_qop << endl;
	+ EvtGenReport( EVTGEN_INFO, "EvtGen" )
	+ << ":EvtSVSCPLH:Af=" << m_Af << endl;
	+ EvtGenReport( EVTGEN_INFO, "EvtGen" )
	+ << ":EvtSVSCPLH:Abarf=" << m_Abarf << endl;
	}
	}

	@@ -106,19 +108,19 @@
	//sign convention is dm=Mheavy-Mlight
	// dGamma=Gammalight-Gammaheavy
	//such that in the standard model both of these are positive.
	- EvtComplex gp = 0.5 *
	- ( exp( EvtComplex( 0.25 * t * _dgamma, -0.5 * t * _dm ) ) +
	- exp( EvtComplex( -0.25 * t * _dgamma, 0.5 * t * _dm ) ) );
	- EvtComplex gm = 0.5 *
	- ( exp( EvtComplex( 0.25 * t * _dgamma, -0.5 * t * _dm ) ) -
	- exp( EvtComplex( -0.25 * t * _dgamma, 0.5 * t * _dm ) ) );
	+ EvtComplex gp =
	+ 0.5 * ( exp( EvtComplex( 0.25 * t * m_dgamma, -0.5 * t * m_dm ) ) +
	+ exp( EvtComplex( -0.25 * t * m_dgamma, 0.5 * t * m_dm ) ) );
	+ EvtComplex gm =
	+ 0.5 * ( exp( EvtComplex( 0.25 * t * m_dgamma, -0.5 * t * m_dm ) ) -
	+ exp( EvtComplex( -0.25 * t * m_dgamma, 0.5 * t * m_dm ) ) );

	EvtComplex amp;

	if ( other_b == B0B ) {
	- amp = gp * _Af + _qop * gm * _Abarf;
	+ amp = gp * m_Af + m_qop * gm * m_Abarf;
	} else if ( other_b == B0 ) {
	- amp = gp * _Abarf + _poq * gm * _Af;
	+ amp = gp * m_Abarf + m_poq * gm * m_Af;
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "other_b was not B0 or B0B!" << endl;
	diff --git a/src/EvtGenModels/EvtSVSCPiso.cpp b/src/EvtGenModels/EvtSVSCPiso.cpp
	--- a/src/EvtGenModels/EvtSVSCPiso.cpp
	+++ b/src/EvtGenModels/EvtSVSCPiso.cpp
	@@ -63,36 +63,36 @@

	void EvtSVSCPiso::setAmpCoeffs()
	{
	- Tp0 = EvtComplex( getArg( 3 ) * cos( getArg( 4 ) ),
	- getArg( 3 ) * sin( getArg( 4 ) ) );
	- Tp0_bar = EvtComplex( getArg( 5 ) * cos( getArg( 6 ) ),
	- getArg( 5 ) * sin( getArg( 6 ) ) );
	- T0p = EvtComplex( getArg( 7 ) * cos( getArg( 8 ) ),
	- getArg( 7 ) * sin( getArg( 8 ) ) );
	- T0p_bar = EvtComplex( getArg( 9 ) * cos( getArg( 10 ) ),
	- getArg( 9 ) * sin( getArg( 10 ) ) );
	- Tpm = EvtComplex( getArg( 11 ) * cos( getArg( 12 ) ),
	- getArg( 11 ) * sin( getArg( 12 ) ) );
	- Tpm_bar = EvtComplex( getArg( 13 ) * cos( getArg( 14 ) ),
	- getArg( 13 ) * sin( getArg( 14 ) ) );
	- Tmp = EvtComplex( getArg( 15 ) * cos( getArg( 16 ) ),
	- getArg( 15 ) * sin( getArg( 16 ) ) );
	- Tmp_bar = EvtComplex( getArg( 17 ) * cos( getArg( 18 ) ),
	- getArg( 17 ) * sin( getArg( 18 ) ) );
	- P0 = EvtComplex( getArg( 19 ) * cos( getArg( 20 ) ),
	- getArg( 19 ) * sin( getArg( 20 ) ) );
	- P0_bar = EvtComplex( getArg( 21 ) * cos( getArg( 22 ) ),
	- getArg( 21 ) * sin( getArg( 22 ) ) );
	- P1 = EvtComplex( getArg( 23 ) * cos( getArg( 24 ) ),
	- getArg( 23 ) * sin( getArg( 24 ) ) );
	- P1_bar = EvtComplex( getArg( 25 ) * cos( getArg( 26 ) ),
	- getArg( 25 ) * sin( getArg( 26 ) ) );
	+ m_Tp0 = EvtComplex( getArg( 3 ) * cos( getArg( 4 ) ),
	+ getArg( 3 ) * sin( getArg( 4 ) ) );
	+ m_Tp0_bar = EvtComplex( getArg( 5 ) * cos( getArg( 6 ) ),
	+ getArg( 5 ) * sin( getArg( 6 ) ) );
	+ m_T0p = EvtComplex( getArg( 7 ) * cos( getArg( 8 ) ),
	+ getArg( 7 ) * sin( getArg( 8 ) ) );
	+ m_T0p_bar = EvtComplex( getArg( 9 ) * cos( getArg( 10 ) ),
	+ getArg( 9 ) * sin( getArg( 10 ) ) );
	+ m_Tpm = EvtComplex( getArg( 11 ) * cos( getArg( 12 ) ),
	+ getArg( 11 ) * sin( getArg( 12 ) ) );
	+ m_Tpm_bar = EvtComplex( getArg( 13 ) * cos( getArg( 14 ) ),
	+ getArg( 13 ) * sin( getArg( 14 ) ) );
	+ m_Tmp = EvtComplex( getArg( 15 ) * cos( getArg( 16 ) ),
	+ getArg( 15 ) * sin( getArg( 16 ) ) );
	+ m_Tmp_bar = EvtComplex( getArg( 17 ) * cos( getArg( 18 ) ),
	+ getArg( 17 ) * sin( getArg( 18 ) ) );
	+ m_P0 = EvtComplex( getArg( 19 ) * cos( getArg( 20 ) ),
	+ getArg( 19 ) * sin( getArg( 20 ) ) );
	+ m_P0_bar = EvtComplex( getArg( 21 ) * cos( getArg( 22 ) ),
	+ getArg( 21 ) * sin( getArg( 22 ) ) );
	+ m_P1 = EvtComplex( getArg( 23 ) * cos( getArg( 24 ) ),
	+ getArg( 23 ) * sin( getArg( 24 ) ) );
	+ m_P1_bar = EvtComplex( getArg( 25 ) * cos( getArg( 26 ) ),
	+ getArg( 25 ) * sin( getArg( 26 ) ) );
	}

	void EvtSVSCPiso::initProbMax()
	{
	- const double max1 = abs2( A_f ) + abs2( Abar_f );
	- const double max2 = abs2( A_fbar ) + abs2( Abar_fbar );
	+ const double max1 = abs2( m_A_f ) + abs2( m_Abar_f );
	+ const double max2 = abs2( m_A_fbar ) + abs2( m_Abar_fbar );
	// Amplitude has momentum normalisation that roughly scales with (parent mass)/2
	// so probability will scale with 0.25 * parenMassSq. Use 0.3 * parMassSq
	// in case we get larger normalisation values
	@@ -151,43 +151,43 @@

	EvtComplex amp;

	- if ( charged == 0 ) {
	+ if ( m_charged == 0 ) {
	if ( !flip ) {
	if ( other_b == B0B ) {
	- amp = A_f * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	+ amp = m_A_f * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	EvtComplex( cos( -2.0 * getArg( 0 ) ),
	sin( -2.0 * getArg( 0 ) ) ) *
	- EvtComplex( 0.0, 1.0 ) * Abar_f *
	+ EvtComplex( 0.0, 1.0 ) * m_Abar_f *
	sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) );
	}
	if ( other_b == B0 ) {
	- amp = A_f *
	+ amp = m_A_f *
	EvtComplex( cos( 2.0 * getArg( 0 ) ),
	sin( 2.0 * getArg( 0 ) ) ) *
	EvtComplex( 0.0, 1.0 ) *
	sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	- Abar_f * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) );
	+ m_Abar_f * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) );
	}
	} else {
	if ( other_b == B0B ) {
	- amp = A_fbar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	+ amp = m_A_fbar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	EvtComplex( cos( -2.0 * getArg( 0 ) ),
	sin( -2.0 * getArg( 0 ) ) ) *
	- EvtComplex( 0.0, 1.0 ) * Abar_fbar *
	+ EvtComplex( 0.0, 1.0 ) * m_Abar_fbar *
	sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) );
	}
	if ( other_b == B0 ) {
	- amp = A_fbar *
	+ amp = m_A_fbar *
	EvtComplex( cos( 2.0 * getArg( 0 ) ),
	sin( 2.0 * getArg( 0 ) ) ) *
	EvtComplex( 0.0, 1.0 ) *
	sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) +
	- Abar_fbar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) );
	+ m_Abar_fbar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) );
	}
	}

	} else {
	- amp = A_f;
	+ amp = m_A_f;
	}

	const EvtVector4R p4_parent = v->getP4() + s->getP4();
	@@ -210,65 +210,65 @@
	if ( Q1 > 0 && Q2 == 0 ) {
	//V+ S0, so T+0 + 2 P1

	- charged = 1;
	- A_f = Tp0 + 2.0 * P1;
	+ m_charged = 1;
	+ m_A_f = m_Tp0 + 2.0 * m_P1;
	}

	if ( Q1 < 0 && Q2 == 0 ) {
	//V- S0, so T+0_bar + 2P1_bar

	- charged = 1;
	- A_f = Tp0_bar + 2.0 * P1_bar;
	+ m_charged = 1;
	+ m_A_f = m_Tp0_bar + 2.0 * m_P1_bar;
	}

	if ( Q1 == 0 && Q2 > 0 ) {
	//V0 S+, so T0+ - 2 P1

	- charged = 1;
	- A_f = T0p - 2.0 * P1;
	+ m_charged = 1;
	+ m_A_f = m_T0p - 2.0 * m_P1;
	}

	if ( Q1 == 0 && Q2 < 0 ) {
	//V0 S-, so T0+_bar - 2 P1_bar

	- charged = 1;
	- A_f = T0p_bar - 2.0 * P1_bar;
	+ m_charged = 1;
	+ m_A_f = m_T0p_bar - 2.0 * m_P1_bar;
	}

	//*********************neutral modes*************************

	//V+ S-, so Af = T+- + P1 + P0
	- Apm = Tpm + P1 + P0;
	- Apm_bar = Tpm_bar + P1_bar + P0_bar;
	+ m_Apm = m_Tpm + m_P1 + m_P0;
	+ m_Apm_bar = m_Tpm_bar + m_P1_bar + m_P0_bar;

	//V- S+, so Af = T-+ - P1 + P0
	- Amp = Tmp - P1 + P0;
	- Amp_bar = Tmp_bar - P1_bar + P0;
	+ m_Amp = m_Tmp - m_P1 + m_P0;
	+ m_Amp_bar = m_Tmp_bar - m_P1_bar + m_P0;

	if ( Q1 > 0 && Q2 < 0 ) {
	//V+ S-
	- charged = 0;
	- A_f = Apm;
	- Abar_f = Apm_bar;
	- A_fbar = Amp;
	- Abar_fbar = Amp_bar;
	+ m_charged = 0;
	+ m_A_f = m_Apm;
	+ m_Abar_f = m_Apm_bar;
	+ m_A_fbar = m_Amp;
	+ m_Abar_fbar = m_Amp_bar;
	}

	if ( Q1 < 0 && Q2 > 0 ) {
	//V- S+
	- charged = 0;
	- A_f = Amp;
	- Abar_f = Amp_bar;
	- A_fbar = Apm;
	- Abar_fbar = Apm_bar;
	+ m_charged = 0;
	+ m_A_f = m_Amp;
	+ m_Abar_f = m_Amp_bar;
	+ m_A_fbar = m_Apm;
	+ m_Abar_fbar = m_Apm_bar;
	}

	if ( Q1 == 0 && Q2 == 0 ) {
	//V0 S0
	- charged = 0;
	- A_f = T0p + Tp0 - Tpm - Tmp - 2.0 * P0;
	- Abar_f = T0p_bar + Tp0_bar - Tpm_bar - Tmp_bar - 2.0 * P0_bar;
	- A_fbar = A_f;
	- Abar_fbar = Abar_f;
	+ m_charged = 0;
	+ m_A_f = m_T0p + m_Tp0 - m_Tpm - m_Tmp - 2.0 * m_P0;
	+ m_Abar_f = m_T0p_bar + m_Tp0_bar - m_Tpm_bar - m_Tmp_bar - 2.0 * m_P0_bar;
	+ m_A_fbar = m_A_f;
	+ m_Abar_fbar = m_Abar_f;
	}
	}
	diff --git a/src/EvtGenModels/EvtSVSNONCPEIGEN.cpp b/src/EvtGenModels/EvtSVSNONCPEIGEN.cpp
	--- a/src/EvtGenModels/EvtSVSNONCPEIGEN.cpp
	+++ b/src/EvtGenModels/EvtSVSNONCPEIGEN.cpp
	@@ -52,31 +52,31 @@
	checkSpinDaughter( 0, EvtSpinType::VECTOR );
	checkSpinDaughter( 1, EvtSpinType::SCALAR );

	- _dm = getArg( 1 );
	- _phickm = 2 * getArg( 0 ) + getArg( 2 );
	+ m_dm = getArg( 1 );
	+ m_phickm = 2 * getArg( 0 ) + getArg( 2 );

	- _A_f = EvtComplex( getArg( 3 ) * cos( getArg( 4 ) ),
	- getArg( 3 ) * sin( getArg( 4 ) ) );
	- _Abar_f = EvtComplex( getArg( 5 ) * cos( getArg( 6 ) ),
	- getArg( 5 ) * sin( getArg( 6 ) ) );
	+ m_A_f = EvtComplex( getArg( 3 ) * cos( getArg( 4 ) ),
	+ getArg( 3 ) * sin( getArg( 4 ) ) );
	+ m_Abar_f = EvtComplex( getArg( 5 ) * cos( getArg( 6 ) ),
	+ getArg( 5 ) * sin( getArg( 6 ) ) );

	- _A_fbar = _Abar_f;
	- _Abar_fbar = _A_f;
	+ m_A_fbar = m_Abar_f;
	+ m_Abar_fbar = m_A_f;

	if ( getNArg() == 11 ) {
	- _A_fbar = EvtComplex( getArg( 7 ) * cos( getArg( 8 ) ),
	- getArg( 7 ) * sin( getArg( 8 ) ) );
	- _Abar_fbar = EvtComplex( getArg( 9 ) * cos( getArg( 10 ) ),
	- getArg( 9 ) * sin( getArg( 10 ) ) );
	+ m_A_fbar = EvtComplex( getArg( 7 ) * cos( getArg( 8 ) ),
	+ getArg( 7 ) * sin( getArg( 8 ) ) );
	+ m_Abar_fbar = EvtComplex( getArg( 9 ) * cos( getArg( 10 ) ),
	+ getArg( 9 ) * sin( getArg( 10 ) ) );
	}
	}

	void EvtSVSNONCPEIGEN::initProbMax()
	{
	- double theProbMax = abs( _A_f ) * abs( _A_f ) +
	- abs( _Abar_f ) * abs( _Abar_f ) +
	- abs( _A_fbar ) * abs( _A_fbar ) +
	- abs( _Abar_fbar ) * abs( _Abar_fbar );
	+ double theProbMax = abs( m_A_f ) * abs( m_A_f ) +
	+ abs( m_Abar_f ) * abs( m_Abar_f ) +
	+ abs( m_A_fbar ) * abs( m_A_fbar ) +
	+ abs( m_Abar_fbar ) * abs( m_Abar_fbar );

	setProbMax( theProbMax );
	}
	@@ -100,9 +100,9 @@
	EvtCPUtil::getInstance()->OtherB( p, t, other_b, 0.5 );

	EvtComplex amp;
	- double dmt2 = ( _dm * t ) / ( 2 * EvtConst::c );
	- EvtComplex ePlusIPhi( cos( _phickm ), sin( _phickm ) );
	- EvtComplex eMinusIPhi( cos( -_phickm ), -sin( _phickm ) );
	+ double dmt2 = ( m_dm * t ) / ( 2 * EvtConst::c );
	+ EvtComplex ePlusIPhi( cos( m_phickm ), sin( m_phickm ) );
	+ EvtComplex eMinusIPhi( cos( -m_phickm ), -sin( m_phickm ) );

	// flip == 0 : D-rho+
	// flip == 1 : D+rho-
	@@ -110,24 +110,24 @@
	if ( !flip ) {
	if ( other_b == B0B ) {
	// At t=0 we have a B0
	- amp = cos( dmt2 ) * _A_f +
	- eMinusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) * _Abar_f;
	+ amp = cos( dmt2 ) * m_A_f +
	+ eMinusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) * m_Abar_f;
	}
	if ( other_b == B0 ) {
	// At t=0 we have a B0bar
	- amp = ePlusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) * _A_f +
	- cos( dmt2 ) * _Abar_f;
	+ amp = ePlusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) * m_A_f +
	+ cos( dmt2 ) * m_Abar_f;
	}
	} else {
	if ( other_b == B0B ) {
	// At t=0 we have a B0
	- amp = cos( dmt2 ) * _A_fbar +
	- eMinusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) * _Abar_fbar;
	+ amp = cos( dmt2 ) * m_A_fbar +
	+ eMinusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) * m_Abar_fbar;
	}
	if ( other_b == B0 ) {
	// At t=0 we have a B0bar
	- amp = ePlusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) * _A_fbar +
	- cos( dmt2 ) * _Abar_fbar;
	+ amp = ePlusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) * m_A_fbar +
	+ cos( dmt2 ) * m_Abar_fbar;
	}
	}

	diff --git a/src/EvtGenModels/EvtSVVCP.cpp b/src/EvtGenModels/EvtSVVCP.cpp
	--- a/src/EvtGenModels/EvtSVVCP.cpp
	+++ b/src/EvtGenModels/EvtSVVCP.cpp
	@@ -113,7 +113,7 @@
	AP = ( cG1P + cG1M ) / sqrt( 2.0 );
	AM = ( cG1P - cG1M ) / sqrt( 2.0 );

	- EvtSVVHelAmp::SVVHel( p, _amp2, getDaug( 0 ), getDaug( 1 ), AP, A0, AM );
	+ EvtSVVHelAmp::SVVHel( p, m_amp2, getDaug( 0 ), getDaug( 1 ), AP, A0, AM );

	return;
	}
	diff --git a/src/EvtGenModels/EvtSVVCPLH.cpp b/src/EvtGenModels/EvtSVVCPLH.cpp
	--- a/src/EvtGenModels/EvtSVVCPLH.cpp
	+++ b/src/EvtGenModels/EvtSVVCPLH.cpp
	@@ -131,7 +131,7 @@
	AP = ( cG1P + cG1M ) / sqrt( 2.0 );
	AM = ( cG1P - cG1M ) / sqrt( 2.0 );

	- EvtSVVHelAmp::SVVHel( p, _amp2, getDaug( 0 ), getDaug( 1 ), AP, A0, AM );
	+ EvtSVVHelAmp::SVVHel( p, m_amp2, getDaug( 0 ), getDaug( 1 ), AP, A0, AM );

	return;
	}
	diff --git a/src/EvtGenModels/EvtSVVHelAmp.cpp b/src/EvtGenModels/EvtSVVHelAmp.cpp
	--- a/src/EvtGenModels/EvtSVVHelAmp.cpp
	+++ b/src/EvtGenModels/EvtSVVHelAmp.cpp
	@@ -65,7 +65,7 @@

	void EvtSVVHelAmp::decay( EvtParticle* p )
	{
	- SVVHel( p, _amp2, getDaug( 0 ), getDaug( 1 ),
	+ SVVHel( p, m_amp2, getDaug( 0 ), getDaug( 1 ),
	EvtComplex( getArg( 0 ) * cos( getArg( 1 ) ),
	getArg( 0 ) * sin( getArg( 1 ) ) ),
	EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ),
	diff --git a/src/EvtGenModels/EvtSVVHelCPMix.cpp b/src/EvtGenModels/EvtSVVHelCPMix.cpp
	--- a/src/EvtGenModels/EvtSVVHelCPMix.cpp
	+++ b/src/EvtGenModels/EvtSVVHelCPMix.cpp
	@@ -58,18 +58,18 @@
	checkSpinDaughter( 0, EvtSpinType::VECTOR );
	checkSpinDaughter( 1, EvtSpinType::VECTOR );

	- hp = EvtComplex( getArg( 0 ) * cos( getArg( 1 ) ),
	- getArg( 0 ) * sin( getArg( 1 ) ) );
	- h0 = EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ),
	- getArg( 2 ) * sin( getArg( 3 ) ) );
	- hm = EvtComplex( getArg( 4 ) * cos( getArg( 5 ) ),
	- getArg( 4 ) * sin( getArg( 5 ) ) );
	- averageM = getArg( 6 );
	- deltaM = getArg( 7 );
	- gamma = getArg( 8 );
	- deltagamma = getArg( 9 );
	- weakmixingphase = EvtComplex( cos( getArg( 10 ) ), sin( getArg( 10 ) ) );
	- weakdirectphase = EvtComplex( cos( getArg( 11 ) ), sin( getArg( 11 ) ) );
	+ m_hp = EvtComplex( getArg( 0 ) * cos( getArg( 1 ) ),
	+ getArg( 0 ) * sin( getArg( 1 ) ) );
	+ m_h0 = EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ),
	+ getArg( 2 ) * sin( getArg( 3 ) ) );
	+ m_hm = EvtComplex( getArg( 4 ) * cos( getArg( 5 ) ),
	+ getArg( 4 ) * sin( getArg( 5 ) ) );
	+ m_averageM = getArg( 6 );
	+ m_deltaM = getArg( 7 );
	+ m_gamma = getArg( 8 );
	+ m_deltagamma = getArg( 9 );
	+ m_weakmixingphase = EvtComplex( cos( getArg( 10 ) ), sin( getArg( 10 ) ) );
	+ m_weakdirectphase = EvtComplex( cos( getArg( 11 ) ), sin( getArg( 11 ) ) );
	}

	void EvtSVVHelCPMix::initProbMax()
	@@ -81,7 +81,7 @@
	void EvtSVVHelCPMix::decay( EvtParticle* p )
	{
	EvtParticle* parent = p;
	- EvtAmp& amp = _amp2;
	+ EvtAmp& amp = m_amp2;
	EvtId n_v1 = getDaug( 0 );
	EvtId n_v2 = getDaug( 1 );

	@@ -114,30 +114,30 @@
	EvtTensor3C M; // Tensor as defined in EvtGen manual, equ 117
	EvtComplex a, b,
	c; // Helicity amplitudes; EvtGen manual eqns 126-128, also see Phys Lett B 369 p144-150 eqn 15
	- //EvtComplex deltamu = EvtComplex(deltaM, -0.5*deltagamma); // See Phys Rev D 34 p1404
	+ //EvtComplex deltamu = EvtComplex(m_deltaM, -0.5*m_deltagamma); // See Phys Rev D 34 p1404

	// conversion from times in mm/c to natural units [GeV]^-1
	double t = ( ( parent->getLifetime() ) / 2.998e11 ) * 6.58e-25;

	// The following two quantities defined in Phys Rev D 34 p1404
	- EvtComplex fplus = EvtComplex( cos( averageM * t ),
	- -1. * sin( averageM * t ) ) *
	- exp( -( gamma / 2.0 ) * t ) *
	- ( cos( 0.5 * deltaM * t ) * cosh( 0.25 * deltagamma * t ) +
	- EvtComplex( 0.0, sin( 0.5 * deltaM * t ) *
	- sinh( 0.25 * deltagamma * t ) ) );
	+ EvtComplex fplus =
	+ EvtComplex( cos( m_averageM * t ), -1. * sin( m_averageM * t ) ) *
	+ exp( -( m_gamma / 2.0 ) * t ) *
	+ ( cos( 0.5 * m_deltaM * t ) * cosh( 0.25 * m_deltagamma * t ) +
	+ EvtComplex( 0.0, sin( 0.5 * m_deltaM * t ) *
	+ sinh( 0.25 * m_deltagamma * t ) ) );
	EvtComplex fminus =
	- EvtComplex( cos( averageM * t ), -1. * sin( averageM * t ) ) *
	- exp( -( gamma / 2.0 ) * t ) * EvtComplex( 0.0, 1.0 ) *
	- ( sin( 0.5 * deltaM * t ) * cosh( 0.25 * deltagamma * t ) -
	- EvtComplex( 0.0, 1.0 ) * sinh( 0.25 * deltagamma * t ) *
	- cos( 0.5 * deltaM * t ) );
	+ EvtComplex( cos( m_averageM * t ), -1. * sin( m_averageM * t ) ) *
	+ exp( -( m_gamma / 2.0 ) * t ) * EvtComplex( 0.0, 1.0 ) *
	+ ( sin( 0.5 * m_deltaM * t ) * cosh( 0.25 * m_deltagamma * t ) -
	+ EvtComplex( 0.0, 1.0 ) * sinh( 0.25 * m_deltagamma * t ) *
	+ cos( 0.5 * m_deltaM * t ) );

	// See EvtGen manual pp 106-107

	- a = -0.5 * ( hp + hm );
	- b = EvtComplex( 0.0, 0.5 ) * ( hp - hm );
	- c = ( h0 + 0.5 * ( hp + hm ) );
	+ a = -0.5 * ( m_hp + m_hm );
	+ b = EvtComplex( 0.0, 0.5 ) * ( m_hp - m_hm );
	+ c = ( m_h0 + 0.5 * ( m_hp + m_hm ) );

	M = a * EvtTensor3C::id() + b * EvtGenFunctions::eps( v1dir ) +
	c * EvtGenFunctions::directProd( v1dir, v1dir );
	@@ -160,69 +160,69 @@
	// First the Bs state:

	if ( parent->getId() == Bs ) {
	- amplSum00 = ( fplus * weakdirectphase * t0 * eps0 ) +
	- ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase *
	+ amplSum00 = ( fplus * m_weakdirectphase * t0 * eps0 ) +
	+ ( fminus * ( 1.0 / m_weakdirectphase ) * m_weakmixingphase *
	t0 * eps0 );
	- amplSum01 = ( fplus * weakdirectphase * t0 * eps1 ) +
	- ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase *
	+ amplSum01 = ( fplus * m_weakdirectphase * t0 * eps1 ) +
	+ ( fminus * ( 1.0 / m_weakdirectphase ) * m_weakmixingphase *
	t0 * eps1 );
	- amplSum02 = ( fplus * weakdirectphase * t0 * eps2 ) +
	- ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase *
	+ amplSum02 = ( fplus * m_weakdirectphase * t0 * eps2 ) +
	+ ( fminus * ( 1.0 / m_weakdirectphase ) * m_weakmixingphase *
	t0 * eps2 );

	- amplSum10 = ( fplus * weakdirectphase * t1 * eps0 ) +
	- ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase *
	+ amplSum10 = ( fplus * m_weakdirectphase * t1 * eps0 ) +
	+ ( fminus * ( 1.0 / m_weakdirectphase ) * m_weakmixingphase *
	t1 * eps0 );
	- amplSum11 = ( fplus * weakdirectphase * t1 * eps1 ) +
	- ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase *
	+ amplSum11 = ( fplus * m_weakdirectphase * t1 * eps1 ) +
	+ ( fminus * ( 1.0 / m_weakdirectphase ) * m_weakmixingphase *
	t1 * eps1 );
	- amplSum12 = ( fplus * weakdirectphase * t1 * eps2 ) +
	- ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase *
	+ amplSum12 = ( fplus * m_weakdirectphase * t1 * eps2 ) +
	+ ( fminus * ( 1.0 / m_weakdirectphase ) * m_weakmixingphase *
	t1 * eps2 );

	- amplSum20 = ( fplus * weakdirectphase * t2 * eps0 ) +
	- ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase *
	+ amplSum20 = ( fplus * m_weakdirectphase * t2 * eps0 ) +
	+ ( fminus * ( 1.0 / m_weakdirectphase ) * m_weakmixingphase *
	t2 * eps0 );
	- amplSum21 = ( fplus * weakdirectphase * t2 * eps1 ) +
	- ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase *
	+ amplSum21 = ( fplus * m_weakdirectphase * t2 * eps1 ) +
	+ ( fminus * ( 1.0 / m_weakdirectphase ) * m_weakmixingphase *
	t2 * eps1 );
	- amplSum22 = ( fplus * weakdirectphase * t2 * eps2 ) +
	- ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase *
	+ amplSum22 = ( fplus * m_weakdirectphase * t2 * eps2 ) +
	+ ( fminus * ( 1.0 / m_weakdirectphase ) * m_weakmixingphase *
	t2 * eps2 );
	}

	// Now the anti-Bs state:

	if ( parent->getId() == antiBs ) {
	- amplSum00 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) *
	+ amplSum00 = ( fminus * m_weakdirectphase * ( 1.0 / m_weakmixingphase ) *
	t0 * eps0 ) +
	- ( fplus * ( 1.0 / weakdirectphase ) * t0 * eps0 );
	- amplSum01 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) *
	+ ( fplus * ( 1.0 / m_weakdirectphase ) * t0 * eps0 );
	+ amplSum01 = ( fminus * m_weakdirectphase * ( 1.0 / m_weakmixingphase ) *
	t0 * eps1 ) +
	- ( fplus * ( 1.0 / weakdirectphase ) * t0 * eps1 );
	- amplSum02 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) *
	+ ( fplus * ( 1.0 / m_weakdirectphase ) * t0 * eps1 );
	+ amplSum02 = ( fminus * m_weakdirectphase * ( 1.0 / m_weakmixingphase ) *
	t0 * eps2 ) +
	- ( fplus * ( 1.0 / weakdirectphase ) * t0 * eps2 );
	+ ( fplus * ( 1.0 / m_weakdirectphase ) * t0 * eps2 );

	- amplSum10 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) *
	+ amplSum10 = ( fminus * m_weakdirectphase * ( 1.0 / m_weakmixingphase ) *
	t1 * eps0 ) +
	- ( fplus * ( 1.0 / weakdirectphase ) * t1 * eps0 );
	- amplSum11 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) *
	+ ( fplus * ( 1.0 / m_weakdirectphase ) * t1 * eps0 );
	+ amplSum11 = ( fminus * m_weakdirectphase * ( 1.0 / m_weakmixingphase ) *
	t1 * eps1 ) +
	- ( fplus * ( 1.0 / weakdirectphase ) * t1 * eps1 );
	- amplSum12 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) *
	+ ( fplus * ( 1.0 / m_weakdirectphase ) * t1 * eps1 );
	+ amplSum12 = ( fminus * m_weakdirectphase * ( 1.0 / m_weakmixingphase ) *
	t1 * eps2 ) +
	- ( fplus * ( 1.0 / weakdirectphase ) * t1 * eps2 );
	+ ( fplus * ( 1.0 / m_weakdirectphase ) * t1 * eps2 );

	- amplSum20 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) *
	+ amplSum20 = ( fminus * m_weakdirectphase * ( 1.0 / m_weakmixingphase ) *
	t2 * eps0 ) +
	- ( fplus * ( 1.0 / weakdirectphase ) * t2 * eps0 );
	- amplSum21 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) *
	+ ( fplus * ( 1.0 / m_weakdirectphase ) * t2 * eps0 );
	+ amplSum21 = ( fminus * m_weakdirectphase * ( 1.0 / m_weakmixingphase ) *
	t2 * eps1 ) +
	- ( fplus * ( 1.0 / weakdirectphase ) * t2 * eps1 );
	- amplSum22 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) *
	+ ( fplus * ( 1.0 / m_weakdirectphase ) * t2 * eps1 );
	+ amplSum22 = ( fminus * m_weakdirectphase * ( 1.0 / m_weakmixingphase ) *
	t2 * eps2 ) +
	- ( fplus * ( 1.0 / weakdirectphase ) * t2 * eps2 );
	+ ( fplus * ( 1.0 / m_weakdirectphase ) * t2 * eps2 );
	}

	// Now set the amplitudes
	diff --git a/src/EvtGenModels/EvtSVVNONCPEIGEN.cpp b/src/EvtGenModels/EvtSVVNONCPEIGEN.cpp
	--- a/src/EvtGenModels/EvtSVVNONCPEIGEN.cpp
	+++ b/src/EvtGenModels/EvtSVVNONCPEIGEN.cpp
	@@ -67,16 +67,16 @@
	int j = ( getNArg() - 3 ) / 2;

	for ( i = 0; i < j; ++i ) {
	- _A_f[i] = getArg( ( 2 * i ) + 3 ) *
	- EvtComplex( cos( getArg( ( 2 * i ) + 4 ) ),
	- sin( getArg( ( 2 * i ) + 4 ) ) );
	+ m_A_f[i] = getArg( ( 2 * i ) + 3 ) *
	+ EvtComplex( cos( getArg( ( 2 * i ) + 4 ) ),
	+ sin( getArg( ( 2 * i ) + 4 ) ) );
	}

	// If only 6 amplitudes are specified, calculate the last 6 from the first 6:
	if ( 6 == j ) {
	for ( i = 0; i < 3; ++i ) {
	- _A_f[6 + i] = _A_f[3 + i];
	- _A_f[9 + i] = _A_f[i];
	+ m_A_f[6 + i] = m_A_f[3 + i];
	+ m_A_f[9 + i] = m_A_f[i];
	}
	}
	}
	@@ -85,7 +85,7 @@
	{
	double probMax = 0;
	for ( int i = 0; i < 12; ++i ) {
	- double amp = abs( _A_f[i] );
	+ double amp = abs( m_A_f[i] );
	probMax += amp * amp;
	}

	@@ -124,16 +124,16 @@
	if ( other_b == B0B ) {
	// At t=0 we have a B0
	for ( int i = 0; i < 3; ++i ) {
	- amp[i] = _A_f[i] * cos( dmt2 ) +
	+ amp[i] = m_A_f[i] * cos( dmt2 ) +
	eMinusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) *
	- _A_f[i + 3];
	+ m_A_f[i + 3];
	}
	}
	if ( other_b == B0 ) {
	// At t=0 we have a B0bar
	for ( int i = 0; i < 3; ++i ) {
	- amp[i] = _A_f[i] * ePlusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) +
	- _A_f[i + 3] * cos( dmt2 );
	+ amp[i] = m_A_f[i] * ePlusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) +
	+ m_A_f[i + 3] * cos( dmt2 );
	}
	}
	} else {
	@@ -146,21 +146,22 @@
	// count the B0bar helicities backwards. (Equivalently, one could flip the chi angle.)

	for ( int i = 0; i < 3; ++i ) {
	- amp[i] = _A_f[8 - i] * cos( dmt2 ) +
	+ amp[i] = m_A_f[8 - i] * cos( dmt2 ) +
	eMinusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) *
	- _A_f[11 - i];
	+ m_A_f[11 - i];
	}
	}
	if ( other_b == B0 ) {
	// At t=0 we have a B0bar
	for ( int i = 0; i < 3; ++i ) {
	- amp[i] = _A_f[8 - i] * ePlusIPhi * EvtComplex( 0.0, sin( dmt2 ) ) +
	- _A_f[11 - i] * cos( dmt2 );
	+ amp[i] = m_A_f[8 - i] * ePlusIPhi *
	+ EvtComplex( 0.0, sin( dmt2 ) ) +
	+ m_A_f[11 - i] * cos( dmt2 );
	}
	}
	}

	- EvtSVVHelAmp::SVVHel( p, _amp2, daugs[0], daugs[1], amp[0], amp[1], amp[2] );
	+ EvtSVVHelAmp::SVVHel( p, m_amp2, daugs[0], daugs[1], amp[0], amp[1], amp[2] );

	return;
	}
	diff --git a/src/EvtGenModels/EvtSingleParticle.cpp b/src/EvtGenModels/EvtSingleParticle.cpp
	--- a/src/EvtGenModels/EvtSingleParticle.cpp
	+++ b/src/EvtGenModels/EvtSingleParticle.cpp
	@@ -55,40 +55,40 @@
	if ( getNArg() == 6 ) {
	//copy the arguments into eaiser to remember names!

	- pmin = getArg( 0 );
	- pmax = getArg( 1 );
	+ m_pmin = getArg( 0 );
	+ m_pmax = getArg( 1 );

	- cthetamin = getArg( 2 );
	- cthetamax = getArg( 3 );
	+ m_cthetamin = getArg( 2 );
	+ m_cthetamax = getArg( 3 );

	- phimin = getArg( 4 );
	- phimax = getArg( 5 );
	+ m_phimin = getArg( 4 );
	+ m_phimax = getArg( 5 );
	}

	if ( getNArg() == 4 ) {
	//copy the arguments into eaiser to remember names!

	- pmin = getArg( 0 );
	- pmax = getArg( 1 );
	+ m_pmin = getArg( 0 );
	+ m_pmax = getArg( 1 );

	- cthetamin = getArg( 2 );
	- cthetamax = getArg( 3 );
	+ m_cthetamin = getArg( 2 );
	+ m_cthetamax = getArg( 3 );

	- phimin = 0.0;
	- phimax = EvtConst::twoPi;
	+ m_phimin = 0.0;
	+ m_phimax = EvtConst::twoPi;
	}

	if ( getNArg() == 2 ) {
	//copy the arguments into eaiser to remember names!

	- pmin = getArg( 0 );
	- pmax = getArg( 1 );
	+ m_pmin = getArg( 0 );
	+ m_pmax = getArg( 1 );

	- cthetamin = -1.0;
	- cthetamax = 1.0;
	+ m_cthetamin = -1.0;
	+ m_cthetamax = 1.0;

	- phimin = 0.0;
	- phimax = EvtConst::twoPi;
	+ m_phimin = 0.0;
	+ m_phimax = EvtConst::twoPi;
	}

	} else {
	@@ -102,11 +102,12 @@

	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "The single particle generator has been configured:" << endl;
	- EvtGenReport( EVTGEN_INFO, "EvtGen" ) << pmax << " > p > " << pmin << endl;
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << cthetamax << " > costheta > " << cthetamin << endl;
	+ << m_pmax << " > p > " << m_pmin << endl;
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	- << phimax << " > phi > " << phimin << endl;
	+ << m_cthetamax << " > costheta > " << m_cthetamin << endl;
	+ EvtGenReport( EVTGEN_INFO, "EvtGen" )
	+ << m_phimax << " > phi > " << m_phimin << endl;
	}

	void EvtSingleParticle::decay( EvtParticle* p )
	@@ -122,15 +123,15 @@
	//generate flat distribution in p
	//we are now in the parents restframe! This means the
	//restframe of the e+e- collison.
	- double pcm = EvtRandom::Flat( pmin, pmax );
	+ double pcm = EvtRandom::Flat( m_pmin, m_pmax );
	//generate flat distribution in phi.
	- double phi = EvtRandom::Flat( phimin, phimax );
	+ double phi = EvtRandom::Flat( m_phimin, m_phimax );

	double cthetalab;

	do {
	//generate flat distribution in costheta
	- double ctheta = EvtRandom::Flat( cthetamin, cthetamax );
	+ double ctheta = EvtRandom::Flat( m_cthetamin, m_cthetamax );
	double stheta = sqrt( 1.0 - ctheta * ctheta );
	p4.set( sqrt( mass * mass + pcm * pcm ), pcm * cos( phi ) * stheta,
	pcm * sin( phi ) * stheta, pcm * ctheta );
	@@ -140,7 +141,7 @@
	//get 4 vector in the lab frame!
	EvtVector4R p4lab = d->getP4Lab();
	cthetalab = p4lab.get( 3 ) / p4lab.d3mag();
	- } while ( cthetalab > cthetamax \|\| cthetalab < cthetamin );
	+ } while ( cthetalab > m_cthetamax \|\| cthetalab < m_cthetamin );

	return;
	}
	diff --git a/src/EvtGenModels/EvtTVP.cpp b/src/EvtGenModels/EvtTVP.cpp
	--- a/src/EvtGenModels/EvtTVP.cpp
	+++ b/src/EvtGenModels/EvtTVP.cpp
	@@ -63,7 +63,7 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::DIRAC );
	checkNArg( 1 );
	- delta = getArg( 0 );
	+ m_delta = getArg( 0 );
	}
	}

	@@ -78,7 +78,7 @@
	}

	} else if ( getNDaug() == 3 ) {
	- double dSq = delta * delta;
	+ double dSq = m_delta * m_delta;
	double denom = dSq - 0.2;
	double ratio( 1.0 );
	if ( fabs( denom ) > 1e-10 ) {
	@@ -166,7 +166,7 @@
	validAmp = false;
	}

	- double dSq = delta * delta;
	+ double dSq = m_delta * m_delta;
	double dSqDenom = dSq - kSq;
	if ( fabs( dSqDenom ) < 1e-10 ) {
	validAmp = false;
	diff --git a/src/EvtGenModels/EvtTVSPwave.cpp b/src/EvtGenModels/EvtTVSPwave.cpp
	--- a/src/EvtGenModels/EvtTVSPwave.cpp
	+++ b/src/EvtGenModels/EvtTVSPwave.cpp
	@@ -83,11 +83,11 @@

	EvtComplex temp;
	temp = ad;
	- double m_parent = p->mass();
	+ double parentMass = p->mass();

	EvtVector4R p_parent;

	- p_parent.set( m_parent, 0.0, 0.0, 0.0 );
	+ p_parent.set( parentMass, 0.0, 0.0, 0.0 );

	EvtVector4C pep0, pep1, pep2, pep3, pep4;
	EvtTensor4C pdual;
	@@ -95,7 +95,7 @@
	EvtVector4C epsdual0, epsdual1, epsdual2;

	double norm = massv /
	- ( m_parent * momv.get( 0 ) * momv.d3mag() * momv.d3mag() );
	+ ( parentMass * momv.get( 0 ) * momv.d3mag() * momv.d3mag() );
	pdual = dual( EvtGenFunctions::directProd( norm * p_parent, momv ) );

	epsdual0 = pdual.cont1( v->epsParent( 0 ).conj() );
	diff --git a/src/EvtGenModels/EvtTauHadnu.cpp b/src/EvtGenModels/EvtTauHadnu.cpp
	--- a/src/EvtGenModels/EvtTauHadnu.cpp
	+++ b/src/EvtGenModels/EvtTauHadnu.cpp
	@@ -64,23 +64,23 @@
	//pipinu
	validndaug = true;
	checkNArg( 7 );
	- _beta = getArg( 0 );
	- _mRho = getArg( 1 );
	- _gammaRho = getArg( 2 );
	- _mRhopr = getArg( 3 );
	- _gammaRhopr = getArg( 4 );
	- _mA1 = getArg( 5 );
	- _gammaA1 = getArg( 6 );
	+ m_beta = getArg( 0 );
	+ m_mRho = getArg( 1 );
	+ m_gammaRho = getArg( 2 );
	+ m_mRhopr = getArg( 3 );
	+ m_gammaRhopr = getArg( 4 );
	+ m_mA1 = getArg( 5 );
	+ m_gammaA1 = getArg( 6 );
	}
	if ( getNDaug() == 3 ) {
	//pipinu
	validndaug = true;
	checkNArg( 5 );
	- _beta = getArg( 0 );
	- _mRho = getArg( 1 );
	- _gammaRho = getArg( 2 );
	- _mRhopr = getArg( 3 );
	- _gammaRhopr = getArg( 4 );
	+ m_beta = getArg( 0 );
	+ m_mRho = getArg( 1 );
	+ m_gammaRho = getArg( 2 );
	+ m_mRhopr = getArg( 3 );
	+ m_gammaRhopr = getArg( 4 );
	}
	if ( getNDaug() == 2 ) {
	//pipinu
	@@ -187,13 +187,13 @@

	EvtVector4R Q = q1 + q2 + q3;
	double Q2 = Q.mass2();
	- double _mA12 = _mA1 * _mA1;
	+ double mA12 = m_mA1 * m_mA1;

	- double _gammaA1X = _gammaA1 * gFunc( Q2, samePi1 ) /
	- gFunc( _mA12, samePi1 );
	+ double gammaA1X = m_gammaA1 * gFunc( Q2, samePi1 ) /
	+ gFunc( mA12, samePi1 );

	- EvtComplex denBW_A1( _mA12 - Q2, -1. * _mA1 * _gammaA1X );
	- EvtComplex BW_A1 = _mA12 / denBW_A1;
	+ EvtComplex denBW_A1( mA12 - Q2, -1. * m_mA1 * gammaA1X );
	+ EvtComplex BW_A1 = mA12 / denBW_A1;

	hadCurr = BW_A1 *
	( ( ( q1 - q3 ) - ( Q * ( Q * ( q1 - q3 ) ) / Q2 ) ) *
	@@ -227,7 +227,7 @@
	{
	double mpi = EvtPDL::getMeanMass( getDaug( dupD ) );
	double mpi2 = pow( mpi, 2. );
	- if ( Q2 < pow( _mRho + mpi, 2. ) ) {
	+ if ( Q2 < pow( m_mRho + mpi, 2. ) ) {
	double arg = Q2 - 9. * mpi2;
	return 4.1 * pow( arg, 3. ) * ( 1. - 3.3 * arg + 5.8 * pow( arg, 2. ) );
	} else
	@@ -237,10 +237,10 @@

	EvtComplex EvtTauHadnu::Fpi( double s, double xm1, double xm2 )
	{
	- EvtComplex BW_rho = BW( s, _mRho, _gammaRho, xm1, xm2 );
	- EvtComplex BW_rhopr = BW( s, _mRhopr, _gammaRhopr, xm1, xm2 );
	+ EvtComplex BW_rho = BW( s, m_mRho, m_gammaRho, xm1, xm2 );
	+ EvtComplex BW_rhopr = BW( s, m_mRhopr, m_gammaRhopr, xm1, xm2 );

	- return ( BW_rho + _beta * BW_rhopr ) / ( 1. + _beta );
	+ return ( BW_rho + m_beta * BW_rhopr ) / ( 1. + m_beta );
	}

	EvtComplex EvtTauHadnu::BW( double s, double m, double gamma, double xm1,
	diff --git a/src/EvtGenModels/EvtVSSBMixCPT.cpp b/src/EvtGenModels/EvtVSSBMixCPT.cpp
	--- a/src/EvtGenModels/EvtVSSBMixCPT.cpp
	+++ b/src/EvtGenModels/EvtVSSBMixCPT.cpp
	@@ -106,56 +106,56 @@
	// and print out a summary of parameters for this decay

	// mixing frequency in hbar/mm
	- _freq = getArg( 0 ) / EvtConst::c;
	+ m_freq = getArg( 0 ) / EvtConst::c;

	// deltaG
	double gamma = 1 / EvtPDL::getctau( getDaug( 0 ) ); // gamma/c (1/mm)
	- _dGamma = 0.0;
	+ m_dGamma = 0.0;
	double dgog = 0.0;
	if ( getNArg() > 1 ) {
	dgog = getArg( 1 );
	- _dGamma = dgog * gamma;
	+ m_dGamma = dgog * gamma;
	}
	// q/p
	- _qoverp = EvtComplex( 1.0, 0.0 );
	+ m_qoverp = EvtComplex( 1.0, 0.0 );
	if ( getNArg() > 2 ) {
	- _qoverp = EvtComplex( getArg( 2 ), 0.0 );
	+ m_qoverp = EvtComplex( getArg( 2 ), 0.0 );
	}
	if ( getNArg() > 3 ) {
	- _qoverp = getArg( 2 ) *
	- EvtComplex( cos( getArg( 3 ) ), sin( getArg( 3 ) ) );
	+ m_qoverp = getArg( 2 ) *
	+ EvtComplex( cos( getArg( 3 ) ), sin( getArg( 3 ) ) );
	}
	- _poverq = 1.0 / _qoverp;
	+ m_poverq = 1.0 / m_qoverp;

	// decay amplitudes
	- _A_f = EvtComplex( 1.0, 0.0 );
	- _Abar_f = EvtComplex( 0.0, 0.0 );
	- _A_fbar = _Abar_f; // CPT conservation
	- _Abar_fbar = _A_f; // CPT conservation
	+ m_A_f = EvtComplex( 1.0, 0.0 );
	+ m_Abar_f = EvtComplex( 0.0, 0.0 );
	+ m_A_fbar = m_Abar_f; // CPT conservation
	+ m_Abar_fbar = m_A_f; // CPT conservation
	if ( getNArg() > 4 ) {
	- _A_f = getArg( 4 ) *
	- EvtComplex( cos( getArg( 5 ) ),
	- sin( getArg( 5 ) ) ); // this allows for DCSD
	- _Abar_f = getArg( 6 ) *
	- EvtComplex( cos( getArg( 7 ) ),
	- sin( getArg( 7 ) ) ); // this allows for DCSD
	+ m_A_f = getArg( 4 ) *
	+ EvtComplex( cos( getArg( 5 ) ),
	+ sin( getArg( 5 ) ) ); // this allows for DCSD
	+ m_Abar_f = getArg( 6 ) *
	+ EvtComplex( cos( getArg( 7 ) ),
	+ sin( getArg( 7 ) ) ); // this allows for DCSD
	if ( getNArg() > 8 ) {
	// CPT violation in decay
	- _A_fbar = getArg( 8 ) *
	- EvtComplex( cos( getArg( 9 ) ), sin( getArg( 9 ) ) );
	- _Abar_fbar = getArg( 10 ) *
	- EvtComplex( cos( getArg( 11 ) ), sin( getArg( 11 ) ) );
	+ m_A_fbar = getArg( 8 ) *
	+ EvtComplex( cos( getArg( 9 ) ), sin( getArg( 9 ) ) );
	+ m_Abar_fbar = getArg( 10 ) * EvtComplex( cos( getArg( 11 ) ),
	+ sin( getArg( 11 ) ) );
	} else {
	// CPT conservation in decay
	- _A_fbar = _Abar_f;
	- _Abar_fbar = _A_f;
	+ m_A_fbar = m_Abar_f;
	+ m_Abar_fbar = m_A_f;
	}
	}

	// CPT violation in mixing
	- _z = EvtComplex( 0.0, 0.0 );
	+ m_z = EvtComplex( 0.0, 0.0 );
	if ( getNArg() > 12 ) {
	- _z = EvtComplex( getArg( 12 ), getArg( 13 ) );
	+ m_z = EvtComplex( getArg( 12 ), getArg( 13 ) );
	}

	// some printout
	@@ -163,13 +163,13 @@
	double dm = 1e-12 * getArg( 0 ); // B0/anti-B0 mass difference in hbar/ps
	double x = dm * tau;
	double y = dgog * 0.5; //y=dgamma/(2*gamma)
	- double qop2 = abs( _qoverp * _qoverp );
	- _chib0_b0bar = qop2 * ( x * x + y * y ) /
	- ( qop2 * ( x * x + y * y ) + 2 + x * x -
	- y * y ); // does not include CPT in mixing
	- _chib0bar_b0 = ( 1 / qop2 ) * ( x * x + y * y ) /
	- ( ( 1 / qop2 ) * ( x * x + y * y ) + 2 + x * x -
	- y * y ); // does not include CPT in mixing
	+ double qop2 = abs( m_qoverp * m_qoverp );
	+ m_chib0_b0bar = qop2 * ( x * x + y * y ) /
	+ ( qop2 * ( x * x + y * y ) + 2 + x * x -
	+ y * y ); // does not include CPT in mixing
	+ m_chib0bar_b0 = ( 1 / qop2 ) * ( x * x + y * y ) /
	+ ( ( 1 / qop2 ) * ( x * x + y * y ) + 2 + x * x -
	+ y * y ); // does not include CPT in mixing

	if ( verbose() ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	@@ -183,19 +183,19 @@
	<< "using parameters:" << endl
	<< endl
	<< " delta(m) = " << dm << " hbar/ps" << endl
	- << " _freq = " << _freq << " hbar/mm" << endl
	+ << " freq = " << m_freq << " hbar/mm" << endl
	<< " dgog = " << dgog << endl
	- << " dGamma = " << _dGamma << " hbar/mm" << endl
	- << " q/p = " << _qoverp << endl
	- << " z = " << _z << endl
	+ << " dGamma = " << m_dGamma << " hbar/mm" << endl
	+ << " q/p = " << m_qoverp << endl
	+ << " z = " << m_z << endl
	<< " tau = " << tau << " ps" << endl
	<< " x = " << x << endl
	- << " chi(B0->B0bar) = " << _chib0_b0bar << endl
	- << " chi(B0bar->B0) = " << _chib0bar_b0 << endl
	- << " Af = " << _A_f << endl
	- << " Abarf = " << _Abar_f << endl
	- << " Afbar = " << _A_fbar << endl
	- << " Abarfbar = " << _Abar_fbar << endl
	+ << " chi(B0->B0bar) = " << m_chib0_b0bar << endl
	+ << " chi(B0bar->B0) = " << m_chib0bar_b0 << endl
	+ << " Af = " << m_A_f << endl
	+ << " Abarf = " << m_Abar_f << endl
	+ << " Afbar = " << m_A_fbar << endl
	+ << " Abarfbar = " << m_Abar_fbar << endl
	<< endl;
	}
	}
	@@ -284,8 +284,8 @@
	s2->setLifetime();
	double dct = s1->getLifetime() - s2->getLifetime(); // in mm

	- // Convention: _dGamma=GammaLight-GammaHeavy
	- EvtComplex exp1( -0.25 * _dGamma * dct, 0.5 * _freq * dct );
	+ // Convention: m_dGamma=GammaLight-GammaHeavy
	+ EvtComplex exp1( -0.25 * m_dGamma * dct, 0.5 * m_freq * dct );

	/*
	//Find the flavor of the B that decayed first.
	@@ -302,27 +302,27 @@
	//define some useful functions: (see BAD #188 eq. 39 for ref.)
	EvtComplex gp = 0.5 * ( exp( -1.0 * exp1 ) + exp( exp1 ) );
	EvtComplex gm = 0.5 * ( exp( -1.0 * exp1 ) - exp( exp1 ) );
	- EvtComplex sqz = sqrt( abs( 1 - _z * _z ) ) *
	- exp( EvtComplex( 0, arg( 1 - _z * _z ) / 2 ) );
	+ EvtComplex sqz = sqrt( abs( 1 - m_z * m_z ) ) *
	+ exp( EvtComplex( 0, arg( 1 - m_z * m_z ) / 2 ) );

	- EvtComplex BB = gp + _z * gm; // <B0\|B0(t)>
	- EvtComplex barBB = -sqz * _qoverp * gm; // <B0bar\|B0(t)>
	- EvtComplex BbarB = -sqz * _poverq * gm; // <B0\|B0bar(t)>
	- EvtComplex barBbarB = gp - _z * gm; // <B0bar\|B0bar(t)>
	+ EvtComplex BB = gp + m_z * gm; // <B0\|B0(t)>
	+ EvtComplex barBB = -sqz * m_qoverp * gm; // <B0bar\|B0(t)>
	+ EvtComplex BbarB = -sqz * m_poverq * gm; // <B0\|B0bar(t)>
	+ EvtComplex barBbarB = gp - m_z * gm; // <B0bar\|B0bar(t)>

	//
	if ( !mixed && stateAtDeltaTeq0 == B0 ) {
	- osc_amp = BB * _A_f + barBB * _Abar_f;
	+ osc_amp = BB * m_A_f + barBB * m_Abar_f;
	}
	if ( !mixed && stateAtDeltaTeq0 == B0B ) {
	- osc_amp = barBbarB * _Abar_fbar + BbarB * _A_fbar;
	+ osc_amp = barBbarB * m_Abar_fbar + BbarB * m_A_fbar;
	}

	if ( mixed && stateAtDeltaTeq0 == B0 ) {
	- osc_amp = barBB * _Abar_fbar + BB * _A_fbar;
	+ osc_amp = barBB * m_Abar_fbar + BB * m_A_fbar;
	}
	if ( mixed && stateAtDeltaTeq0 == B0B ) {
	- osc_amp = BbarB * _A_f + barBbarB * _Abar_f;
	+ osc_amp = BbarB * m_A_f + barBbarB * m_Abar_f;
	}

	// store the amplitudes for each parent spin basis state
	diff --git a/src/EvtGenModels/EvtVVP.cpp b/src/EvtGenModels/EvtVVP.cpp
	--- a/src/EvtGenModels/EvtVVP.cpp
	+++ b/src/EvtGenModels/EvtVVP.cpp
	@@ -57,7 +57,7 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::DIRAC );
	checkNArg( 1 );
	- delta = getArg( 0 );
	+ m_delta = getArg( 0 );
	}
	}

	@@ -145,7 +145,7 @@
	}

	// Extra checks to make sure we are not dividing by zero
	- double dSq = delta * delta;
	+ double dSq = m_delta * m_delta;
	double dSqDenom = dSq - kSq;
	if ( fabs( dSqDenom ) < 1e-10 ) {
	validAmp = false;
	diff --git a/src/EvtGenModels/EvtVectorIsr.cpp b/src/EvtGenModels/EvtVectorIsr.cpp
	--- a/src/EvtGenModels/EvtVectorIsr.cpp
	+++ b/src/EvtGenModels/EvtVectorIsr.cpp
	@@ -61,19 +61,19 @@
	if ( narg > 4 )
	checkNArg( 4 );

	- csfrmn = 1.;
	- csbkmn = 1.;
	- fmax = 1.2;
	- firstorder = false;
	+ m_csfrmn = 1.;
	+ m_csbkmn = 1.;
	+ m_fmax = 1.2;
	+ m_firstorder = false;

	if ( narg > 0 )
	- csfrmn = getArg( 0 );
	+ m_csfrmn = getArg( 0 );
	if ( narg > 1 )
	- csbkmn = getArg( 1 );
	+ m_csbkmn = getArg( 1 );
	if ( narg > 2 )
	- fmax = getArg( 2 );
	+ m_fmax = getArg( 2 );
	if ( narg > 3 )
	- firstorder = true;
	+ m_firstorder = true;
	}

	void EvtVectorIsr::initProbMax()
	@@ -130,7 +130,7 @@
	double largest_f =
	0; //only used when determining max weight for this vector particle mass

	- if ( !firstorder ) {
	+ if ( !m_firstorder ) {
	while ( fran > f ) {
	m++;

	@@ -178,8 +178,8 @@

	f = cs_Born * f_col;

	- //if fmax was set properly, f should NEVER be larger than fmax
	- if ( f > fmax && fmax > 0. ) {
	+ //if m_fmax was set properly, f should NEVER be larger than m_fmax
	+ if ( f > m_fmax && m_fmax > 0. ) {
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "EvtVectorIsr finds a problem with fmax, the maximum weight setting\n"
	<< "fmax is the third decay argument in the .dec file. VectorIsr attempts to set it reasonably if it wasn't provided\n"
	@@ -190,13 +190,13 @@
	<< "phi->1.15 J/psi-psi(4415)->0.105\n"
	<< "The current value of f and fmax for "
	<< EvtPDL::name( phi->getId() ) << " are " << f << " "
	- << fmax << "\n"
	+ << m_fmax << "\n"
	<< "Will now assert\n";
	assert( 0 );
	}

	- if ( fmax > 0. ) {
	- fran = fmax * EvtRandom::Flat( 0.0, 1.0 );
	+ if ( m_fmax > 0. ) {
	+ fran = m_fmax * EvtRandom::Flat( 0.0, 1.0 );
	}

	else {
	@@ -227,7 +227,7 @@
	}

	if ( m > 100000 ) {
	- if ( fmax > 0. )
	+ if ( m_fmax > 0. )
	EvtGenReport( EVTGEN_INFO, "EvtGen" )
	<< "EvtVectorIsr is having problems. Check the fmax value - the 3rd argument in the .dec file\n"
	<< "Recommended values for various vector particles: "
	@@ -237,7 +237,7 @@
	}
	} //while (fran > f)

	- } //if (firstorder)
	+ } //if (m_firstorder)

	//Compute parameters for boost to/from the system after colinear radiation

	@@ -248,12 +248,12 @@
	double csfrmn_new;
	double csbkmn_new;

	- if ( firstorder ) {
	+ if ( m_firstorder ) {
	bet_l = 0.;
	gam_l = 1.;
	betgam_l = 0.;
	- csfrmn_new = csfrmn;
	- csbkmn_new = csbkmn;
	+ csfrmn_new = m_csfrmn;
	+ csbkmn_new = m_csbkmn;
	} else {
	double xx = e02 / e01;
	double sq_xx = sqrt( xx );
	@@ -262,8 +262,8 @@
	betgam_l = ( 1. - xx ) / ( 2. * sq_xx );

	//Boost photon cos_theta limits in lab to limits in the system after colinear rad
	- csfrmn_new = ( csfrmn - bet_l ) / ( 1. - bet_l * csfrmn );
	- csbkmn_new = ( csbkmn - bet_l ) / ( 1. - bet_l * csbkmn );
	+ csfrmn_new = ( m_csfrmn - bet_l ) / ( 1. - bet_l * m_csfrmn );
	+ csbkmn_new = ( m_csbkmn - bet_l ) / ( 1. - bet_l * m_csbkmn );
	}

	// //generate kinematics according to Bonneau-Martin article
	@@ -305,7 +305,7 @@
	-p4phi.get( 2 ), betgam_l * isr_p0 + gam_l * isr_p3 );

	//four-vectors of the collinear photons
	- if ( !firstorder ) {
	+ if ( !m_firstorder ) {
	p4softg1.set( 0, eb - e02 );
	p4softg1.set( 3, e02 - eb );
	p4softg2.set( 0, eb - e01 );
	diff --git a/src/EvtGenModels/EvtVtoSll.cpp b/src/EvtGenModels/EvtVtoSll.cpp
	--- a/src/EvtGenModels/EvtVtoSll.cpp
	+++ b/src/EvtGenModels/EvtVtoSll.cpp
	@@ -186,7 +186,7 @@
	parent->initializePhaseSpace( getNDaug(), getDaugs() );
	}

	- calcAmp( *parent, _amp2 );
	+ calcAmp( *parent, m_amp2 );
	}

	void EvtVtoSll::calcAmp( const EvtParticle& parent, EvtAmp& amp ) const
	diff --git a/src/EvtGenModels/EvtVub.cpp b/src/EvtGenModels/EvtVub.cpp
	--- a/src/EvtGenModels/EvtVub.cpp
	+++ b/src/EvtGenModels/EvtVub.cpp
	@@ -58,17 +58,17 @@
	::abort();
	}

	- _mb = getArg( 0 );
	- _a = getArg( 1 );
	- _alphas = getArg( 2 );
	- _nbins = abs( (int)getArg( 3 ) );
	- _storeQplus = ( getArg( 3 ) < 0 ? 1 : 0 );
	- _masses = std::vector<double>( _nbins );
	- _weights = std::vector<double>( _nbins );
	-
	- if ( getNArg() - 4 != 2 * _nbins ) {
	+ m_mb = getArg( 0 );
	+ m_a = getArg( 1 );
	+ m_alphas = getArg( 2 );
	+ m_nbins = abs( (int)getArg( 3 ) );
	+ m_storeQplus = ( getArg( 3 ) < 0 ? 1 : 0 );
	+ m_masses = std::vector<double>( m_nbins );
	+ m_weights = std::vector<double>( m_nbins );
	+
	+ if ( getNArg() - 4 != 2 * m_nbins ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "EvtVub generator expected " << _nbins
	+ << "EvtVub generator expected " << m_nbins
	<< " masses and weights but found: " << ( getNArg() - 4 ) / 2
	<< endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -77,26 +77,26 @@
	}
	int i, j = 4;
	double maxw = 0.;
	- for ( i = 0; i < _nbins; i++ ) {
	- _masses[i] = getArg( j++ );
	- if ( i > 0 && _masses[i] <= _masses[i - 1] ) {
	+ for ( i = 0; i < m_nbins; i++ ) {
	+ m_masses[i] = getArg( j++ );
	+ if ( i > 0 && m_masses[i] <= m_masses[i - 1] ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "EvtVub generator expected "
	<< " mass bins in ascending order!"
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- _weights[i] = getArg( j++ );
	- if ( _weights[i] < 0 ) {
	+ m_weights[i] = getArg( j++ );
	+ if ( m_weights[i] < 0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "EvtVub generator expected "
	- << " weights >= 0, but found: " << _weights[i] << endl;
	+ << " weights >= 0, but found: " << m_weights[i] << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- if ( _weights[i] > maxw )
	- maxw = _weights[i];
	+ if ( m_weights[i] > maxw )
	+ maxw = m_weights[i];
	}
	if ( maxw == 0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -105,15 +105,15 @@
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- for ( i = 0; i < _nbins; i++ )
	- _weights[i] /= maxw;
	+ for ( i = 0; i < m_nbins; i++ )
	+ m_weights[i] /= maxw;

	// the maximum dGamma*p2 value depends on alpha_s only:

	const double dGMax0 = 3.;
	- _dGMax = 0.21344 + 8.905 * _alphas;
	- if ( _dGMax < dGMax0 )
	- _dGMax = dGMax0;
	+ m_dGMax = 0.21344 + 8.905 * m_alphas;
	+ if ( m_dGMax < dGMax0 )
	+ m_dGMax = dGMax0;

	// for the Fermi Motion we need a B-Meson mass - but it's not critical
	// to get an exact value; in order to stay in the phase space for
	@@ -127,30 +127,30 @@

	double mB = ( mB0 < mBP ? mB0 : mBP );

	- const double xlow = -_mb;
	- const double xhigh = mB - _mb;
	+ const double xlow = -m_mb;
	+ const double xhigh = mB - m_mb;
	const int aSize = 10000;

	- EvtPFermi pFermi( _a, mB, _mb );
	+ EvtPFermi pFermi( m_a, mB, m_mb );
	// pf is the cumulative distribution
	// normalized to 1.
	- _pf.resize( aSize );
	+ m_pf.resize( aSize );
	for ( i = 0; i < aSize; i++ ) {
	double kplus = xlow + (double)( i + 0.5 ) / ( (double)aSize ) *
	( xhigh - xlow );
	if ( i == 0 )
	- _pf[i] = pFermi.getFPFermi( kplus );
	+ m_pf[i] = pFermi.getFPFermi( kplus );
	else
	- _pf[i] = _pf[i - 1] + pFermi.getFPFermi( kplus );
	+ m_pf[i] = m_pf[i - 1] + pFermi.getFPFermi( kplus );
	}
	- for ( size_t index = 0; index < _pf.size(); index++ ) {
	- _pf[index] /= _pf[_pf.size() - 1];
	+ for ( size_t index = 0; index < m_pf.size(); index++ ) {
	+ m_pf[index] /= m_pf[m_pf.size() - 1];
	}

	// static EvtHepRandomEngine myEngine;

	// _pFermi = new RandGeneral(myEngine,pf,aSize,0);
	- _dGamma = std::make_unique<EvtVubdGamma>( _alphas );
	+ m_dGamma = std::make_unique<EvtVubdGamma>( m_alphas );

	// check that there are 3 daughters
	checkNDaug( 3 );
	@@ -188,8 +188,8 @@
	mB = p->mass();
	ml = lepton->mass();

	- xlow = -_mb;
	- xhigh = mB - _mb;
	+ xlow = -m_mb;
	+ xhigh = mB - m_mb;

	// Fermi motion does not need to be computed inside the
	// tryit loop as m_b in Gamma0 does not need to be replaced by (m_b+kplus).
	@@ -197,17 +197,17 @@
	// beyond the considered orders in the paper anyway ...

	// for alpha_S = 0 and a mass cut on X_u not all values of kplus are
	- // possible. The maximum value is mB/2-_mb + sqrt(mB^2/4-_masses[0]^2)
	+ // possible. The maximum value is mB/2-m_mb + sqrt(mB^2/4-m_masses[0]^2)
	kplus = 2 * xhigh;

	while ( kplus >= xhigh \|\| kplus <= xlow \|\|
	- ( _alphas == 0 &&
	- kplus >= mB / 2 - _mb +
	- sqrt( mB * mB / 4 - _masses[0] * _masses[0] ) ) ) {
	+ ( m_alphas == 0 &&
	+ kplus >= mB / 2 - m_mb +
	+ sqrt( mB * mB / 4 - m_masses[0] * m_masses[0] ) ) ) {
	kplus = findPFermi(); //_pFermi->shoot();
	kplus = xlow + kplus * ( xhigh - xlow );
	}
	- qplus = mB - _mb - kplus;
	+ qplus = mB - m_mb - kplus;
	if ( ( mB - qplus ) / 2. <= ml )
	continue;

	@@ -224,11 +224,12 @@
	if ( Eh > 0 && Eh < mB ) {
	sh = p2 * pow( mB - qplus, 2 ) +
	2 * qplus * ( Eh - qplus ) + qplus * qplus;
	- if ( sh > _masses[0] * _masses[0] &&
	+ if ( sh > m_masses[0] * m_masses[0] &&
	mB * mB + sh - 2 * mB * Eh > ml * ml ) {
	double xran = EvtRandom::Flat();

	- double y = _dGamma->getdGdxdzdp( x, z, p2 ) / _dGMax * p2;
	+ double y = m_dGamma->getdGdxdzdp( x, z, p2 ) / m_dGMax *
	+ p2;

	if ( y > 1 )
	EvtGenReport( EVTGEN_WARNING, "EvtGen" )
	@@ -241,13 +242,13 @@
	}
	}
	// reweight the Mx distribution
	- if ( _nbins > 0 ) {
	+ if ( m_nbins > 0 ) {
	double xran1 = EvtRandom::Flat();
	double m = sqrt( sh );
	j = 0;
	- while ( j < _nbins && m > _masses[j] )
	+ while ( j < m_nbins && m > m_masses[j] )
	j++;
	- double w = _weights[j - 1];
	+ double w = m_weights[j - 1];
	if ( w >= xran1 )
	rew = false;
	} else {
	@@ -279,7 +280,7 @@
	p4.set( pHB[0], pHB[1], pHB[2], pHB[3] );
	xuhad->init( getDaug( 0 ), p4 );

	- if ( _storeQplus ) {
	+ if ( m_storeQplus ) {
	// cludge to store the hidden parameter q+ with the decay;
	// the lifetime of the Xu is abused for this purpose.
	// tau = 1 ps corresponds to ctau = 0.3 mm -> in order to
	@@ -376,21 +377,21 @@
	double EvtVub::findPFermi()
	{
	double ranNum = EvtRandom::Flat();
	- double oOverBins = 1.0 / ( float( _pf.size() ) );
	+ double oOverBins = 1.0 / ( float( m_pf.size() ) );
	int nBinsBelow = 0; // largest k such that I[k] is known to be <= rand
	- int nBinsAbove = _pf.size(); // largest k such that I[k] is known to be > rand
	+ int nBinsAbove = m_pf.size(); // largest k such that I[k] is known to be > rand
	int middle;

	while ( nBinsAbove > nBinsBelow + 1 ) {
	middle = ( nBinsAbove + nBinsBelow + 1 ) >> 1;
	- if ( ranNum >= _pf[middle] ) {
	+ if ( ranNum >= m_pf[middle] ) {
	nBinsBelow = middle;
	} else {
	nBinsAbove = middle;
	}
	}

	- double bSize = _pf[nBinsAbove] - _pf[nBinsBelow];
	+ double bSize = m_pf[nBinsAbove] - m_pf[nBinsBelow];
	// binMeasure is always aProbFunc[nBinsBelow],

	if ( bSize == 0 ) {
	@@ -400,7 +401,7 @@
	return ( nBinsBelow + .5 ) * oOverBins;
	}

	- double bFract = ( ranNum - _pf[nBinsBelow] ) / bSize;
	+ double bFract = ( ranNum - m_pf[nBinsBelow] ) / bSize;

	return ( nBinsBelow + bFract ) * oOverBins;
	}
	diff --git a/src/EvtGenModels/EvtVubBLNP.cpp b/src/EvtGenModels/EvtVubBLNP.cpp
	--- a/src/EvtGenModels/EvtVubBLNP.cpp
	+++ b/src/EvtGenModels/EvtVubBLNP.cpp
	@@ -60,121 +60,123 @@
	// get parameters (declared in the header file)

	// Input parameters
	- mBB = 5.2792;
	- lambda2 = 0.12;
	+ m_mBB = 5.2792;
	+ m_lambda2 = 0.12;

	// Shape function parameters
	- b = getArg( 0 );
	- Lambda = getArg( 1 );
	- Ecut = 1.8;
	- wzero = mBB - 2 * Ecut;
	+ m_b = getArg( 0 );
	+ m_Lambda = getArg( 1 );
	+ m_Ecut = 1.8;
	+ m_wzero = m_mBB - 2 * m_Ecut;

	// SF and SSF modes
	- itype = (int)getArg( 5 );
	- dtype = getArg( 5 );
	- isubl = (int)getArg( 6 );
	+ m_itype = (int)getArg( 5 );
	+ m_dtype = getArg( 5 );
	+ m_isubl = (int)getArg( 6 );

	// flags
	- flag1 = (int)getArg( 7 );
	- flag2 = (int)getArg( 8 );
	- flag3 = (int)getArg( 9 );
	+ m_flag1 = (int)getArg( 7 );
	+ m_flag2 = (int)getArg( 8 );
	+ m_flag3 = (int)getArg( 9 );

	// Quark mass
	- mb = 4.61;
	+ m_mb = 4.61;

	// hidden parameter what and SF stuff
	const double xlow = 0;
	- const double xhigh = mBB;
	+ const double xhigh = m_mBB;
	const int aSize = 10000;
	- EvtPFermi pFermi( Lambda, b );
	+ EvtPFermi pFermi( m_Lambda, m_b );
	// pf is the cumulative distribution normalized to 1.
	- _pf.resize( aSize );
	+ m_pf.resize( aSize );
	for ( int i = 0; i < aSize; i++ ) {
	double what = xlow + (double)( i + 0.5 ) / ( (double)aSize ) *
	( xhigh - xlow );
	if ( i == 0 )
	- _pf[i] = pFermi.getSFBLNP( what );
	+ m_pf[i] = pFermi.getSFBLNP( what );
	else
	- _pf[i] = _pf[i - 1] + pFermi.getSFBLNP( what );
	+ m_pf[i] = m_pf[i - 1] + pFermi.getSFBLNP( what );
	}
	- for ( size_t i = 0; i < _pf.size(); i++ ) {
	- _pf[i] /= _pf[_pf.size() - 1];
	+ for ( size_t i = 0; i < m_pf.size(); i++ ) {
	+ m_pf[i] /= m_pf[m_pf.size() - 1];
	}

	// Matching scales
	- muh = mBB * getArg( 2 ); // 0.5
	- mui = getArg( 3 ); // 1.5
	- mubar = getArg( 4 ); // 1.5
	+ m_muh = m_mBB * getArg( 2 ); // 0.5
	+ m_mui = getArg( 3 ); // 1.5
	+ m_mubar = getArg( 4 ); // 1.5

	// Perturbative quantities
	- CF = 4.0 / 3.0;
	- CA = 3.0;
	+ m_CF = 4.0 / 3.0;
	+ m_CA = 3.0;
	double nf = 4.0;

	- beta0 = 11.0 / 3.0 * CA - 2.0 / 3.0 * nf;
	- beta1 = 34.0 / 3.0 * CA * CA - 10.0 / 3.0 * CA * nf - 2.0 * CF * nf;
	- beta2 = 2857.0 / 54.0 * CA * CA * CA +
	- ( CF * CF - 205.0 / 18.0 * CF * CA - 1415.0 / 54.0 * CA * CA ) * nf +
	- ( 11.0 / 9.0 * CF + 79.0 / 54.0 * CA ) * nf * nf;
	-
	- zeta3 = 1.0 + 1 / 8.0 + 1 / 27.0 + 1 / 64.0;
	-
	- Gamma0 = 4 * CF;
	- Gamma1 = CF * ( ( 268.0 / 9.0 - 4.0 * M_PI * M_PI / 3.0 ) * CA -
	- 40.0 / 9.0 * nf );
	- Gamma2 = 16 * CF *
	- ( ( 245.0 / 24.0 - 67.0 / 54.0 * M_PI * M_PI +
	- +11.0 / 180.0 * pow( M_PI, 4 ) + 11.0 / 6.0 * zeta3 ) *
	- CA * CA *
	- +( -209.0 / 108.0 + 5.0 / 27.0 * M_PI * M_PI -
	- 7.0 / 3.0 * zeta3 ) *
	- CA * nf +
	- ( -55.0 / 24.0 + 2 * zeta3 ) * CF * nf - nf * nf / 27.0 );
	-
	- gp0 = -5.0 * CF;
	- gp1 = -8.0 * CF *
	- ( ( 3.0 / 16.0 - M_PI * M_PI / 4.0 + 3 * zeta3 ) * CF +
	- ( 1549.0 / 432.0 + 7.0 / 48.0 * M_PI * M_PI - 11.0 / 4.0 * zeta3 ) *
	- CA -
	- ( 125.0 / 216.0 + M_PI * M_PI / 24.0 ) * nf );
	-
	- // Lbar and mupisq
	-
	- Lbar = Lambda; // all models
	- mupisq = 3 * Lambda * Lambda / b;
	- if ( itype == 1 )
	- mupisq = 3 * Lambda * Lambda / b;
	- if ( itype == 2 )
	- mupisq = 3 * Lambda * Lambda *
	- ( Gamma( 1 + 0.5 * b ) * Gamma( 0.5 * b ) /
	- pow( Gamma( 0.5 + 0.5 * b ), 2 ) -
	- 1 );
	-
	- // moment2 for SSFs
	- moment2 = pow( 0.3, 3 );
	+ m_beta0 = 11.0 / 3.0 * m_CA - 2.0 / 3.0 * nf;
	+ m_beta1 = 34.0 / 3.0 * m_CA * m_CA - 10.0 / 3.0 * m_CA * nf - 2.0 * m_CF * nf;
	+ m_beta2 = 2857.0 / 54.0 * m_CA * m_CA * m_CA +
	+ ( m_CF * m_CF - 205.0 / 18.0 * m_CF * m_CA -
	+ 1415.0 / 54.0 * m_CA * m_CA ) *
	+ nf +
	+ ( 11.0 / 9.0 * m_CF + 79.0 / 54.0 * m_CA ) * nf * nf;
	+
	+ m_zeta3 = 1.0 + 1 / 8.0 + 1 / 27.0 + 1 / 64.0;
	+
	+ m_Gamma0 = 4 * m_CF;
	+ m_Gamma1 = m_CF * ( ( 268.0 / 9.0 - 4.0 * M_PI * M_PI / 3.0 ) * m_CA -
	+ 40.0 / 9.0 * nf );
	+ m_Gamma2 = 16 * m_CF *
	+ ( ( 245.0 / 24.0 - 67.0 / 54.0 * M_PI * M_PI +
	+ +11.0 / 180.0 * pow( M_PI, 4 ) + 11.0 / 6.0 * m_zeta3 ) *
	+ m_CA * m_CA *
	+ +( -209.0 / 108.0 + 5.0 / 27.0 * M_PI * M_PI -
	+ 7.0 / 3.0 * m_zeta3 ) *
	+ m_CA * nf +
	+ ( -55.0 / 24.0 + 2 * m_zeta3 ) * m_CF * nf - nf * nf / 27.0 );
	+
	+ m_gp0 = -5.0 * m_CF;
	+ m_gp1 = -8.0 * m_CF *
	+ ( ( 3.0 / 16.0 - M_PI * M_PI / 4.0 + 3 * m_zeta3 ) * m_CF +
	+ ( 1549.0 / 432.0 + 7.0 / 48.0 * M_PI * M_PI - 11.0 / 4.0 * m_zeta3 ) *
	+ m_CA -
	+ ( 125.0 / 216.0 + M_PI * M_PI / 24.0 ) * nf );
	+
	+ // Lbar and m_mupisq
	+
	+ m_Lbar = m_Lambda; // all models
	+ m_mupisq = 3 * m_Lambda * m_Lambda / m_b;
	+ if ( m_itype == 1 )
	+ m_mupisq = 3 * m_Lambda * m_Lambda / m_b;
	+ if ( m_itype == 2 )
	+ m_mupisq = 3 * m_Lambda * m_Lambda *
	+ ( Gamma( 1 + 0.5 * m_b ) * Gamma( 0.5 * m_b ) /
	+ pow( Gamma( 0.5 + 0.5 * m_b ), 2 ) -
	+ 1 );
	+
	+ // m_moment2 for SSFs
	+ m_moment2 = pow( 0.3, 3 );

	// inputs for total rate (T for Total); use BLNP notebook defaults
	- flagpower = 1;
	- flag2loop = 1;
	+ m_flagpower = 1;
	+ m_flag2loop = 1;

	// stuff for the integrator
	- maxLoop = 20;
	- //precision = 1.0e-3;
	- precision = 2.0e-2;
	+ m_maxLoop = 20;
	+ //m_precision = 1.0e-3;
	+ m_precision = 2.0e-2;

	// vector of global variables, to pass to static functions (which can't access globals);
	- gvars.push_back( 0.0 ); // 0
	- gvars.push_back( 0.0 ); // 1
	- gvars.push_back( mui ); // 2
	- gvars.push_back( b ); // 3
	- gvars.push_back( Lambda ); // 4
	- gvars.push_back( mBB ); // 5
	- gvars.push_back( mb ); // 6
	- gvars.push_back( wzero ); // 7
	- gvars.push_back( beta0 ); // 8
	- gvars.push_back( beta1 ); // 9
	- gvars.push_back( beta2 ); // 10
	- gvars.push_back( dtype ); // 11
	+ m_gvars.push_back( 0.0 ); // 0
	+ m_gvars.push_back( 0.0 ); // 1
	+ m_gvars.push_back( m_mui ); // 2
	+ m_gvars.push_back( m_b ); // 3
	+ m_gvars.push_back( m_Lambda ); // 4
	+ m_gvars.push_back( m_mBB ); // 5
	+ m_gvars.push_back( m_mb ); // 6
	+ m_gvars.push_back( m_wzero ); // 7
	+ m_gvars.push_back( m_beta0 ); // 8
	+ m_gvars.push_back( m_beta1 ); // 9
	+ m_gvars.push_back( m_beta2 ); // 10
	+ m_gvars.push_back( m_dtype ); // 11

	// check that there are 3 daughters and 10 arguments
	checkNDaug( 3 );
	@@ -203,12 +205,12 @@
	lepton = Bmeson->getDaug( 1 );
	neutrino = Bmeson->getDaug( 2 );

	- mBB = Bmeson->mass();
	+ m_mBB = Bmeson->mass();
	ml = lepton->mass();

	// get SF value
	xlow = 0;
	- xhigh = mBB;
	+ xhigh = m_mBB;
	// the case for alphas = 0 is not considered
	what = 2 * xhigh;
	while ( what > xhigh \|\| what < xlow ) {
	@@ -222,13 +224,13 @@
	// generate pp between 0 and
	// Flat(min, max) gives R(max - min) + min, where R = random btwn 0 and 1

	- Pp = EvtRandom::Flat( 0, mBB ); // P+ = EX - \|PX\|
	- Pl = EvtRandom::Flat( 0, mBB ); // mBB - 2El
	- Pm = EvtRandom::Flat( 0, mBB ); // P- = EX + \|PX\|
	+ Pp = EvtRandom::Flat( 0, m_mBB ); // P+ = EX - \|PX\|
	+ Pl = EvtRandom::Flat( 0, m_mBB ); // mBB - 2El
	+ Pm = EvtRandom::Flat( 0, m_mBB ); // P- = EX + \|PX\|

	sh = Pm * Pp;
	EX = 0.5 * ( Pm + Pp );
	- El = 0.5 * ( mBB - Pl );
	+ El = 0.5 * ( m_mBB - Pl );

	// Need maximum rate. Waiting for Mr. Paz to give it to me.
	// Meanwhile, use this.
	@@ -236,7 +238,7 @@

	// kinematic bounds (Eq. 2)
	mpi = 0.14;
	- if ( ( Pp > 0 ) && ( Pp <= Pl ) && ( Pl <= Pm ) && ( Pm < mBB ) &&
	+ if ( ( Pp > 0 ) && ( Pp <= Pl ) && ( Pl <= Pm ) && ( Pm < m_mBB ) &&
	( El > ml ) && ( sh > 4 * mpi * mpi ) ) {
	// Probability of pass proportional to PDF
	pdf = rate3( Pp, Pl, Pm );
	@@ -287,12 +289,12 @@
	// calculate the W 4 vector in the B Meson restrframe

	double apWB = ptmp;
	- double pWB[4] = { mBB - EX, -pHB[1], -pHB[2], -pHB[3] };
	+ double pWB[4] = { m_mBB - EX, -pHB[1], -pHB[2], -pHB[3] };

	// first go in the W restframe and calculate the lepton and
	// the neutrino in the W frame

	- double mW2 = mBB * mBB + sh - 2 * mBB * EX;
	+ double mW2 = m_mBB * m_mBB + sh - 2 * m_mBB * EX;
	double beta = ptmp / pWB[0];
	double gamma = pWB[0] / sqrt( mW2 );

	@@ -366,13 +368,13 @@
	{
	// rate3 in units of GF^2*Vub^2/pi^3

	- double factor = 1.0 / 16 * ( mBB - Pp ) * U1lo( muh, mui ) *
	- pow( ( Pm - Pp ) / ( mBB - Pp ), alo( muh, mui ) );
	+ double factor = 1.0 / 16 * ( m_mBB - Pp ) * U1lo( m_muh, m_mui ) *
	+ pow( ( Pm - Pp ) / ( m_mBB - Pp ), alo( m_muh, m_mui ) );

	- double doneJS = DoneJS( Pp, Pm, mui );
	- double done1 = Done1( Pp, Pm, mui );
	- double done2 = Done2( Pp, Pm, mui );
	- double done3 = Done3( Pp, Pm, mui );
	+ double doneJS = DoneJS( Pp, Pm, m_mui );
	+ double done1 = Done1( Pp, Pm, m_mui );
	+ double done2 = Done2( Pp, Pm, m_mui );
	+ double done3 = Done3( Pp, Pm, m_mui );

	// The EvtSimpsonIntegrator returns zero for bad integrals.
	// So if any of the integrals are zero (ie bad), return zero.
	@@ -386,12 +388,12 @@
	// cout << "Integral OK: (Pp, Pm, Pl) = (" << Pp << ", " << Pm << ", " << Pl << ")" << endl;
	//}

	- double f1 = F1( Pp, Pm, muh, mui, mubar, doneJS, done1 );
	- double f2 = F2( Pp, Pm, muh, mui, mubar, done3 );
	- double f3 = F3( Pp, Pm, muh, mui, mubar, done2 );
	- double answer = factor * ( ( mBB + Pl - Pp - Pm ) * ( Pm - Pl ) * f1 +
	+ double f1 = F1( Pp, Pm, m_muh, m_mui, m_mubar, doneJS, done1 );
	+ double f2 = F2( Pp, Pm, m_muh, m_mui, m_mubar, done3 );
	+ double f3 = F3( Pp, Pm, m_muh, m_mui, m_mubar, done2 );
	+ double answer = factor * ( ( m_mBB + Pl - Pp - Pm ) * ( Pm - Pl ) * f1 +
	2 * ( Pl - Pp ) * ( Pm - Pl ) * f2 +
	- ( mBB - Pm ) * ( Pm - Pp ) * f3 );
	+ ( m_mBB - Pm ) * ( Pm - Pp ) * f3 );
	return answer;
	}

	@@ -402,35 +404,37 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	- double y = ( Pm - Pp ) / ( mBB - Pp );
	- double ah = CF * alphas( muh, vars ) / 4 / M_PI;
	- double ai = CF * alphas( mui, vars ) / 4 / M_PI;
	- double abar = CF * alphas( mubar, vars ) / 4 / M_PI;
	- double lambda1 = -mupisq;
	+ double y = ( Pm - Pp ) / ( m_mBB - Pp );
	+ double ah = m_CF * alphas( muh, vars ) / 4 / M_PI;
	+ double ai = m_CF * alphas( mui, vars ) / 4 / M_PI;
	+ double abar = m_CF * alphas( mubar, vars ) / 4 / M_PI;
	+ double lambda1 = -m_mupisq;

	- double t1 = -4 * ai / ( Pp - Lbar ) * ( 2 * log( ( Pp - Lbar ) / mui ) + 1 );
	+ double t1 = -4 * ai / ( Pp - m_Lbar ) *
	+ ( 2 * log( ( Pp - m_Lbar ) / mui ) + 1 );
	double t2 = 1 + dU1nlo( muh, mui ) + anlo( muh, mui ) * log( y );
	- double t3 = -4.0 * pow( log( y * mb / muh ), 2 ) +
	- 10.0 * log( y * mb / muh ) - 4.0 * log( y ) -
	+ double t3 = -4.0 * pow( log( y * m_mb / muh ), 2 ) +
	+ 10.0 * log( y * m_mb / muh ) - 4.0 * log( y ) -
	2.0 * log( y ) / ( 1 - y ) - 4.0 * PolyLog( 2, 1 - y ) -
	M_PI * M_PI / 6.0 - 12.0;
	- double t4 = 2 * pow( log( y * mb * Pp / ( mui * mui ) ), 2 ) -
	- 3 * log( y * mb * Pp / ( mui * mui ) ) + 7 - M_PI * M_PI;
	+ double t4 = 2 * pow( log( y * m_mb * Pp / ( mui * mui ) ), 2 ) -
	+ 3 * log( y * m_mb * Pp / ( mui * mui ) ) + 7 - M_PI * M_PI;

	double t5 = -wS( Pp ) + 2 * t( Pp ) +
	( 1.0 / y - 1.0 ) * ( u( Pp ) - v( Pp ) );
	- double t6 = -( lambda1 + 3.0 * lambda2 ) / 3.0 +
	- 1.0 / pow( y, 2 ) * ( 4.0 / 3.0 * lambda1 - 2.0 * lambda2 );
	+ double t6 = -( lambda1 + 3.0 * m_lambda2 ) / 3.0 +
	+ 1.0 / pow( y, 2 ) * ( 4.0 / 3.0 * lambda1 - 2.0 * m_lambda2 );

	double shapePp = Shat( Pp, vars );

	double answer = ( t2 + ah * t3 + ai * t4 ) * shapePp + ai * doneJS +
	- 1 / ( mBB - Pp ) * ( flag2 * abar * done1 + flag1 * t5 ) +
	- 1 / pow( mBB - Pp, 2 ) * flag3 * shapePp * t6;
	- if ( Pp > Lbar + mui / exp( 0.5 ) )
	+ 1 / ( m_mBB - Pp ) *
	+ ( m_flag2 * abar * done1 + m_flag1 * t5 ) +
	+ 1 / pow( m_mBB - Pp, 2 ) * m_flag3 * shapePp * t6;
	+ if ( Pp > m_Lbar + mui / exp( 0.5 ) )
	answer = answer + t1;
	return answer;
	}
	@@ -442,24 +446,24 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	- double y = ( Pm - Pp ) / ( mBB - Pp );
	- double lambda1 = -mupisq;
	- double ah = CF * alphas( muh, vars ) / 4 / M_PI;
	- double abar = CF * alphas( mubar, vars ) / 4 / M_PI;
	+ double y = ( Pm - Pp ) / ( m_mBB - Pp );
	+ double lambda1 = -m_mupisq;
	+ double ah = m_CF * alphas( muh, vars ) / 4 / M_PI;
	+ double abar = m_CF * alphas( mubar, vars ) / 4 / M_PI;

	double t6 = -wS( Pp ) - 2 * t( Pp ) + 1.0 / y * ( t( Pp ) + v( Pp ) );
	- double t7 = 1 / pow( y, 2 ) * ( 2.0 / 3.0 * lambda1 + 4.0 * lambda2 ) -
	- 1 / y * ( 2.0 / 3.0 * lambda1 + 3.0 / 2.0 * lambda2 );
	+ double t7 = 1 / pow( y, 2 ) * ( 2.0 / 3.0 * lambda1 + 4.0 * m_lambda2 ) -
	+ 1 / y * ( 2.0 / 3.0 * lambda1 + 3.0 / 2.0 * m_lambda2 );

	double shapePp = Shat( Pp, vars );

	double answer = ah * log( y ) / ( 1 - y ) * shapePp +
	- 1 / ( mBB - Pp ) *
	- ( flag2 * abar * 0.5 * done3 + flag1 / y * t6 ) +
	- 1.0 / pow( mBB - Pp, 2 ) * flag3 * shapePp * t7;
	+ 1 / ( m_mBB - Pp ) *
	+ ( m_flag2 * abar * 0.5 * done3 + m_flag1 / y * t6 ) +
	+ 1.0 / pow( m_mBB - Pp, 2 ) * m_flag3 * shapePp * t7;
	return answer;
	}

	@@ -470,19 +474,19 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	- double y = ( Pm - Pp ) / ( mBB - Pp );
	- double lambda1 = -mupisq;
	- double abar = CF * alphas( mubar, vars ) / 4 / M_PI;
	+ double y = ( Pm - Pp ) / ( m_mBB - Pp );
	+ double lambda1 = -m_mupisq;
	+ double abar = m_CF * alphas( mubar, vars ) / 4 / M_PI;

	- double t7 = 1.0 / pow( y, 2 ) * ( -2.0 / 3.0 * lambda1 + lambda2 );
	+ double t7 = 1.0 / pow( y, 2 ) * ( -2.0 / 3.0 * lambda1 + m_lambda2 );

	double shapePp = Shat( Pp, vars );

	- double answer = 1.0 / ( Pm - Pp ) * flag2 * 0.5 * y * abar * done2 +
	- 1.0 / pow( mBB - Pp, 2 ) * flag3 * shapePp * t7;
	+ double answer = 1.0 / ( Pm - Pp ) * m_flag2 * 0.5 * y * abar * done2 +
	+ 1.0 / pow( m_mBB - Pp, 2 ) * m_flag3 * shapePp * t7;
	return answer;
	}

	@@ -492,14 +496,14 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	double lowerlim = 0.001 * Pp;
	double upperlim = ( 1.0 - 0.001 ) * Pp;

	auto func = EvtItgPtrFunction{ &IntJS, lowerlim, upperlim, vars };
	- auto integ = EvtItgSimpsonIntegrator{ func, precision, maxLoop };
	+ auto integ = EvtItgSimpsonIntegrator{ func, m_precision, m_maxLoop };
	return integ.evaluate( lowerlim, upperlim );
	}

	@@ -509,14 +513,14 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	double lowerlim = 0.001 * Pp;
	double upperlim = ( 1.0 - 0.001 ) * Pp;

	auto func = EvtItgPtrFunction{ &Int1, lowerlim, upperlim, vars };
	- auto integ = EvtItgSimpsonIntegrator{ func, precision, maxLoop };
	+ auto integ = EvtItgSimpsonIntegrator{ func, m_precision, m_maxLoop };
	return integ.evaluate( lowerlim, upperlim );
	}

	@@ -526,14 +530,14 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	double lowerlim = 0.001 * Pp;
	double upperlim = ( 1.0 - 0.001 ) * Pp;

	auto func = EvtItgPtrFunction{ &Int2, lowerlim, upperlim, vars };
	- auto integ = EvtItgSimpsonIntegrator{ func, precision, maxLoop };
	+ auto integ = EvtItgSimpsonIntegrator{ func, m_precision, m_maxLoop };
	return integ.evaluate( lowerlim, upperlim );
	}

	@@ -543,14 +547,14 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	double lowerlim = 0.001 * Pp;
	double upperlim = ( 1.0 - 0.001 ) * Pp;

	auto func = EvtItgPtrFunction{ &Int3, lowerlim, upperlim, vars };
	- auto integ = EvtItgSimpsonIntegrator{ func, precision, maxLoop };
	+ auto integ = EvtItgSimpsonIntegrator{ func, m_precision, m_maxLoop };
	return integ.evaluate( lowerlim, upperlim );
	}

	@@ -714,26 +718,26 @@

	double EvtVubBLNP::wS( double w )
	{
	- double answer = ( Lbar - w ) * Shat( w, gvars );
	+ double answer = ( m_Lbar - w ) * Shat( w, m_gvars );
	return answer;
	}

	double EvtVubBLNP::t( double w )
	{
	- double t1 = -3 * lambda2 / mupisq * ( Lbar - w ) * Shat( w, gvars );
	- double myf = myfunction( w, Lbar, moment2 );
	- double myBIK = myfunctionBIK( w, Lbar, moment2 );
	+ double t1 = -3 * m_lambda2 / m_mupisq * ( m_Lbar - w ) * Shat( w, m_gvars );
	+ double myf = myfunction( w, m_Lbar, m_moment2 );
	+ double myBIK = myfunctionBIK( w, m_Lbar, m_moment2 );
	double answer = t1;

	- if ( isubl == 1 )
	+ if ( m_isubl == 1 )
	answer = t1;
	- if ( isubl == 3 )
	+ if ( m_isubl == 3 )
	answer = t1 - myf;
	- if ( isubl == 4 )
	+ if ( m_isubl == 4 )
	answer = t1 + myf;
	- if ( isubl == 5 )
	+ if ( m_isubl == 5 )
	answer = t1 - myBIK;
	- if ( isubl == 6 )
	+ if ( m_isubl == 6 )
	answer = t1 + myBIK;

	return answer;
	@@ -741,20 +745,20 @@

	double EvtVubBLNP::u( double w )
	{
	- double u1 = -2 * ( Lbar - w ) * Shat( w, gvars );
	- double myf = myfunction( w, Lbar, moment2 );
	- double myBIK = myfunctionBIK( w, Lbar, moment2 );
	+ double u1 = -2 * ( m_Lbar - w ) * Shat( w, m_gvars );
	+ double myf = myfunction( w, m_Lbar, m_moment2 );
	+ double myBIK = myfunctionBIK( w, m_Lbar, m_moment2 );
	double answer = u1;

	- if ( isubl == 1 )
	+ if ( m_isubl == 1 )
	answer = u1;
	- if ( isubl == 3 )
	+ if ( m_isubl == 3 )
	answer = u1 + myf;
	- if ( isubl == 4 )
	+ if ( m_isubl == 4 )
	answer = u1 - myf;
	- if ( isubl == 5 )
	+ if ( m_isubl == 5 )
	answer = u1 + myBIK;
	- if ( isubl == 6 )
	+ if ( m_isubl == 6 )
	answer = u1 - myBIK;

	return answer;
	@@ -762,20 +766,20 @@

	double EvtVubBLNP::v( double w )
	{
	- double v1 = 3 * lambda2 / mupisq * ( Lbar - w ) * Shat( w, gvars );
	- double myf = myfunction( w, Lbar, moment2 );
	- double myBIK = myfunctionBIK( w, Lbar, moment2 );
	+ double v1 = 3 * m_lambda2 / m_mupisq * ( m_Lbar - w ) * Shat( w, m_gvars );
	+ double myf = myfunction( w, m_Lbar, m_moment2 );
	+ double myBIK = myfunctionBIK( w, m_Lbar, m_moment2 );
	double answer = v1;

	- if ( isubl == 1 )
	+ if ( m_isubl == 1 )
	answer = v1;
	- if ( isubl == 3 )
	+ if ( m_isubl == 3 )
	answer = v1 - myf;
	- if ( isubl == 4 )
	+ if ( m_isubl == 4 )
	answer = v1 + myf;
	- if ( isubl == 5 )
	+ if ( m_isubl == 5 )
	answer = v1 - myBIK;
	- if ( isubl == 6 )
	+ if ( m_isubl == 6 )
	answer = v1 + myBIK;

	return answer;
	@@ -807,30 +811,30 @@

	double EvtVubBLNP::dU1nlo( double muh, double mui )
	{
	- double ai = alphas( mui, gvars );
	- double ah = alphas( muh, gvars );
	-
	- double q1 = ( ah - ai ) / ( 4 * M_PI * beta0 );
	- double q2 = log( mb / muh ) * Gamma1 + gp1;
	- double q3 = 4 * beta1 * ( log( mb / muh ) * Gamma0 + gp0 ) +
	- Gamma2 * ( 1 - ai / ah );
	- double q4 = beta1 * beta1 * Gamma0 * ( -1.0 + ai / ah ) /
	- ( 4 * pow( beta0, 3 ) );
	- double q5 = -beta2 * Gamma0 * ( 1.0 + ai / ah ) +
	- beta1 * Gamma1 * ( 3 - ai / ah );
	- double q6 = beta1 * beta1 * Gamma0 * ( ah - ai ) / beta0 -
	- beta2 * Gamma0 * ah + beta1 * Gamma1 * ai;
	+ double ai = alphas( mui, m_gvars );
	+ double ah = alphas( muh, m_gvars );
	+
	+ double q1 = ( ah - ai ) / ( 4 * M_PI * m_beta0 );
	+ double q2 = log( m_mb / muh ) * m_Gamma1 + m_gp1;
	+ double q3 = 4 * m_beta1 * ( log( m_mb / muh ) * m_Gamma0 + m_gp0 ) +
	+ m_Gamma2 * ( 1 - ai / ah );
	+ double q4 = m_beta1 * m_beta1 * m_Gamma0 * ( -1.0 + ai / ah ) /
	+ ( 4 * pow( m_beta0, 3 ) );
	+ double q5 = -m_beta2 * m_Gamma0 * ( 1.0 + ai / ah ) +
	+ m_beta1 * m_Gamma1 * ( 3 - ai / ah );
	+ double q6 = m_beta1 * m_beta1 * m_Gamma0 * ( ah - ai ) / m_beta0 -
	+ m_beta2 * m_Gamma0 * ah + m_beta1 * m_Gamma1 * ai;

	double answer =
	- q1 * ( q2 - q3 / 4 / beta0 + q4 + q5 / ( 4 * beta0 * beta0 ) ) +
	- 1 / ( 8 * M_PI * beta0 * beta0 * beta0 ) * log( ai / ah ) * q6;
	+ q1 * ( q2 - q3 / 4 / m_beta0 + q4 + q5 / ( 4 * m_beta0 * m_beta0 ) ) +
	+ 1 / ( 8 * M_PI * m_beta0 * m_beta0 * m_beta0 ) * log( ai / ah ) * q6;
	return answer;
	}

	double EvtVubBLNP::U1lo( double muh, double mui )
	{
	double epsilon = 0.0;
	- double answer = pow( mb / muh, -2 * aGamma( muh, mui, epsilon ) ) *
	+ double answer = pow( m_mb / muh, -2 * aGamma( muh, mui, epsilon ) ) *
	exp( 2 * Sfun( muh, mui, epsilon ) -
	2 * agp( muh, mui, epsilon ) );
	return answer;
	@@ -838,8 +842,8 @@

	double EvtVubBLNP::Sfun( double mu1, double mu2, double epsilon )
	{
	- double a1 = alphas( mu1, gvars ) / 4 / M_PI;
	- double a2 = alphas( mu2, gvars ) / alphas( mu1, gvars );
	+ double a1 = alphas( mu1, m_gvars ) / 4 / M_PI;
	+ double a2 = alphas( mu2, m_gvars ) / alphas( mu1, m_gvars );

	double answer = S0( a1, a2 ) + S1( a1, a2 ) + epsilon * S2( a1, a2 );
	return answer;
	@@ -847,26 +851,27 @@

	double EvtVubBLNP::S0( double a1, double r )
	{
	- double answer = -Gamma0 / ( 4.0 * beta0 * beta0 * a1 ) *
	+ double answer = -m_Gamma0 / ( 4.0 * m_beta0 * m_beta0 * a1 ) *
	( -1.0 + 1.0 / r + log( r ) );
	return answer;
	}

	double EvtVubBLNP::S1( double /a1/, double r )
	{
	- double answer = Gamma0 / ( 4 * beta0 * beta0 ) *
	- ( 0.5 * log( r ) * log( r ) * beta1 / beta0 +
	- ( Gamma1 / Gamma0 - beta1 / beta0 ) * ( 1 - r + log( r ) ) );
	+ double answer = m_Gamma0 / ( 4 * m_beta0 * m_beta0 ) *
	+ ( 0.5 * log( r ) * log( r ) * m_beta1 / m_beta0 +
	+ ( m_Gamma1 / m_Gamma0 - m_beta1 / m_beta0 ) *
	+ ( 1 - r + log( r ) ) );
	return answer;
	}

	double EvtVubBLNP::S2( double a1, double r )
	{
	- double w1 = pow( beta1, 2 ) / pow( beta0, 2 ) - beta2 / beta0 -
	- beta1 * Gamma1 / ( beta0 * Gamma0 ) + Gamma2 / Gamma0;
	- double w2 = pow( beta1, 2 ) / pow( beta0, 2 ) - beta2 / beta0;
	- double w3 = beta1 * Gamma1 / ( beta0 * Gamma0 ) - beta2 / beta0;
	- double w4 = a1 * Gamma0 / ( 4 * beta0 * beta0 );
	+ double w1 = pow( m_beta1, 2 ) / pow( m_beta0, 2 ) - m_beta2 / m_beta0 -
	+ m_beta1 * m_Gamma1 / ( m_beta0 * m_Gamma0 ) + m_Gamma2 / m_Gamma0;
	+ double w2 = pow( m_beta1, 2 ) / pow( m_beta0, 2 ) - m_beta2 / m_beta0;
	+ double w3 = m_beta1 * m_Gamma1 / ( m_beta0 * m_Gamma0 ) - m_beta2 / m_beta0;
	+ double w4 = a1 * m_Gamma0 / ( 4 * m_beta0 * m_beta0 );

	double answer = w4 *
	( -0.5 * pow( 1 - r, 2 ) * w1 + w2 * ( 1 - r ) * log( r ) +
	@@ -876,21 +881,23 @@

	double EvtVubBLNP::aGamma( double mu1, double mu2, double epsilon )
	{
	- double a1 = alphas( mu1, gvars );
	- double a2 = alphas( mu2, gvars );
	- double answer = Gamma0 / ( 2 * beta0 ) * log( a2 / a1 ) +
	+ double a1 = alphas( mu1, m_gvars );
	+ double a2 = alphas( mu2, m_gvars );
	+ double answer = m_Gamma0 / ( 2 * m_beta0 ) * log( a2 / a1 ) +
	epsilon * ( a2 - a1 ) / ( 8.0 * M_PI ) *
	- ( Gamma1 / beta0 - beta1 * Gamma0 / ( beta0 * beta0 ) );
	+ ( m_Gamma1 / m_beta0 -
	+ m_beta1 * m_Gamma0 / ( m_beta0 * m_beta0 ) );
	return answer;
	}

	double EvtVubBLNP::agp( double mu1, double mu2, double epsilon )
	{
	- double a1 = alphas( mu1, gvars );
	- double a2 = alphas( mu2, gvars );
	- double answer = gp0 / ( 2 * beta0 ) * log( a2 / a1 ) +
	+ double a1 = alphas( mu1, m_gvars );
	+ double a2 = alphas( mu2, m_gvars );
	+ double answer = m_gp0 / ( 2 * m_beta0 ) * log( a2 / a1 ) +
	epsilon * ( a2 - a1 ) / ( 8.0 * M_PI ) *
	- ( gp1 / beta0 - beta1 * gp0 / ( beta0 * beta0 ) );
	+ ( m_gp1 / m_beta0 -
	+ m_beta1 * m_gp0 / ( m_beta0 * m_beta0 ) );
	return answer;
	}

	@@ -902,10 +909,11 @@
	double EvtVubBLNP::anlo( double muh, double mui )
	{ // d/depsilon of aGamma

	- double ah = alphas( muh, gvars );
	- double ai = alphas( mui, gvars );
	+ double ah = alphas( muh, m_gvars );
	+ double ai = alphas( mui, m_gvars );
	double answer = ( ah - ai ) / ( 8.0 * M_PI ) *
	- ( Gamma1 / beta0 - beta1 * Gamma0 / ( beta0 * beta0 ) );
	+ ( m_Gamma1 / m_beta0 -
	+ m_beta1 * m_Gamma0 / ( m_beta0 * m_beta0 ) );
	return answer;
	}

	@@ -1021,21 +1029,21 @@
	double EvtVubBLNP::findBLNPWhat()
	{
	double ranNum = EvtRandom::Flat();
	- double oOverBins = 1.0 / ( float( _pf.size() ) );
	+ double oOverBins = 1.0 / ( float( m_pf.size() ) );
	int nBinsBelow = 0; // largest k such that I[k] is known to be <= rand
	- int nBinsAbove = _pf.size(); // largest k such that I[k] is known to be > rand
	+ int nBinsAbove = m_pf.size(); // largest k such that I[k] is known to be > rand
	int middle;

	while ( nBinsAbove > nBinsBelow + 1 ) {
	middle = ( nBinsAbove + nBinsBelow + 1 ) >> 1;
	- if ( ranNum >= _pf[middle] ) {
	+ if ( ranNum >= m_pf[middle] ) {
	nBinsBelow = middle;
	} else {
	nBinsAbove = middle;
	}
	}

	- double bSize = _pf[nBinsAbove] - _pf[nBinsBelow];
	+ double bSize = m_pf[nBinsAbove] - m_pf[nBinsBelow];
	// binMeasure is always aProbFunc[nBinsBelow],

	if ( bSize == 0 ) {
	@@ -1045,7 +1053,7 @@
	return ( nBinsBelow + .5 ) * oOverBins;
	}

	- double bFract = ( ranNum - _pf[nBinsBelow] ) / bSize;
	+ double bFract = ( ranNum - m_pf[nBinsBelow] ) / bSize;

	return ( nBinsBelow + bFract ) * oOverBins;
	}
	diff --git a/src/EvtGenModels/EvtVubBLNPHybrid.cpp b/src/EvtGenModels/EvtVubBLNPHybrid.cpp
	--- a/src/EvtGenModels/EvtVubBLNPHybrid.cpp
	+++ b/src/EvtGenModels/EvtVubBLNPHybrid.cpp
	@@ -69,7 +69,7 @@
	EvtGenReport( EVTGEN_WARNING, "EvtVubBLNPHybrid" )
	<< "EvtVubBLNPHybrid: generate B -> Xu l nu events "
	<< "without using the hybrid reweighting." << endl;
	- _noHybrid = true;
	+ m_noHybrid = true;
	} else if ( getNArg() <
	EvtVubBLNPHybrid::nParameters + EvtVubBLNPHybrid::nVariables ) {
	EvtGenReport( EVTGEN_ERROR, "EvtVubBLNPHybrid" )
	@@ -82,141 +82,143 @@
	// get parameters (declared in the header file)

	// Input parameters
	- mBB = 5.2792;
	- lambda2 = 0.12;
	+ m_mBB = 5.2792;
	+ m_lambda2 = 0.12;

	// Shape function parameters
	- b = getArg( 0 );
	- Lambda = getArg( 1 );
	- Ecut = 1.8;
	- wzero = mBB - 2 * Ecut;
	+ m_b = getArg( 0 );
	+ m_Lambda = getArg( 1 );
	+ m_Ecut = 1.8;
	+ m_wzero = m_mBB - 2 * m_Ecut;

	// SF and SSF modes
	- itype = (int)getArg( 5 );
	- dtype = getArg( 5 );
	- isubl = (int)getArg( 6 );
	+ m_itype = (int)getArg( 5 );
	+ m_dtype = getArg( 5 );
	+ m_isubl = (int)getArg( 6 );

	// flags
	- flag1 = (int)getArg( 7 );
	- flag2 = (int)getArg( 8 );
	- flag3 = (int)getArg( 9 );
	+ m_flag1 = (int)getArg( 7 );
	+ m_flag2 = (int)getArg( 8 );
	+ m_flag3 = (int)getArg( 9 );

	// Quark mass
	- mb = 4.61;
	+ m_mb = 4.61;

	// hidden parameter what and SF stuff
	const double xlow = 0;
	- const double xhigh = mBB;
	+ const double xhigh = m_mBB;
	const int aSize = 10000;
	- EvtPFermi pFermi( Lambda, b );
	+ EvtPFermi pFermi( m_Lambda, m_b );
	// pf is the cumulative distribution normalized to 1.
	- _pf.resize( aSize );
	+ m_pf.resize( aSize );
	for ( int i = 0; i < aSize; i++ ) {
	double what = xlow + (double)( i + 0.5 ) / ( (double)aSize ) *
	( xhigh - xlow );
	if ( i == 0 )
	- _pf[i] = pFermi.getSFBLNP( what );
	+ m_pf[i] = pFermi.getSFBLNP( what );
	else
	- _pf[i] = _pf[i - 1] + pFermi.getSFBLNP( what );
	+ m_pf[i] = m_pf[i - 1] + pFermi.getSFBLNP( what );
	}
	- for ( size_t i = 0; i < _pf.size(); i++ ) {
	- _pf[i] /= _pf[_pf.size() - 1];
	+ for ( size_t i = 0; i < m_pf.size(); i++ ) {
	+ m_pf[i] /= m_pf[m_pf.size() - 1];
	}

	// Matching scales
	- muh = mBB * getArg( 2 ); // 0.5
	- mui = getArg( 3 ); // 1.5
	- mubar = getArg( 4 ); // 1.5
	+ m_muh = m_mBB * getArg( 2 ); // 0.5
	+ m_mui = getArg( 3 ); // 1.5
	+ m_mubar = getArg( 4 ); // 1.5

	// Perturbative quantities
	- CF = 4.0 / 3.0;
	- CA = 3.0;
	+ m_CF = 4.0 / 3.0;
	+ m_CA = 3.0;
	double nf = 4.0;

	- beta0 = 11.0 / 3.0 * CA - 2.0 / 3.0 * nf;
	- beta1 = 34.0 / 3.0 * CA * CA - 10.0 / 3.0 * CA * nf - 2.0 * CF * nf;
	- beta2 = 2857.0 / 54.0 * CA * CA * CA +
	- ( CF * CF - 205.0 / 18.0 * CF * CA - 1415.0 / 54.0 * CA * CA ) * nf +
	- ( 11.0 / 9.0 * CF + 79.0 / 54.0 * CA ) * nf * nf;
	-
	- zeta3 = 1.0 + 1 / 8.0 + 1 / 27.0 + 1 / 64.0;
	-
	- Gamma0 = 4 * CF;
	- Gamma1 = CF * ( ( 268.0 / 9.0 - 4.0 * M_PI * M_PI / 3.0 ) * CA -
	- 40.0 / 9.0 * nf );
	- Gamma2 = 16 * CF *
	- ( ( 245.0 / 24.0 - 67.0 / 54.0 * M_PI * M_PI +
	- +11.0 / 180.0 * pow( M_PI, 4 ) + 11.0 / 6.0 * zeta3 ) *
	- CA * CA *
	- +( -209.0 / 108.0 + 5.0 / 27.0 * M_PI * M_PI -
	- 7.0 / 3.0 * zeta3 ) *
	- CA * nf +
	- ( -55.0 / 24.0 + 2 * zeta3 ) * CF * nf - nf * nf / 27.0 );
	-
	- gp0 = -5.0 * CF;
	- gp1 = -8.0 * CF *
	- ( ( 3.0 / 16.0 - M_PI * M_PI / 4.0 + 3 * zeta3 ) * CF +
	- ( 1549.0 / 432.0 + 7.0 / 48.0 * M_PI * M_PI - 11.0 / 4.0 * zeta3 ) *
	- CA -
	- ( 125.0 / 216.0 + M_PI * M_PI / 24.0 ) * nf );
	-
	- // Lbar and mupisq
	-
	- Lbar = Lambda; // all models
	- mupisq = 3 * Lambda * Lambda / b;
	- if ( itype == 1 )
	- mupisq = 3 * Lambda * Lambda / b;
	- if ( itype == 2 )
	- mupisq = 3 * Lambda * Lambda *
	- ( Gamma( 1 + 0.5 * b ) * Gamma( 0.5 * b ) /
	- pow( Gamma( 0.5 + 0.5 * b ), 2 ) -
	- 1 );
	-
	- // moment2 for SSFs
	- moment2 = pow( 0.3, 3 );
	+ m_beta0 = 11.0 / 3.0 * m_CA - 2.0 / 3.0 * nf;
	+ m_beta1 = 34.0 / 3.0 * m_CA * m_CA - 10.0 / 3.0 * m_CA * nf - 2.0 * m_CF * nf;
	+ m_beta2 = 2857.0 / 54.0 * m_CA * m_CA * m_CA +
	+ ( m_CF * m_CF - 205.0 / 18.0 * m_CF * m_CA -
	+ 1415.0 / 54.0 * m_CA * m_CA ) *
	+ nf +
	+ ( 11.0 / 9.0 * m_CF + 79.0 / 54.0 * m_CA ) * nf * nf;
	+
	+ m_zeta3 = 1.0 + 1 / 8.0 + 1 / 27.0 + 1 / 64.0;
	+
	+ m_Gamma0 = 4 * m_CF;
	+ m_Gamma1 = m_CF * ( ( 268.0 / 9.0 - 4.0 * M_PI * M_PI / 3.0 ) * m_CA -
	+ 40.0 / 9.0 * nf );
	+ m_Gamma2 = 16 * m_CF *
	+ ( ( 245.0 / 24.0 - 67.0 / 54.0 * M_PI * M_PI +
	+ +11.0 / 180.0 * pow( M_PI, 4 ) + 11.0 / 6.0 * m_zeta3 ) *
	+ m_CA * m_CA *
	+ +( -209.0 / 108.0 + 5.0 / 27.0 * M_PI * M_PI -
	+ 7.0 / 3.0 * m_zeta3 ) *
	+ m_CA * nf +
	+ ( -55.0 / 24.0 + 2 * m_zeta3 ) * m_CF * nf - nf * nf / 27.0 );
	+
	+ m_gp0 = -5.0 * m_CF;
	+ m_gp1 = -8.0 * m_CF *
	+ ( ( 3.0 / 16.0 - M_PI * M_PI / 4.0 + 3 * m_zeta3 ) * m_CF +
	+ ( 1549.0 / 432.0 + 7.0 / 48.0 * M_PI * M_PI - 11.0 / 4.0 * m_zeta3 ) *
	+ m_CA -
	+ ( 125.0 / 216.0 + M_PI * M_PI / 24.0 ) * nf );
	+
	+ // Lbar and m_mupisq
	+
	+ m_Lbar = m_Lambda; // all models
	+ m_mupisq = 3 * m_Lambda * m_Lambda / m_b;
	+ if ( m_itype == 1 )
	+ m_mupisq = 3 * m_Lambda * m_Lambda / m_b;
	+ if ( m_itype == 2 )
	+ m_mupisq = 3 * m_Lambda * m_Lambda *
	+ ( Gamma( 1 + 0.5 * m_b ) * Gamma( 0.5 * m_b ) /
	+ pow( Gamma( 0.5 + 0.5 * m_b ), 2 ) -
	+ 1 );
	+
	+ // m_moment2 for SSFs
	+ m_moment2 = pow( 0.3, 3 );

	// inputs for total rate (T for Total); use BLNP notebook defaults
	- flagpower = 1;
	- flag2loop = 1;
	+ m_flagpower = 1;
	+ m_flag2loop = 1;

	// stuff for the integrator
	- maxLoop = 20;
	- //precision = 1.0e-3;
	- precision = 2.0e-2;
	+ m_maxLoop = 20;
	+ //m_precision = 1.0e-3;
	+ m_precision = 2.0e-2;

	// vector of global variables, to pass to static functions (which can't access globals);
	- gvars.push_back( 0.0 ); // 0
	- gvars.push_back( 0.0 ); // 1
	- gvars.push_back( mui ); // 2
	- gvars.push_back( b ); // 3
	- gvars.push_back( Lambda ); // 4
	- gvars.push_back( mBB ); // 5
	- gvars.push_back( mb ); // 6
	- gvars.push_back( wzero ); // 7
	- gvars.push_back( beta0 ); // 8
	- gvars.push_back( beta1 ); // 9
	- gvars.push_back( beta2 ); // 10
	- gvars.push_back( dtype ); // 11
	+ m_gvars.push_back( 0.0 ); // 0
	+ m_gvars.push_back( 0.0 ); // 1
	+ m_gvars.push_back( m_mui ); // 2
	+ m_gvars.push_back( m_b ); // 3
	+ m_gvars.push_back( m_Lambda ); // 4
	+ m_gvars.push_back( m_mBB ); // 5
	+ m_gvars.push_back( m_mb ); // 6
	+ m_gvars.push_back( m_wzero ); // 7
	+ m_gvars.push_back( m_beta0 ); // 8
	+ m_gvars.push_back( m_beta1 ); // 9
	+ m_gvars.push_back( m_beta2 ); // 10
	+ m_gvars.push_back( m_dtype ); // 11

	// check that there are 3 daughters and 10 arguments
	checkNDaug( 3 );
	// A. Volk: check for number of arguments is not necessary
	//checkNArg(10);

	- if ( _noHybrid )
	+ if ( m_noHybrid )
	return; // Without hybrid weighting, nothing else to do

	- _bins_mX = std::vector<double>( abs( (int)getArg( 10 ) ) );
	- _bins_q2 = std::vector<double>( abs( (int)getArg( 11 ) ) );
	- _bins_El = std::vector<double>( abs( (int)getArg( 12 ) ) );
	+ m_bins_mX = std::vector<double>( abs( (int)getArg( 10 ) ) );
	+ m_bins_q2 = std::vector<double>( abs( (int)getArg( 11 ) ) );
	+ m_bins_El = std::vector<double>( abs( (int)getArg( 12 ) ) );

	int nextArg = EvtVubBLNPHybrid::nParameters + EvtVubBLNPHybrid::nVariables;

	- _nbins = _bins_mX.size() * _bins_q2.size() *
	- _bins_El.size(); // Binning of weight table
	+ m_nbins = m_bins_mX.size() * m_bins_q2.size() *
	+ m_bins_El.size(); // Binning of weight table

	- int expectArgs = nextArg + _bins_mX.size() + _bins_q2.size() +
	- _bins_El.size() + _nbins;
	+ int expectArgs = nextArg + m_bins_mX.size() + m_bins_q2.size() +
	+ m_bins_El.size() + m_nbins;

	if ( getNArg() < expectArgs ) {
	EvtGenReport( EVTGEN_ERROR, "EvtVubBLNPHybrid" )
	@@ -227,12 +229,12 @@
	}

	// read bin boundaries from decay.dec
	- for ( auto& b : _bins_mX )
	+ for ( auto& b : m_bins_mX )
	b = getArg( nextArg++ );
	- _masscut = _bins_mX[0];
	- for ( auto& b : _bins_q2 )
	+ m_masscut = m_bins_mX[0];
	+ for ( auto& b : m_bins_q2 )
	b = getArg( nextArg++ );
	- for ( auto& b : _bins_El )
	+ for ( auto& b : m_bins_El )
	b = getArg( nextArg++ );

	// read in weights (and rescale to range 0..1)
	@@ -264,12 +266,12 @@
	lepton = Bmeson->getDaug( 1 );
	neutrino = Bmeson->getDaug( 2 );

	- mBB = Bmeson->mass();
	+ m_mBB = Bmeson->mass();
	ml = lepton->mass();

	// get SF value
	xlow = 0;
	- xhigh = mBB;
	+ xhigh = m_mBB;
	// the case for alphas = 0 is not considered
	what = 2 * xhigh;
	while ( what > xhigh \|\| what < xlow ) {
	@@ -283,14 +285,14 @@
	// generate pp between 0 and
	// Flat(min, max) gives R(max - min) + min, where R = random btwn 0 and 1

	- Pp = EvtRandom::Flat( 0, mBB ); // P+ = EX - \|PX\|
	- Pl = EvtRandom::Flat( 0, mBB ); // mBB - 2El
	- Pm = EvtRandom::Flat( 0, mBB ); // P- = EX + \|PX\|
	+ Pp = EvtRandom::Flat( 0, m_mBB ); // P+ = EX - \|PX\|
	+ Pl = EvtRandom::Flat( 0, m_mBB ); // mBB - 2El
	+ Pm = EvtRandom::Flat( 0, m_mBB ); // P- = EX + \|PX\|

	sh = Pm * Pp;
	EX = 0.5 * ( Pm + Pp );
	- qsq = ( mBB - Pp ) * ( mBB - Pm );
	- El = 0.5 * ( mBB - Pl );
	+ qsq = ( m_mBB - Pp ) * ( m_mBB - Pm );
	+ El = 0.5 * ( m_mBB - Pl );

	// Need maximum rate. Waiting for Mr. Paz to give it to me.
	// Meanwhile, use this.
	@@ -298,7 +300,7 @@

	// kinematic bounds (Eq. 2)
	mpi = 0.14;
	- if ( ( Pp > 0 ) && ( Pp <= Pl ) && ( Pl <= Pm ) && ( Pm < mBB ) &&
	+ if ( ( Pp > 0 ) && ( Pp <= Pl ) && ( Pl <= Pm ) && ( Pm < m_mBB ) &&
	( El > ml ) && ( sh > 4 * mpi * mpi ) ) {
	// Probability of pass proportional to PDF
	pdf = rate3( Pp, Pl, Pm );
	@@ -312,10 +314,10 @@
	mX = sqrt( sh );

	// Reweighting in bins of mX, q2, El
	- if ( _nbins > 0 ) {
	+ if ( m_nbins > 0 ) {
	double xran1 = EvtRandom::Flat();
	double w = 1.0;
	- if ( !_noHybrid )
	+ if ( !m_noHybrid )
	w = getWeight( mX, qsq, El );
	if ( w >= xran1 )
	rew = false;
	@@ -347,7 +349,7 @@
	p4.set( pHB[0], pHB[1], pHB[2], pHB[3] );
	xuhad->init( getDaug( 0 ), p4 );

	- if ( _storeWhat ) {
	+ if ( m_storeWhat ) {
	// cludge to store the hidden parameter what with the decay;
	// the lifetime of the Xu is abused for this purpose.
	// tau = 1 ps corresponds to ctau = 0.3 mm -> in order to
	@@ -363,12 +365,12 @@
	// calculate the W 4 vector in the B Meson restrframe

	double apWB = ptmp;
	- double pWB[4] = { mBB - EX, -pHB[1], -pHB[2], -pHB[3] };
	+ double pWB[4] = { m_mBB - EX, -pHB[1], -pHB[2], -pHB[3] };

	// first go in the W restframe and calculate the lepton and
	// the neutrino in the W frame

	- double mW2 = mBB * mBB + sh - 2 * mBB * EX;
	+ double mW2 = m_mBB * m_mBB + sh - 2 * m_mBB * EX;
	double beta = ptmp / pWB[0];
	double gamma = pWB[0] / sqrt( mW2 );

	@@ -440,13 +442,13 @@
	{
	// rate3 in units of GF^2*Vub^2/pi^3

	- double factor = 1.0 / 16 * ( mBB - Pp ) * U1lo( muh, mui ) *
	- pow( ( Pm - Pp ) / ( mBB - Pp ), alo( muh, mui ) );
	+ double factor = 1.0 / 16 * ( m_mBB - Pp ) * U1lo( m_muh, m_mui ) *
	+ pow( ( Pm - Pp ) / ( m_mBB - Pp ), alo( m_muh, m_mui ) );

	- double doneJS = DoneJS( Pp, Pm, mui );
	- double done1 = Done1( Pp, Pm, mui );
	- double done2 = Done2( Pp, Pm, mui );
	- double done3 = Done3( Pp, Pm, mui );
	+ double doneJS = DoneJS( Pp, Pm, m_mui );
	+ double done1 = Done1( Pp, Pm, m_mui );
	+ double done2 = Done2( Pp, Pm, m_mui );
	+ double done3 = Done3( Pp, Pm, m_mui );

	// The EvtSimpsonIntegrator returns zero for bad integrals.
	// So if any of the integrals are zero (ie bad), return zero.
	@@ -460,12 +462,12 @@
	// cout << "Integral OK: (Pp, Pm, Pl) = (" << Pp << ", " << Pm << ", " << Pl << ")" << endl;
	//}

	- double f1 = F1( Pp, Pm, muh, mui, mubar, doneJS, done1 );
	- double f2 = F2( Pp, Pm, muh, mui, mubar, done3 );
	- double f3 = F3( Pp, Pm, muh, mui, mubar, done2 );
	- double answer = factor * ( ( mBB + Pl - Pp - Pm ) * ( Pm - Pl ) * f1 +
	+ double f1 = F1( Pp, Pm, m_muh, m_mui, m_mubar, doneJS, done1 );
	+ double f2 = F2( Pp, Pm, m_muh, m_mui, m_mubar, done3 );
	+ double f3 = F3( Pp, Pm, m_muh, m_mui, m_mubar, done2 );
	+ double answer = factor * ( ( m_mBB + Pl - Pp - Pm ) * ( Pm - Pl ) * f1 +
	2 * ( Pl - Pp ) * ( Pm - Pl ) * f2 +
	- ( mBB - Pm ) * ( Pm - Pp ) * f3 );
	+ ( m_mBB - Pm ) * ( Pm - Pp ) * f3 );
	return answer;
	}

	@@ -476,35 +478,37 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	- double y = ( Pm - Pp ) / ( mBB - Pp );
	- double ah = CF * alphas( muh, vars ) / 4 / M_PI;
	- double ai = CF * alphas( mui, vars ) / 4 / M_PI;
	- double abar = CF * alphas( mubar, vars ) / 4 / M_PI;
	- double lambda1 = -mupisq;
	+ double y = ( Pm - Pp ) / ( m_mBB - Pp );
	+ double ah = m_CF * alphas( muh, vars ) / 4 / M_PI;
	+ double ai = m_CF * alphas( mui, vars ) / 4 / M_PI;
	+ double abar = m_CF * alphas( mubar, vars ) / 4 / M_PI;
	+ double lambda1 = -m_mupisq;

	- double t1 = -4 * ai / ( Pp - Lbar ) * ( 2 * log( ( Pp - Lbar ) / mui ) + 1 );
	+ double t1 = -4 * ai / ( Pp - m_Lbar ) *
	+ ( 2 * log( ( Pp - m_Lbar ) / mui ) + 1 );
	double t2 = 1 + dU1nlo( muh, mui ) + anlo( muh, mui ) * log( y );
	- double t3 = -4.0 * pow( log( y * mb / muh ), 2 ) +
	- 10.0 * log( y * mb / muh ) - 4.0 * log( y ) -
	+ double t3 = -4.0 * pow( log( y * m_mb / muh ), 2 ) +
	+ 10.0 * log( y * m_mb / muh ) - 4.0 * log( y ) -
	2.0 * log( y ) / ( 1 - y ) - 4.0 * PolyLog( 2, 1 - y ) -
	M_PI * M_PI / 6.0 - 12.0;
	- double t4 = 2 * pow( log( y * mb * Pp / ( mui * mui ) ), 2 ) -
	- 3 * log( y * mb * Pp / ( mui * mui ) ) + 7 - M_PI * M_PI;
	+ double t4 = 2 * pow( log( y * m_mb * Pp / ( mui * mui ) ), 2 ) -
	+ 3 * log( y * m_mb * Pp / ( mui * mui ) ) + 7 - M_PI * M_PI;

	double t5 = -wS( Pp ) + 2 * t( Pp ) +
	( 1.0 / y - 1.0 ) * ( u( Pp ) - v( Pp ) );
	- double t6 = -( lambda1 + 3.0 * lambda2 ) / 3.0 +
	- 1.0 / pow( y, 2 ) * ( 4.0 / 3.0 * lambda1 - 2.0 * lambda2 );
	+ double t6 = -( lambda1 + 3.0 * m_lambda2 ) / 3.0 +
	+ 1.0 / pow( y, 2 ) * ( 4.0 / 3.0 * lambda1 - 2.0 * m_lambda2 );

	double shapePp = Shat( Pp, vars );

	double answer = ( t2 + ah * t3 + ai * t4 ) * shapePp + ai * doneJS +
	- 1 / ( mBB - Pp ) * ( flag2 * abar * done1 + flag1 * t5 ) +
	- 1 / pow( mBB - Pp, 2 ) * flag3 * shapePp * t6;
	- if ( Pp > Lbar + mui / exp( 0.5 ) )
	+ 1 / ( m_mBB - Pp ) *
	+ ( m_flag2 * abar * done1 + m_flag1 * t5 ) +
	+ 1 / pow( m_mBB - Pp, 2 ) * m_flag3 * shapePp * t6;
	+ if ( Pp > m_Lbar + mui / exp( 0.5 ) )
	answer = answer + t1;
	return answer;
	}
	@@ -516,24 +520,24 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	- double y = ( Pm - Pp ) / ( mBB - Pp );
	- double lambda1 = -mupisq;
	- double ah = CF * alphas( muh, vars ) / 4 / M_PI;
	- double abar = CF * alphas( mubar, vars ) / 4 / M_PI;
	+ double y = ( Pm - Pp ) / ( m_mBB - Pp );
	+ double lambda1 = -m_mupisq;
	+ double ah = m_CF * alphas( muh, vars ) / 4 / M_PI;
	+ double abar = m_CF * alphas( mubar, vars ) / 4 / M_PI;

	double t6 = -wS( Pp ) - 2 * t( Pp ) + 1.0 / y * ( t( Pp ) + v( Pp ) );
	- double t7 = 1 / pow( y, 2 ) * ( 2.0 / 3.0 * lambda1 + 4.0 * lambda2 ) -
	- 1 / y * ( 2.0 / 3.0 * lambda1 + 3.0 / 2.0 * lambda2 );
	+ double t7 = 1 / pow( y, 2 ) * ( 2.0 / 3.0 * lambda1 + 4.0 * m_lambda2 ) -
	+ 1 / y * ( 2.0 / 3.0 * lambda1 + 3.0 / 2.0 * m_lambda2 );

	double shapePp = Shat( Pp, vars );

	double answer = ah * log( y ) / ( 1 - y ) * shapePp +
	- 1 / ( mBB - Pp ) *
	- ( flag2 * abar * 0.5 * done3 + flag1 / y * t6 ) +
	- 1.0 / pow( mBB - Pp, 2 ) * flag3 * shapePp * t7;
	+ 1 / ( m_mBB - Pp ) *
	+ ( m_flag2 * abar * 0.5 * done3 + m_flag1 / y * t6 ) +
	+ 1.0 / pow( m_mBB - Pp, 2 ) * m_flag3 * shapePp * t7;
	return answer;
	}

	@@ -544,19 +548,19 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	- double y = ( Pm - Pp ) / ( mBB - Pp );
	- double lambda1 = -mupisq;
	- double abar = CF * alphas( mubar, vars ) / 4 / M_PI;
	+ double y = ( Pm - Pp ) / ( m_mBB - Pp );
	+ double lambda1 = -m_mupisq;
	+ double abar = m_CF * alphas( mubar, vars ) / 4 / M_PI;

	- double t7 = 1.0 / pow( y, 2 ) * ( -2.0 / 3.0 * lambda1 + lambda2 );
	+ double t7 = 1.0 / pow( y, 2 ) * ( -2.0 / 3.0 * lambda1 + m_lambda2 );

	double shapePp = Shat( Pp, vars );

	- double answer = 1.0 / ( Pm - Pp ) * flag2 * 0.5 * y * abar * done2 +
	- 1.0 / pow( mBB - Pp, 2 ) * flag3 * shapePp * t7;
	+ double answer = 1.0 / ( Pm - Pp ) * m_flag2 * 0.5 * y * abar * done2 +
	+ 1.0 / pow( m_mBB - Pp, 2 ) * m_flag3 * shapePp * t7;
	return answer;
	}

	@@ -566,14 +570,14 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	double lowerlim = 0.001 * Pp;
	double upperlim = ( 1.0 - 0.001 ) * Pp;

	auto func = EvtItgPtrFunction{ &IntJS, lowerlim, upperlim, vars };
	- auto integ = EvtItgSimpsonIntegrator{ func, precision, maxLoop };
	+ auto integ = EvtItgSimpsonIntegrator{ func, m_precision, m_maxLoop };
	return integ.evaluate( lowerlim, upperlim );
	}

	@@ -583,14 +587,14 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	double lowerlim = 0.001 * Pp;
	double upperlim = ( 1.0 - 0.001 ) * Pp;

	auto func = EvtItgPtrFunction{ &Int1, lowerlim, upperlim, vars };
	- auto integ = EvtItgSimpsonIntegrator{ func, precision, maxLoop };
	+ auto integ = EvtItgSimpsonIntegrator{ func, m_precision, m_maxLoop };
	return integ.evaluate( lowerlim, upperlim );
	}

	@@ -600,14 +604,14 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	double lowerlim = 0.001 * Pp;
	double upperlim = ( 1.0 - 0.001 ) * Pp;

	auto func = EvtItgPtrFunction{ &Int2, lowerlim, upperlim, vars };
	- auto integ = EvtItgSimpsonIntegrator{ func, precision, maxLoop };
	+ auto integ = EvtItgSimpsonIntegrator{ func, m_precision, m_maxLoop };
	return integ.evaluate( lowerlim, upperlim );
	}

	@@ -617,14 +621,14 @@
	vars[0] = Pp;
	vars[1] = Pm;
	for ( int j = 2; j < 12; j++ ) {
	- vars[j] = gvars[j];
	+ vars[j] = m_gvars[j];
	}

	double lowerlim = 0.001 * Pp;
	double upperlim = ( 1.0 - 0.001 ) * Pp;

	auto func = EvtItgPtrFunction{ &Int3, lowerlim, upperlim, vars };
	- auto integ = EvtItgSimpsonIntegrator{ func, precision, maxLoop };
	+ auto integ = EvtItgSimpsonIntegrator{ func, m_precision, m_maxLoop };
	return integ.evaluate( lowerlim, upperlim );
	}

	@@ -788,26 +792,26 @@

	double EvtVubBLNPHybrid::wS( double w )
	{
	- double answer = ( Lbar - w ) * Shat( w, gvars );
	+ double answer = ( m_Lbar - w ) * Shat( w, m_gvars );
	return answer;
	}

	double EvtVubBLNPHybrid::t( double w )
	{
	- double t1 = -3 * lambda2 / mupisq * ( Lbar - w ) * Shat( w, gvars );
	- double myf = myfunction( w, Lbar, moment2 );
	- double myBIK = myfunctionBIK( w, Lbar, moment2 );
	+ double t1 = -3 * m_lambda2 / m_mupisq * ( m_Lbar - w ) * Shat( w, m_gvars );
	+ double myf = myfunction( w, m_Lbar, m_moment2 );
	+ double myBIK = myfunctionBIK( w, m_Lbar, m_moment2 );
	double answer = t1;

	- if ( isubl == 1 )
	+ if ( m_isubl == 1 )
	answer = t1;
	- if ( isubl == 3 )
	+ if ( m_isubl == 3 )
	answer = t1 - myf;
	- if ( isubl == 4 )
	+ if ( m_isubl == 4 )
	answer = t1 + myf;
	- if ( isubl == 5 )
	+ if ( m_isubl == 5 )
	answer = t1 - myBIK;
	- if ( isubl == 6 )
	+ if ( m_isubl == 6 )
	answer = t1 + myBIK;

	return answer;
	@@ -815,20 +819,20 @@

	double EvtVubBLNPHybrid::u( double w )
	{
	- double u1 = -2 * ( Lbar - w ) * Shat( w, gvars );
	- double myf = myfunction( w, Lbar, moment2 );
	- double myBIK = myfunctionBIK( w, Lbar, moment2 );
	+ double u1 = -2 * ( m_Lbar - w ) * Shat( w, m_gvars );
	+ double myf = myfunction( w, m_Lbar, m_moment2 );
	+ double myBIK = myfunctionBIK( w, m_Lbar, m_moment2 );
	double answer = u1;

	- if ( isubl == 1 )
	+ if ( m_isubl == 1 )
	answer = u1;
	- if ( isubl == 3 )
	+ if ( m_isubl == 3 )
	answer = u1 + myf;
	- if ( isubl == 4 )
	+ if ( m_isubl == 4 )
	answer = u1 - myf;
	- if ( isubl == 5 )
	+ if ( m_isubl == 5 )
	answer = u1 + myBIK;
	- if ( isubl == 6 )
	+ if ( m_isubl == 6 )
	answer = u1 - myBIK;

	return answer;
	@@ -836,20 +840,20 @@

	double EvtVubBLNPHybrid::v( double w )
	{
	- double v1 = 3 * lambda2 / mupisq * ( Lbar - w ) * Shat( w, gvars );
	- double myf = myfunction( w, Lbar, moment2 );
	- double myBIK = myfunctionBIK( w, Lbar, moment2 );
	+ double v1 = 3 * m_lambda2 / m_mupisq * ( m_Lbar - w ) * Shat( w, m_gvars );
	+ double myf = myfunction( w, m_Lbar, m_moment2 );
	+ double myBIK = myfunctionBIK( w, m_Lbar, m_moment2 );
	double answer = v1;

	- if ( isubl == 1 )
	+ if ( m_isubl == 1 )
	answer = v1;
	- if ( isubl == 3 )
	+ if ( m_isubl == 3 )
	answer = v1 - myf;
	- if ( isubl == 4 )
	+ if ( m_isubl == 4 )
	answer = v1 + myf;
	- if ( isubl == 5 )
	+ if ( m_isubl == 5 )
	answer = v1 - myBIK;
	- if ( isubl == 6 )
	+ if ( m_isubl == 6 )
	answer = v1 + myBIK;

	return answer;
	@@ -881,30 +885,30 @@

	double EvtVubBLNPHybrid::dU1nlo( double muh, double mui )
	{
	- double ai = alphas( mui, gvars );
	- double ah = alphas( muh, gvars );
	-
	- double q1 = ( ah - ai ) / ( 4 * M_PI * beta0 );
	- double q2 = log( mb / muh ) * Gamma1 + gp1;
	- double q3 = 4 * beta1 * ( log( mb / muh ) * Gamma0 + gp0 ) +
	- Gamma2 * ( 1 - ai / ah );
	- double q4 = beta1 * beta1 * Gamma0 * ( -1.0 + ai / ah ) /
	- ( 4 * pow( beta0, 3 ) );
	- double q5 = -beta2 * Gamma0 * ( 1.0 + ai / ah ) +
	- beta1 * Gamma1 * ( 3 - ai / ah );
	- double q6 = beta1 * beta1 * Gamma0 * ( ah - ai ) / beta0 -
	- beta2 * Gamma0 * ah + beta1 * Gamma1 * ai;
	+ double ai = alphas( mui, m_gvars );
	+ double ah = alphas( muh, m_gvars );
	+
	+ double q1 = ( ah - ai ) / ( 4 * M_PI * m_beta0 );
	+ double q2 = log( m_mb / muh ) * m_Gamma1 + m_gp1;
	+ double q3 = 4 * m_beta1 * ( log( m_mb / muh ) * m_Gamma0 + m_gp0 ) +
	+ m_Gamma2 * ( 1 - ai / ah );
	+ double q4 = m_beta1 * m_beta1 * m_Gamma0 * ( -1.0 + ai / ah ) /
	+ ( 4 * pow( m_beta0, 3 ) );
	+ double q5 = -m_beta2 * m_Gamma0 * ( 1.0 + ai / ah ) +
	+ m_beta1 * m_Gamma1 * ( 3 - ai / ah );
	+ double q6 = m_beta1 * m_beta1 * m_Gamma0 * ( ah - ai ) / m_beta0 -
	+ m_beta2 * m_Gamma0 * ah + m_beta1 * m_Gamma1 * ai;

	double answer =
	- q1 * ( q2 - q3 / 4 / beta0 + q4 + q5 / ( 4 * beta0 * beta0 ) ) +
	- 1 / ( 8 * M_PI * beta0 * beta0 * beta0 ) * log( ai / ah ) * q6;
	+ q1 * ( q2 - q3 / 4 / m_beta0 + q4 + q5 / ( 4 * m_beta0 * m_beta0 ) ) +
	+ 1 / ( 8 * M_PI * m_beta0 * m_beta0 * m_beta0 ) * log( ai / ah ) * q6;
	return answer;
	}

	double EvtVubBLNPHybrid::U1lo( double muh, double mui )
	{
	double epsilon = 0.0;
	- double answer = pow( mb / muh, -2 * aGamma( muh, mui, epsilon ) ) *
	+ double answer = pow( m_mb / muh, -2 * aGamma( muh, mui, epsilon ) ) *
	exp( 2 * Sfun( muh, mui, epsilon ) -
	2 * agp( muh, mui, epsilon ) );
	return answer;
	@@ -912,8 +916,8 @@

	double EvtVubBLNPHybrid::Sfun( double mu1, double mu2, double epsilon )
	{
	- double a1 = alphas( mu1, gvars ) / 4 / M_PI;
	- double a2 = alphas( mu2, gvars ) / alphas( mu1, gvars );
	+ double a1 = alphas( mu1, m_gvars ) / 4 / M_PI;
	+ double a2 = alphas( mu2, m_gvars ) / alphas( mu1, m_gvars );

	double answer = S0( a1, a2 ) + S1( a1, a2 ) + epsilon * S2( a1, a2 );
	return answer;
	@@ -921,26 +925,27 @@

	double EvtVubBLNPHybrid::S0( double a1, double r )
	{
	- double answer = -Gamma0 / ( 4.0 * beta0 * beta0 * a1 ) *
	+ double answer = -m_Gamma0 / ( 4.0 * m_beta0 * m_beta0 * a1 ) *
	( -1.0 + 1.0 / r + log( r ) );
	return answer;
	}

	double EvtVubBLNPHybrid::S1( double /* a1 */, double r )
	{
	- double answer = Gamma0 / ( 4 * beta0 * beta0 ) *
	- ( 0.5 * log( r ) * log( r ) * beta1 / beta0 +
	- ( Gamma1 / Gamma0 - beta1 / beta0 ) * ( 1 - r + log( r ) ) );
	+ double answer = m_Gamma0 / ( 4 * m_beta0 * m_beta0 ) *
	+ ( 0.5 * log( r ) * log( r ) * m_beta1 / m_beta0 +
	+ ( m_Gamma1 / m_Gamma0 - m_beta1 / m_beta0 ) *
	+ ( 1 - r + log( r ) ) );
	return answer;
	}

	double EvtVubBLNPHybrid::S2( double a1, double r )
	{
	- double w1 = pow( beta1, 2 ) / pow( beta0, 2 ) - beta2 / beta0 -
	- beta1 * Gamma1 / ( beta0 * Gamma0 ) + Gamma2 / Gamma0;
	- double w2 = pow( beta1, 2 ) / pow( beta0, 2 ) - beta2 / beta0;
	- double w3 = beta1 * Gamma1 / ( beta0 * Gamma0 ) - beta2 / beta0;
	- double w4 = a1 * Gamma0 / ( 4 * beta0 * beta0 );
	+ double w1 = pow( m_beta1, 2 ) / pow( m_beta0, 2 ) - m_beta2 / m_beta0 -
	+ m_beta1 * m_Gamma1 / ( m_beta0 * m_Gamma0 ) + m_Gamma2 / m_Gamma0;
	+ double w2 = pow( m_beta1, 2 ) / pow( m_beta0, 2 ) - m_beta2 / m_beta0;
	+ double w3 = m_beta1 * m_Gamma1 / ( m_beta0 * m_Gamma0 ) - m_beta2 / m_beta0;
	+ double w4 = a1 * m_Gamma0 / ( 4 * m_beta0 * m_beta0 );

	double answer = w4 *
	( -0.5 * pow( 1 - r, 2 ) * w1 + w2 * ( 1 - r ) * log( r ) +
	@@ -950,21 +955,23 @@

	double EvtVubBLNPHybrid::aGamma( double mu1, double mu2, double epsilon )
	{
	- double a1 = alphas( mu1, gvars );
	- double a2 = alphas( mu2, gvars );
	- double answer = Gamma0 / ( 2 * beta0 ) * log( a2 / a1 ) +
	+ double a1 = alphas( mu1, m_gvars );
	+ double a2 = alphas( mu2, m_gvars );
	+ double answer = m_Gamma0 / ( 2 * m_beta0 ) * log( a2 / a1 ) +
	epsilon * ( a2 - a1 ) / ( 8.0 * M_PI ) *
	- ( Gamma1 / beta0 - beta1 * Gamma0 / ( beta0 * beta0 ) );
	+ ( m_Gamma1 / m_beta0 -
	+ m_beta1 * m_Gamma0 / ( m_beta0 * m_beta0 ) );
	return answer;
	}

	double EvtVubBLNPHybrid::agp( double mu1, double mu2, double epsilon )
	{
	- double a1 = alphas( mu1, gvars );
	- double a2 = alphas( mu2, gvars );
	- double answer = gp0 / ( 2 * beta0 ) * log( a2 / a1 ) +
	+ double a1 = alphas( mu1, m_gvars );
	+ double a2 = alphas( mu2, m_gvars );
	+ double answer = m_gp0 / ( 2 * m_beta0 ) * log( a2 / a1 ) +
	epsilon * ( a2 - a1 ) / ( 8.0 * M_PI ) *
	- ( gp1 / beta0 - beta1 * gp0 / ( beta0 * beta0 ) );
	+ ( m_gp1 / m_beta0 -
	+ m_beta1 * m_gp0 / ( m_beta0 * m_beta0 ) );
	return answer;
	}

	@@ -976,10 +983,11 @@
	double EvtVubBLNPHybrid::anlo( double muh, double mui )
	{ // d/depsilon of aGamma

	- double ah = alphas( muh, gvars );
	- double ai = alphas( mui, gvars );
	+ double ah = alphas( muh, m_gvars );
	+ double ai = alphas( mui, m_gvars );
	double answer = ( ah - ai ) / ( 8.0 * M_PI ) *
	- ( Gamma1 / beta0 - beta1 * Gamma0 / ( beta0 * beta0 ) );
	+ ( m_Gamma1 / m_beta0 -
	+ m_beta1 * m_Gamma0 / ( m_beta0 * m_beta0 ) );
	return answer;
	}

	@@ -1096,21 +1104,21 @@
	double EvtVubBLNPHybrid::findBLNPWhat()
	{
	double ranNum = EvtRandom::Flat();
	- double oOverBins = 1.0 / ( float( _pf.size() ) );
	+ double oOverBins = 1.0 / ( float( m_pf.size() ) );
	int nBinsBelow = 0; // largest k such that I[k] is known to be <= rand
	- int nBinsAbove = _pf.size(); // largest k such that I[k] is known to be > rand
	+ int nBinsAbove = m_pf.size(); // largest k such that I[k] is known to be > rand
	int middle;

	while ( nBinsAbove > nBinsBelow + 1 ) {
	middle = ( nBinsAbove + nBinsBelow + 1 ) >> 1;
	- if ( ranNum >= _pf[middle] ) {
	+ if ( ranNum >= m_pf[middle] ) {
	nBinsBelow = middle;
	} else {
	nBinsAbove = middle;
	}
	}

	- double bSize = _pf[nBinsAbove] - _pf[nBinsBelow];
	+ double bSize = m_pf[nBinsAbove] - m_pf[nBinsBelow];
	// binMeasure is always aProbFunc[nBinsBelow],

	if ( bSize == 0 ) {
	@@ -1120,7 +1128,7 @@
	return ( nBinsBelow + .5 ) * oOverBins;
	}

	- double bFract = ( ranNum - _pf[nBinsBelow] ) / bSize;
	+ double bFract = ( ranNum - m_pf[nBinsBelow] ) / bSize;

	return ( nBinsBelow + bFract ) * oOverBins;
	}
	@@ -1131,20 +1139,20 @@
	int ibin_q2 = -1;
	int ibin_El = -1;

	- for ( unsigned i = 0; i < _bins_mX.size(); i++ ) {
	- if ( mX >= _bins_mX[i] )
	+ for ( unsigned i = 0; i < m_bins_mX.size(); i++ ) {
	+ if ( mX >= m_bins_mX[i] )
	ibin_mX = i;
	}
	- for ( unsigned i = 0; i < _bins_q2.size(); i++ ) {
	- if ( q2 >= _bins_q2[i] )
	+ for ( unsigned i = 0; i < m_bins_q2.size(); i++ ) {
	+ if ( q2 >= m_bins_q2[i] )
	ibin_q2 = i;
	}
	- for ( unsigned i = 0; i < _bins_El.size(); i++ ) {
	- if ( El >= _bins_El[i] )
	+ for ( unsigned i = 0; i < m_bins_El.size(); i++ ) {
	+ if ( El >= m_bins_El[i] )
	ibin_El = i;
	}
	- int ibin = ibin_mX + ibin_q2 * _bins_mX.size() +
	- ibin_El * _bins_mX.size() * _bins_q2.size();
	+ int ibin = ibin_mX + ibin_q2 * m_bins_mX.size() +
	+ ibin_El * m_bins_mX.size() * m_bins_q2.size();

	if ( ( ibin_mX < 0 ) \|\| ( ibin_q2 < 0 ) \|\| ( ibin_El < 0 ) ) {
	EvtGenReport( EVTGEN_ERROR, "EvtVubHybrid" )
	@@ -1154,15 +1162,15 @@
	return 0.0;
	}

	- return _weights[ibin];
	+ return m_weights[ibin];
	}

	void EvtVubBLNPHybrid::readWeights( int startArg )
	{
	- _weights.resize( _nbins );
	+ m_weights.resize( m_nbins );

	double maxw = 0.0;
	- for ( auto& w : _weights ) {
	+ for ( auto& w : m_weights ) {
	w = getArg( startArg++ );
	if ( w > maxw )
	maxw = w;
	@@ -1177,6 +1185,6 @@
	}

	// rescale weights (to be in range 0..1)
	- for ( auto& w : _weights )
	+ for ( auto& w : m_weights )
	w /= maxw;
	}
	diff --git a/src/EvtGenModels/EvtVubHybrid.cpp b/src/EvtGenModels/EvtVubHybrid.cpp
	--- a/src/EvtGenModels/EvtVubHybrid.cpp
	+++ b/src/EvtGenModels/EvtVubHybrid.cpp
	@@ -63,7 +63,7 @@
	EvtGenReport( EVTGEN_WARNING, "EvtVubHybrid" )
	<< "EvtVub: generate B -> Xu l nu events "
	<< "without using the hybrid reweighting." << endl;
	- _noHybrid = true;
	+ m_noHybrid = true;
	} else if ( getNArg() < EvtVubHybrid::nParameters + EvtVubHybrid::nVariables ) {
	EvtGenReport( EVTGEN_ERROR, "EvtVubHybrid" )
	<< "EvtVub could not read number of bins for "
	@@ -76,15 +76,15 @@
	checkNDaug( 3 );

	// read minimum required parameters from decay.dec
	- _mb = getArg( 0 );
	- _a = getArg( 1 );
	- _alphas = getArg( 2 );
	+ m_mb = getArg( 0 );
	+ m_a = getArg( 1 );
	+ m_alphas = getArg( 2 );

	// the maximum dGamma*p2 value depends on alpha_s only:
	const double dGMax0 = 3.;
	- _dGMax = 0.21344 + 8.905 * _alphas;
	- if ( _dGMax < dGMax0 )
	- _dGMax = dGMax0;
	+ m_dGMax = 0.21344 + 8.905 * m_alphas;
	+ if ( m_dGMax < dGMax0 )
	+ m_dGMax = dGMax0;

	// for the Fermi Motion we need a B-Meson mass - but it's not critical
	// to get an exact value; in order to stay in the phase space for
	@@ -94,41 +94,41 @@
	static double mBP = EvtPDL::getMaxMass( EvtPDL::getId( "B+" ) );
	static double mB = ( mB0 < mBP ? mB0 : mBP );

	- const double xlow = -_mb;
	- const double xhigh = mB - _mb;
	+ const double xlow = -m_mb;
	+ const double xhigh = mB - m_mb;
	const int aSize = 10000;

	- EvtPFermi pFermi( _a, mB, _mb );
	+ EvtPFermi pFermi( m_a, mB, m_mb );
	// pf is the cumulative distribution normalized to 1.
	- _pf.resize( aSize );
	+ m_pf.resize( aSize );
	for ( int i = 0; i < aSize; i++ ) {
	double kplus = xlow + (double)( i + 0.5 ) / ( (double)aSize ) *
	( xhigh - xlow );
	if ( i == 0 )
	- _pf[i] = pFermi.getFPFermi( kplus );
	+ m_pf[i] = pFermi.getFPFermi( kplus );
	else
	- _pf[i] = _pf[i - 1] + pFermi.getFPFermi( kplus );
	+ m_pf[i] = m_pf[i - 1] + pFermi.getFPFermi( kplus );
	}
	- for ( size_t index = 0; index < _pf.size(); index++ ) {
	- _pf[index] /= _pf[_pf.size() - 1];
	+ for ( size_t index = 0; index < m_pf.size(); index++ ) {
	+ m_pf[index] /= m_pf[m_pf.size() - 1];
	}

	- _dGamma = std::make_unique<EvtVubdGamma>( _alphas );
	+ m_dGamma = std::make_unique<EvtVubdGamma>( m_alphas );

	- if ( _noHybrid )
	+ if ( m_noHybrid )
	return; // Without hybrid weighting, nothing else to do

	- _bins_mX.resize( abs( (int)getArg( 3 ) ) );
	- _bins_q2.resize( abs( (int)getArg( 4 ) ) );
	- _bins_El.resize( abs( (int)getArg( 5 ) ) );
	+ m_bins_mX.resize( abs( (int)getArg( 3 ) ) );
	+ m_bins_q2.resize( abs( (int)getArg( 4 ) ) );
	+ m_bins_El.resize( abs( (int)getArg( 5 ) ) );

	int nextArg = EvtVubHybrid::nParameters + EvtVubHybrid::nVariables;

	- _nbins = _bins_mX.size() * _bins_q2.size() *
	- _bins_El.size(); // Binning of weight table
	+ m_nbins = m_bins_mX.size() * m_bins_q2.size() *
	+ m_bins_El.size(); // Binning of weight table

	- int expectArgs = nextArg + _bins_mX.size() + _bins_q2.size() +
	- _bins_El.size() + _nbins;
	+ int expectArgs = nextArg + m_bins_mX.size() + m_bins_q2.size() +
	+ m_bins_El.size() + m_nbins;

	if ( getNArg() < expectArgs ) {
	EvtGenReport( EVTGEN_ERROR, "EvtVubHybrid" )
	@@ -139,13 +139,13 @@
	}

	// read bin boundaries from decay.dec
	- for ( auto& b : _bins_mX )
	+ for ( auto& b : m_bins_mX )
	b = getArg( nextArg++ );
	- _masscut = _bins_mX[0];
	+ m_masscut = m_bins_mX[0];

	- for ( auto& b : _bins_q2 )
	+ for ( auto& b : m_bins_q2 )
	b = getArg( nextArg++ );
	- for ( auto& b : _bins_El )
	+ for ( auto& b : m_bins_El )
	b = getArg( nextArg++ );

	// read in weights (and rescale to range 0..1)
	@@ -186,8 +186,8 @@
	mB = p->mass();
	ml = lepton->mass();

	- xlow = -_mb;
	- xhigh = mB - _mb;
	+ xlow = -m_mb;
	+ xhigh = mB - m_mb;

	// Fermi motion does not need to be computed inside the
	// tryit loop as m_b in Gamma0 does not need to be replaced by (m_b+kplus).
	@@ -195,17 +195,17 @@
	// beyond the considered orders in the paper anyway ...

	// for alpha_S = 0 and a mass cut on X_u not all values of kplus are
	- // possible. The maximum value is mB/2-_mb + sqrt(mB^2/4-_masscut^2)
	+ // possible. The maximum value is mB/2-m_mb + sqrt(mB^2/4-m_masscut^2)
	kplus = 2 * xhigh;

	while ( kplus >= xhigh \|\| kplus <= xlow \|\|
	- ( _alphas == 0 &&
	- kplus >= mB / 2 - _mb +
	- sqrt( mB * mB / 4 - _masscut * _masscut ) ) ) {
	+ ( m_alphas == 0 &&
	+ kplus >= mB / 2 - m_mb +
	+ sqrt( mB * mB / 4 - m_masscut * m_masscut ) ) ) {
	kplus = findPFermi(); //_pFermi->shoot();
	kplus = xlow + kplus * ( xhigh - xlow );
	}
	- qplus = mB - _mb - kplus;
	+ qplus = mB - m_mb - kplus;
	if ( ( mB - qplus ) / 2. <= ml )
	continue;

	@@ -222,11 +222,12 @@
	if ( Eh > 0 && Eh < mB ) {
	sh = p2 * pow( mB - qplus, 2 ) +
	2 * qplus * ( Eh - qplus ) + qplus * qplus;
	- if ( sh > _masscut * _masscut &&
	+ if ( sh > m_masscut * m_masscut &&
	mB * mB + sh - 2 * mB * Eh > ml * ml ) {
	double xran = EvtRandom::Flat();

	- double y = _dGamma->getdGdxdzdp( x, z, p2 ) / _dGMax * p2;
	+ double y = m_dGamma->getdGdxdzdp( x, z, p2 ) / m_dGMax *
	+ p2;

	if ( y > 1 )
	EvtGenReport( EVTGEN_WARNING, "EvtVubHybrid" )
	@@ -244,10 +245,10 @@
	q2 = mB * mB + sh - 2 * mB * Eh;

	// Reweighting in bins of mX, q2, El (J. Dingfelder)
	- if ( !_weights.empty() ) {
	+ if ( !m_weights.empty() ) {
	double xran1 = EvtRandom::Flat();
	double w = 1.0;
	- if ( !_noHybrid )
	+ if ( !m_noHybrid )
	w = getWeight( mX, q2, El );
	if ( w >= xran1 )
	rew = false;
	@@ -280,7 +281,7 @@
	p4.set( pHB[0], pHB[1], pHB[2], pHB[3] );
	xuhad->init( getDaug( 0 ), p4 );

	- if ( _storeQplus ) {
	+ if ( m_storeQplus ) {
	// cludge to store the hidden parameter q+ with the decay;
	// the lifetime of the Xu is abused for this purpose.
	// tau = 1 ps corresponds to ctau = 0.3 mm -> in order to
	@@ -380,21 +381,21 @@
	double EvtVubHybrid::findPFermi()
	{
	double ranNum = EvtRandom::Flat();
	- double oOverBins = 1.0 / ( float( _pf.size() ) );
	+ double oOverBins = 1.0 / ( float( m_pf.size() ) );
	int nBinsBelow = 0; // largest k such that I[k] is known to be <= rand
	- int nBinsAbove = _pf.size(); // largest k such that I[k] is known to be > rand
	+ int nBinsAbove = m_pf.size(); // largest k such that I[k] is known to be > rand
	int middle;

	while ( nBinsAbove > nBinsBelow + 1 ) {
	middle = ( nBinsAbove + nBinsBelow + 1 ) >> 1;
	- if ( ranNum >= _pf[middle] ) {
	+ if ( ranNum >= m_pf[middle] ) {
	nBinsBelow = middle;
	} else {
	nBinsAbove = middle;
	}
	}

	- double bSize = _pf[nBinsAbove] - _pf[nBinsBelow];
	+ double bSize = m_pf[nBinsAbove] - m_pf[nBinsBelow];
	// binMeasure is always aProbFunc[nBinsBelow],

	if ( bSize == 0 ) {
	@@ -404,7 +405,7 @@
	return ( nBinsBelow + .5 ) * oOverBins;
	}

	- double bFract = ( ranNum - _pf[nBinsBelow] ) / bSize;
	+ double bFract = ( ranNum - m_pf[nBinsBelow] ) / bSize;
	return ( nBinsBelow + bFract ) * oOverBins;
	}

	@@ -414,20 +415,20 @@
	int ibin_q2 = -1;
	int ibin_El = -1;

	- for ( unsigned i = 0; i < _bins_mX.size(); i++ ) {
	- if ( mX >= _bins_mX[i] )
	+ for ( unsigned i = 0; i < m_bins_mX.size(); i++ ) {
	+ if ( mX >= m_bins_mX[i] )
	ibin_mX = i;
	}
	- for ( unsigned i = 0; i < _bins_q2.size(); i++ ) {
	- if ( q2 >= _bins_q2[i] )
	+ for ( unsigned i = 0; i < m_bins_q2.size(); i++ ) {
	+ if ( q2 >= m_bins_q2[i] )
	ibin_q2 = i;
	}
	- for ( unsigned i = 0; i < _bins_El.size(); i++ ) {
	- if ( El >= _bins_El[i] )
	+ for ( unsigned i = 0; i < m_bins_El.size(); i++ ) {
	+ if ( El >= m_bins_El[i] )
	ibin_El = i;
	}
	- int ibin = ibin_mX + ibin_q2 * _bins_mX.size() +
	- ibin_El * _bins_mX.size() * _bins_q2.size();
	+ int ibin = ibin_mX + ibin_q2 * m_bins_mX.size() +
	+ ibin_El * m_bins_mX.size() * m_bins_q2.size();

	if ( ( ibin_mX < 0 ) \|\| ( ibin_q2 < 0 ) \|\| ( ibin_El < 0 ) ) {
	EvtGenReport( EVTGEN_ERROR, "EvtVubHybrid" )
	@@ -437,15 +438,15 @@
	return 0.0;
	}

	- return _weights[ibin];
	+ return m_weights[ibin];
	}

	void EvtVubHybrid::readWeights( int startArg )
	{
	- _weights.resize( _nbins );
	+ m_weights.resize( m_nbins );

	double maxw = 0.0;
	- for ( auto& w : _weights ) {
	+ for ( auto& w : m_weights ) {
	w = getArg( startArg++ );
	if ( w > maxw )
	maxw = w;
	@@ -460,6 +461,6 @@
	}

	// rescale weights (to be in range 0..1)
	- for ( auto& w : _weights )
	+ for ( auto& w : m_weights )
	w /= maxw;
	}
	diff --git a/src/EvtGenModels/EvtVubNLO.cpp b/src/EvtGenModels/EvtVubNLO.cpp
	--- a/src/EvtGenModels/EvtVubNLO.cpp
	+++ b/src/EvtGenModels/EvtVubNLO.cpp
	@@ -43,8 +43,8 @@

	EvtVubNLO::~EvtVubNLO()
	{
	- cout << " max pdf : " << _gmax << endl;
	- cout << " efficiency : " << (float)_ngood / (float)_ntot << endl;
	+ cout << " max pdf : " << m_gmax << endl;
	+ cout << " efficiency : " << (float)m_ngood / (float)m_ntot << endl;
	}

	std::string EvtVubNLO::getName()
	@@ -60,11 +60,11 @@
	void EvtVubNLO::init()
	{
	// max pdf
	- _gmax = 0;
	- _ntot = 0;
	- _ngood = 0;
	- _lbar = -1000;
	- _mupi2 = -1000;
	+ m_gmax = 0;
	+ m_ntot = 0;
	+ m_ngood = 0;
	+ m_lbar = -1000;
	+ m_mupi2 = -1000;

	// check number of arguments
	int npar = 8;
	@@ -77,30 +77,30 @@
	::abort();
	}
	// this is the shape function parameter
	- _mb = getArg( 0 );
	- _b = getArg( 1 );
	- _lambdaSF = getArg( 2 ); // shape function lambda is different from lambda
	- _mui = 1.5; // GeV (scale)
	- _kpar = getArg( 3 ); // 0
	- _idSF = abs( (int)getArg(
	+ m_mb = getArg( 0 );
	+ m_b = getArg( 1 );
	+ m_lambdaSF = getArg( 2 ); // shape function lambda is different from lambda
	+ m_mui = 1.5; // GeV (scale)
	+ m_kpar = getArg( 3 ); // 0
	+ m_idSF = abs( (int)getArg(
	4 ) ); // type of shape function 1: exponential (from Neubert)
	int nbins = abs( (int)getArg( 5 ) );
	- _masses.resize( nbins );
	- _weights.resize( nbins );
	+ m_masses.resize( nbins );
	+ m_weights.resize( nbins );

	// Shape function normalization
	- _mB = 5.28; // temporary B meson mass for normalization
	+ m_mB = 5.28; // temporary B meson mass for normalization

	std::vector<double> sCoeffs( 11 );
	- sCoeffs[3] = _b;
	- sCoeffs[4] = _mb;
	- sCoeffs[5] = _mB;
	- sCoeffs[6] = _idSF;
	+ sCoeffs[3] = m_b;
	+ sCoeffs[4] = m_mb;
	+ sCoeffs[5] = m_mB;
	+ sCoeffs[6] = m_idSF;
	sCoeffs[7] = lambda_SF();
	sCoeffs[8] = mu_h();
	sCoeffs[9] = mu_i();
	sCoeffs[10] = 1.;
	- _SFNorm = SFNorm( sCoeffs ); // SF normalization;
	+ m_SFNorm = SFNorm( sCoeffs ); // SF normalization;

	cout << " pdf 0.66, 1.32 , 4.32 " << tripleDiff( 0.66, 1.32, 4.32 ) << endl;
	cout << " pdf 0.23,0.37,3.76 " << tripleDiff( 0.23, 0.37, 3.76 ) << endl;
	@@ -108,9 +108,9 @@
	cout << " pdf 0.52,1.02,2.01 " << tripleDiff( 0.52, 1.02, 2.01 ) << endl;
	cout << " pdf 1.35,1.39,2.73 " << tripleDiff( 1.35, 1.39, 2.73 ) << endl;

	- if ( getNArg() - npar + 2 != int( 2 * _weights.size() ) ) {
	+ if ( getNArg() - npar + 2 != int( 2 * m_weights.size() ) ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	- << "EvtVubNLO generator expected " << _weights.size()
	+ << "EvtVubNLO generator expected " << m_weights.size()
	<< " masses and weights but found: " << ( getNArg() - npar ) / 2
	<< endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -119,26 +119,26 @@
	}
	int j = npar - 2;
	double maxw = 0.;
	- for ( unsigned i = 0; i < _masses.size(); i++ ) {
	- _masses[i] = getArg( j++ );
	- if ( i > 0 && _masses[i] <= _masses[i - 1] ) {
	+ for ( unsigned i = 0; i < m_masses.size(); i++ ) {
	+ m_masses[i] = getArg( j++ );
	+ if ( i > 0 && m_masses[i] <= m_masses[i - 1] ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "EvtVubNLO generator expected "
	<< " mass bins in ascending order!"
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- _weights[i] = getArg( j++ );
	- if ( _weights[i] < 0 ) {
	+ m_weights[i] = getArg( j++ );
	+ if ( m_weights[i] < 0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "EvtVubNLO generator expected "
	- << " weights >= 0, but found: " << _weights[i] << endl;
	+ << " weights >= 0, but found: " << m_weights[i] << endl;
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- if ( _weights[i] > maxw )
	- maxw = _weights[i];
	+ if ( m_weights[i] > maxw )
	+ maxw = m_weights[i];
	}
	if ( maxw == 0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -147,13 +147,13 @@
	<< "Will terminate execution!" << endl;
	::abort();
	}
	- for ( auto& w : _weights )
	+ for ( auto& w : m_weights )
	w /= maxw;

	// the maximum dGamma*p2 value depends on alpha_s only:

	- // _dGMax = 0.05;
	- _dGMax = 150.;
	+ // m_dGMax = 0.05;
	+ m_dGMax = 150.;

	// for the Fermi Motion we need a B-Meso\n mass - but it's not critical
	// to get an exact value; in order to stay in the phase space for
	@@ -183,7 +183,7 @@
	lepton = p->getDaug( 1 );
	neutrino = p->getDaug( 2 );

	- _mB = p->mass();
	+ m_mB = p->mass();
	ml = lepton->mass();

	bool tryit = true;
	@@ -191,26 +191,26 @@
	while ( tryit ) {
	// pm=(E_H+P_H)
	pm = EvtRandom::Flat( 0., 1 );
	- pm = pow( pm, 1. / 3. ) * _mB;
	+ pm = pow( pm, 1. / 3. ) * m_mB;
	// pl=mB-2*El
	pl = EvtRandom::Flat( 0., 1 );
	pl = sqrt( pl ) * pm;
	// pp=(E_H-P_H)
	pp = EvtRandom::Flat( 0., pl );

	- _ntot++;
	+ m_ntot++;

	- El = ( _mB - pl ) / 2.;
	+ El = ( m_mB - pl ) / 2.;
	Eh = ( pp + pm ) / 2;
	sh = pp * pm;

	double pdf( 0. );
	- if ( pp < pl && El > ml && sh > _masses[0] * _masses[0] &&
	- _mB * _mB + sh - 2 * _mB * Eh > ml * ml ) {
	- double xran = EvtRandom::Flat( 0, _dGMax );
	+ if ( pp < pl && El > ml && sh > m_masses[0] * m_masses[0] &&
	+ m_mB * m_mB + sh - 2 * m_mB * Eh > ml * ml ) {
	+ double xran = EvtRandom::Flat( 0, m_dGMax );
	pdf = tripleDiff( pp, pl, pm ); // triple differential distribution
	// cout <<" P+,P-,Pl,Pdf= "<<pp <<" "<<pm<<" "<<pl<<" "<<pdf<<endl;
	- if ( pdf > _dGMax ) {
	+ if ( pdf > m_dGMax ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "EvtVubNLO pdf above maximum: " << pdf
	<< " P+,P-,Pl,Pdf= " << pp << " " << pm << " " << pl << " "
	@@ -220,21 +220,21 @@
	if ( pdf >= xran )
	tryit = false;

	- if ( pdf > _gmax )
	- _gmax = pdf;
	+ if ( pdf > m_gmax )
	+ m_gmax = pdf;
	} else {
	// cout <<" EvtVubNLO incorrect kinematics sh= "<<sh<<"EH "<<Eh<<endl;
	}

	// reweight the Mx distribution
	- if ( !tryit && !_weights.empty() ) {
	- _ngood++;
	+ if ( !tryit && !m_weights.empty() ) {
	+ m_ngood++;
	double xran1 = EvtRandom::Flat();
	double m = sqrt( sh );
	unsigned j = 0;
	- while ( j < _masses.size() && m > _masses[j] )
	+ while ( j < m_masses.size() && m > m_masses[j] )
	j++;
	- double w = _weights[j - 1];
	+ double w = m_weights[j - 1];
	if ( w < xran1 )
	tryit = true; // through away this candidate
	}
	@@ -269,12 +269,12 @@
	// calculate the W 4 vector in the B Meson restrframe

	double apWB = ptmp;
	- double pWB[4] = { _mB - Eh, -pHB[1], -pHB[2], -pHB[3] };
	+ double pWB[4] = { m_mB - Eh, -pHB[1], -pHB[2], -pHB[3] };

	// first go in the W restframe and calculate the lepton and
	// the neutrino in the W frame

	- double mW2 = _mB * _mB + sh - 2 * _mB * Eh;
	+ double mW2 = m_mB * m_mB + sh - 2 * m_mB * Eh;
	// if(mW2<0.1){
	// cout <<" low Q2! "<<pp<<" "<<epp<<" "<<x<<" "<<y<<endl;
	//}
	@@ -353,32 +353,32 @@
	sCoeffs[0] = pp;
	sCoeffs[1] = pl;
	sCoeffs[2] = pm;
	- sCoeffs[3] = _b;
	- sCoeffs[4] = _mb;
	- sCoeffs[5] = _mB;
	- sCoeffs[6] = _idSF;
	+ sCoeffs[3] = m_b;
	+ sCoeffs[4] = m_mb;
	+ sCoeffs[5] = m_mB;
	+ sCoeffs[6] = m_idSF;
	sCoeffs[7] = lambda_SF();
	sCoeffs[8] = mu_h();
	sCoeffs[9] = mu_i();
	- sCoeffs[10] = _SFNorm; // SF normalization;
	+ sCoeffs[10] = m_SFNorm; // SF normalization;

	- double c1 = ( _mB + pl - pp - pm ) * ( pm - pl );
	+ double c1 = ( m_mB + pl - pp - pm ) * ( pm - pl );
	double c2 = 2 * ( pl - pp ) * ( pm - pl );
	- double c3 = ( _mB - pm ) * ( pm - pp );
	+ double c3 = ( m_mB - pm ) * ( pm - pp );
	double aF1 = F10( sCoeffs );
	double aF2 = F20( sCoeffs );
	double aF3 = F30( sCoeffs );
	double td0 = c1 * aF1 + c2 * aF2 + c3 * aF3;

	- auto func = EvtItgPtrFunction{ &integrand, 0., _mB, sCoeffs };
	+ auto func = EvtItgPtrFunction{ &integrand, 0., m_mB, sCoeffs };
	auto jetSF = EvtItgSimpsonIntegrator{ func, 0.01, 25 };
	double smallfrac =
	0.000001; // stop a bit before the end to avoid problems with numerical integration
	double tdInt = jetSF.evaluate( 0, pp * ( 1 - smallfrac ) );

	double SU = U1lo( mu_h(), mu_i() ) *
	- pow( ( pm - pp ) / ( _mB - pp ), alo( mu_h(), mu_i() ) );
	- double TD = ( _mB - pp ) * SU * ( td0 + tdInt );
	+ pow( ( pm - pp ) / ( m_mB - pp ), alo( mu_h(), mu_i() ) );
	+ double TD = ( m_mB - pp ) * SU * ( td0 + tdInt );

	return TD;
	}
	@@ -563,19 +563,18 @@

	double EvtVubNLO::SFNorm( const std::vector<double>& /coeffs/ )
	{
	- double omega0 = 1.68; //normalization scale (mB-2*1.8)
	- if ( _idSF == 1 ) { // exponential SF
	- double omega0 = 1.68; //normalization scale (mB-2*1.8)
	- return M0( mu_i(), omega0 ) * pow( _b, _b ) / lambda_SF() /
	- ( Gamma( _b ) - Gamma( _b, _b * omega0 / lambda_SF() ) );
	- } else if ( _idSF == 2 ) { // Gaussian SF
	- double c = cGaus( _b );
	+ double omega0 = 1.68; //normalization scale (mB-2*1.8)
	+ if ( m_idSF == 1 ) { // exponential SF
	+ return M0( mu_i(), omega0 ) * pow( m_b, m_b ) / lambda_SF() /
	+ ( Gamma( m_b ) - Gamma( m_b, m_b * omega0 / lambda_SF() ) );
	+ } else if ( m_idSF == 2 ) { // Gaussian SF
	+ double c = cGaus( m_b );
	return M0( mu_i(), omega0 ) * 2 / lambda_SF() /
	- pow( c, -( 1 + _b ) / 2. ) /
	- ( Gamma( ( 1 + _b ) / 2 ) -
	- Gamma( ( 1 + _b ) / 2, pow( omega0 / lambda_SF(), 2 ) * c ) );
	+ pow( c, -( 1 + m_b ) / 2. ) /
	+ ( Gamma( ( 1 + m_b ) / 2 ) -
	+ Gamma( ( 1 + m_b ) / 2, pow( omega0 / lambda_SF(), 2 ) * c ) );
	} else {
	- EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "unknown SF " << _idSF << endl;
	+ EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "unknown SF " << m_idSF << endl;
	return -1;
	}
	}
	@@ -613,50 +612,50 @@

	double EvtVubNLO::lambda_bar( double omega0 )
	{
	- if ( _lbar < 0 ) {
	- if ( _idSF == 1 ) { // exponential SF
	- double rat = omega0 * _b / lambda_SF();
	- _lbar = lambda_SF() / _b *
	- ( Gamma( 1 + _b ) - Gamma( 1 + _b, rat ) ) /
	- ( Gamma( _b ) - Gamma( _b, rat ) );
	- } else if ( _idSF == 2 ) { // Gaussian SF
	- double c = cGaus( _b );
	- _lbar = lambda_SF() *
	- ( Gamma( 1 + _b / 2 ) -
	- Gamma( 1 + _b / 2, pow( omega0 / lambda_SF(), 2 ) * c ) ) /
	- ( Gamma( ( 1 + _b ) / 2 ) -
	- Gamma( ( 1 + _b ) / 2,
	- pow( omega0 / lambda_SF(), 2 ) * c ) ) /
	- sqrt( c );
	+ if ( m_lbar < 0 ) {
	+ if ( m_idSF == 1 ) { // exponential SF
	+ double rat = omega0 * m_b / lambda_SF();
	+ m_lbar = lambda_SF() / m_b *
	+ ( Gamma( 1 + m_b ) - Gamma( 1 + m_b, rat ) ) /
	+ ( Gamma( m_b ) - Gamma( m_b, rat ) );
	+ } else if ( m_idSF == 2 ) { // Gaussian SF
	+ double c = cGaus( m_b );
	+ m_lbar =
	+ lambda_SF() *
	+ ( Gamma( 1 + m_b / 2 ) -
	+ Gamma( 1 + m_b / 2, pow( omega0 / lambda_SF(), 2 ) * c ) ) /
	+ ( Gamma( ( 1 + m_b ) / 2 ) -
	+ Gamma( ( 1 + m_b ) / 2, pow( omega0 / lambda_SF(), 2 ) * c ) ) /
	+ sqrt( c );
	}
	}
	- return _lbar;
	+ return m_lbar;
	}

	double EvtVubNLO::mu_pi2( double omega0 )
	{
	- if ( _mupi2 < 0 ) {
	- if ( _idSF == 1 ) { // exponential SF
	- double rat = omega0 * _b / lambda_SF();
	- _mupi2 = 3 * ( pow( lambda_SF() / _b, 2 ) *
	- ( Gamma( 2 + _b ) - Gamma( 2 + _b, rat ) ) /
	- ( Gamma( _b ) - Gamma( _b, rat ) ) -
	- pow( lambda_bar( omega0 ), 2 ) );
	- } else if ( _idSF == 2 ) { // Gaussian SF
	- double c = cGaus( _b );
	- double m1 = Gamma( ( 3 + _b ) / 2 ) -
	- Gamma( ( 3 + _b ) / 2,
	+ if ( m_mupi2 < 0 ) {
	+ if ( m_idSF == 1 ) { // exponential SF
	+ double rat = omega0 * m_b / lambda_SF();
	+ m_mupi2 = 3 * ( pow( lambda_SF() / m_b, 2 ) *
	+ ( Gamma( 2 + m_b ) - Gamma( 2 + m_b, rat ) ) /
	+ ( Gamma( m_b ) - Gamma( m_b, rat ) ) -
	+ pow( lambda_bar( omega0 ), 2 ) );
	+ } else if ( m_idSF == 2 ) { // Gaussian SF
	+ double c = cGaus( m_b );
	+ double m1 = Gamma( ( 3 + m_b ) / 2 ) -
	+ Gamma( ( 3 + m_b ) / 2,
	pow( omega0 / lambda_SF(), 2 ) * c );
	- double m2 = Gamma( 1 + _b / 2 ) -
	- Gamma( 1 + _b / 2, pow( omega0 / lambda_SF(), 2 ) * c );
	- double m3 = Gamma( ( 1 + _b ) / 2 ) -
	- Gamma( ( 1 + _b ) / 2,
	+ double m2 = Gamma( 1 + m_b / 2 ) -
	+ Gamma( 1 + m_b / 2, pow( omega0 / lambda_SF(), 2 ) * c );
	+ double m3 = Gamma( ( 1 + m_b ) / 2 ) -
	+ Gamma( ( 1 + m_b ) / 2,
	pow( omega0 / lambda_SF(), 2 ) * c );
	- _mupi2 = 3 * pow( lambda_SF(), 2 ) *
	- ( m1 / m3 - pow( m2 / m3, 2 ) ) / c;
	+ m_mupi2 = 3 * pow( lambda_SF(), 2 ) *
	+ ( m1 / m3 - pow( m2 / m3, 2 ) ) / c;
	}
	}
	- return _mupi2;
	+ return m_mupi2;
	}

	double EvtVubNLO::M0( double mui, double omega0 )
	diff --git a/src/EvtGenModels/EvtVubdGamma.cpp b/src/EvtGenModels/EvtVubdGamma.cpp
	--- a/src/EvtGenModels/EvtVubdGamma.cpp
	+++ b/src/EvtGenModels/EvtVubdGamma.cpp
	@@ -32,10 +32,10 @@

	EvtVubdGamma::EvtVubdGamma( const double& alphas )
	{
	- _alphas = alphas;
	+ m_alphas = alphas;

	- // the range for the delta distribution in p2 is from _epsilon1 to
	- // _epsilon2. It was checked with the single differential formulae
	+ // the range for the delta distribution in p2 is from m_epsilon1 to
	+ // m_epsilon2. It was checked with the single differential formulae
	// in the paper that these values are small enough to imitate p2 = 0
	// for the regular terms.
	// The ()* distributions, however need further treatment. In order to
	@@ -44,10 +44,10 @@
	// for z=1 p2=0 is not allowed and therefore the part of dGamma proportional
	// to delta(p2) should go to 0 for z->1.
	// Using equation (3.1) and (3.2) it is possible to find the correct value
	- // for log(_epsilon3) from this requirement.
	+ // for log(m_epsilon3) from this requirement.

	- _epsilon1 = 1e-10;
	- _epsilon2 = 1e-5;
	+ m_epsilon1 = 1e-10;
	+ m_epsilon2 = 1e-5;
	if ( alphas > 0 ) {
	double lne3 = 9. / 16. - 2 * EvtConst::pi * EvtConst::pi / 3. +
	6 * EvtConst::pi / 4 / alphas;
	@@ -55,9 +55,9 @@
	lne3 = -7. / 4. - sqrt( lne3 );
	else
	lne3 = -7. / 4.;
	- _epsilon3 = exp( lne3 );
	+ m_epsilon3 = exp( lne3 );
	} else
	- _epsilon3 = 1;
	+ m_epsilon3 = 1;
	}

	//-----------
	@@ -85,7 +85,7 @@

	double dG;

	- if ( p2 > _epsilon1 && p2 < _epsilon2 ) {
	+ if ( p2 > m_epsilon1 && p2 < m_epsilon2 ) {
	double W1 = getW1delta( x, z );
	double W4plus5 = getW4plus5delta( x, z );

	@@ -110,8 +110,8 @@
	{
	if ( xmin > 0 \|\| xmax < 0 )
	return 0.;
	- if ( _epsilon1 < x && x < _epsilon2 )
	- return 1. / ( _epsilon2 - _epsilon1 );
	+ if ( m_epsilon1 < x && x < m_epsilon2 )
	+ return 1. / ( m_epsilon2 - m_epsilon1 );
	return 0.0;
	}

	@@ -134,10 +134,10 @@
	double dl = 4. * EvtDiLog::DiLog( mz ) + 4. * pow( EvtConst::pi, 2 ) / 3.;

	double w = -( 8. * pow( log( z ), 2 ) - 10. * log( z ) + 2. * lz + dl + 5. ) +
	- ( 8. * log( z ) - 7. ) * log( _epsilon3 ) -
	- 2. * pow( log( _epsilon3 ), 2 );
	+ ( 8. * log( z ) - 7. ) * log( m_epsilon3 ) -
	+ 2. * pow( log( m_epsilon3 ), 2 );

	- return ( 1. + w * _alphas / 3. / EvtConst::pi );
	+ return ( 1. + w * m_alphas / 3. / EvtConst::pi );
	}

	double EvtVubdGamma::getW1nodelta( const double&, const double& z,
	@@ -148,15 +148,15 @@
	double t = sqrt( t2 );

	double w = 0;
	- if ( p2 > _epsilon2 )
	+ if ( p2 > m_epsilon2 )
	w += 4. / p2 * ( log( ( 1. + t ) / ( 1. - t ) ) / t + log( p2 / z2 ) ) +
	1. - ( 8. - z ) * ( 2. - z ) / z2 / t2 +
	( ( 2. - z ) / 2. / z + ( 8. - z ) * ( 2. - z ) / 2. / z2 / t2 ) *
	log( ( 1. + t ) / ( 1. - t ) ) / t;
	- if ( p2 > _epsilon3 )
	+ if ( p2 > m_epsilon3 )
	w += ( 8. * log( z ) - 7. ) / p2 - 4. * log( p2 ) / p2;

	- return w * _alphas / 3. / EvtConst::pi;
	+ return w * m_alphas / 3. / EvtConst::pi;
	}

	double EvtVubdGamma::getW2nodelta( const double&, const double& z,
	@@ -168,13 +168,13 @@
	double w11 = ( 32. - 8. * z + z2 ) / 4. / z / t2;

	double w = 0;
	- if ( p2 > _epsilon2 )
	+ if ( p2 > m_epsilon2 )
	w -= ( z * t2 / 8. + ( 4. - z ) / 4. + w11 / 2. ) *
	log( ( 1. + t ) / ( 1. - t ) ) / t;
	- if ( p2 > _epsilon2 )
	+ if ( p2 > m_epsilon2 )
	w += ( 8. - z ) / 4. + w11;

	- return ( w * _alphas / 3. / EvtConst::pi );
	+ return ( w * m_alphas / 3. / EvtConst::pi );
	}

	double EvtVubdGamma::getW3nodelta( const double&, const double& z,
	@@ -187,16 +187,16 @@

	double w = 0;

	- if ( p2 > _epsilon2 )
	+ if ( p2 > m_epsilon2 )
	w += ( z * t2 / 16. + 5. * ( 4. - z ) / 16. -
	( 64. + 56. * z - 7. * z2 ) / 16. / z / t2 +
	3. * ( 12. - z ) / 16. / t4 ) *
	log( ( 1. + t ) / ( 1. - t ) ) / t;
	- if ( p2 > _epsilon2 )
	+ if ( p2 > m_epsilon2 )
	w += -( 8. - 3. * z ) / 8. + ( 32. + 22. * z - 3. * z2 ) / 4. / z / t2 -
	3. * ( 12. - z ) / 8. / t4;

	- return ( w * _alphas / 3. / EvtConst::pi );
	+ return ( w * m_alphas / 3. / EvtConst::pi );
	}

	double EvtVubdGamma::getW4nodelta( const double&, const double& z,
	@@ -209,15 +209,15 @@

	double w = 0;

	- if ( p2 > _epsilon2 )
	+ if ( p2 > m_epsilon2 )
	w -= ( ( 8. - 3. * z ) / 4. / z - ( 22. - 3. * z ) / 2. / z / t2 +
	3. * ( 12. - z ) / 4. / z / t4 ) *
	log( ( 1. + t ) / ( 1. - t ) ) / t;
	- if ( p2 > _epsilon2 )
	+ if ( p2 > m_epsilon2 )
	w += -1. - ( 32. - 5. * z ) / 2. / z / t2 +
	3. * ( 12. - z ) / 2. / z / t4;

	- return w * _alphas / 3. / EvtConst::pi;
	+ return w * m_alphas / 3. / EvtConst::pi;
	}

	double EvtVubdGamma::getW4plus5delta( const double&, const double& z )
	@@ -229,7 +229,7 @@
	else
	w = 2. * log( z ) / ( 1. - z );

	- return ( w * _alphas / 3. / EvtConst::pi );
	+ return ( w * m_alphas / 3. / EvtConst::pi );
	}

	double EvtVubdGamma::getW5nodelta( const double&, const double& z,
	@@ -241,12 +241,12 @@
	double t = sqrt( t2 );

	double w = 0;
	- if ( p2 > _epsilon2 )
	+ if ( p2 > m_epsilon2 )
	w += ( 1. / 4. / z - ( 2. - z ) / 2. / z2 / t2 +
	3. * ( 12. - z ) / 4. / z2 / t4 ) *
	log( ( 1. + t ) / ( 1. - t ) ) / t;
	- if ( p2 > _epsilon2 )
	+ if ( p2 > m_epsilon2 )
	w += -( 8. + z ) / 2. / z2 / t2 - 3. * ( 12. - z ) / 2. / z2 / t4;

	- return ( w * _alphas / 3. / EvtConst::pi );
	+ return ( w * m_alphas / 3. / EvtConst::pi );
	}
	diff --git a/src/EvtGenModels/EvtWHad.cpp b/src/EvtGenModels/EvtWHad.cpp
	--- a/src/EvtGenModels/EvtWHad.cpp
	+++ b/src/EvtGenModels/EvtWHad.cpp
	@@ -24,64 +24,64 @@
	#include "EvtGenBase/EvtTensor4C.hh"

	EvtWHad::EvtWHad() :
	- mRho_(),
	- gamma0_(),
	- cK_( 0 ),
	- mK_(),
	- gammaK_(),
	- gKRho_(),
	- gKPi_(),
	- mPi_( EvtPDL::getMeanMass( EvtPDL::getId( "pi+" ) ) ),
	- mPiSq_( mPi_ * mPi_ )
	+ m_mRho(),
	+ m_gamma0(),
	+ m_cK( 0 ),
	+ m_mK(),
	+ m_gammaK(),
	+ m_gKRho(),
	+ m_gKPi(),
	+ m_mPi( EvtPDL::getMeanMass( EvtPDL::getId( "pi+" ) ) ),
	+ m_mPiSq( m_mPi * m_mPi )
	{
	// cK coefficients from Eur. Phys. J. C39, 41 (2005), arXiv:hep-ph/0409080 [hep-ph]

	// rho(770)
	- mRho_.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "rho0" ) ) );
	- gamma0_.push_back( EvtPDL::getWidth( EvtPDL::getId( "rho0" ) ) );
	- cK_.push_back( 1.195 );
	+ m_mRho.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "rho0" ) ) );
	+ m_gamma0.push_back( EvtPDL::getWidth( EvtPDL::getId( "rho0" ) ) );
	+ m_cK.push_back( 1.195 );

	// rho(1450)
	- mRho_.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "rho(2S)0" ) ) );
	- gamma0_.push_back( EvtPDL::getWidth( EvtPDL::getId( "rho(2S)0" ) ) );
	- cK_.push_back( -0.112 );
	+ m_mRho.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "rho(2S)0" ) ) );
	+ m_gamma0.push_back( EvtPDL::getWidth( EvtPDL::getId( "rho(2S)0" ) ) );
	+ m_cK.push_back( -0.112 );

	// rho(1700)
	- mRho_.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "rho(3S)0" ) ) );
	- gamma0_.push_back( EvtPDL::getWidth( EvtPDL::getId( "rho(3S)0" ) ) );
	- cK_.push_back( -0.083 );
	+ m_mRho.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "rho(3S)0" ) ) );
	+ m_gamma0.push_back( EvtPDL::getWidth( EvtPDL::getId( "rho(3S)0" ) ) );
	+ m_cK.push_back( -0.083 );

	// rho(2150), PRD 76 092005
	- mRho_.push_back( 2.150 );
	- gamma0_.push_back( 0.310 );
	- cK_.push_back( 0.0 );
	+ m_mRho.push_back( 2.150 );
	+ m_gamma0.push_back( 0.310 );
	+ m_cK.push_back( 0.0 );

	// Storing K resonance information

	// K(892)

	- mK_.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "K*0" ) ) );
	- gammaK_.push_back( EvtPDL::getWidth( EvtPDL::getId( "K*0" ) ) );
	- gKRho_.push_back( 0.0 );
	- gKPi_.push_back( 3.26 );
	+ m_mK.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "K*0" ) ) );
	+ m_gammaK.push_back( EvtPDL::getWidth( EvtPDL::getId( "K*0" ) ) );
	+ m_gKRho.push_back( 0.0 );
	+ m_gKPi.push_back( 3.26 );

	// K1(1270)

	- mK_.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "K_10" ) ) );
	- gammaK_.push_back( EvtPDL::getWidth( EvtPDL::getId( "K_10" ) ) );
	- gKRho_.push_back( 2.71 );
	- gKPi_.push_back( 0.792 );
	+ m_mK.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "K_10" ) ) );
	+ m_gammaK.push_back( EvtPDL::getWidth( EvtPDL::getId( "K_10" ) ) );
	+ m_gKRho.push_back( 2.71 );
	+ m_gKPi.push_back( 0.792 );

	// K1(1400)
	- mK_.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "K'_10" ) ) );
	- gammaK_.push_back( EvtPDL::getWidth( EvtPDL::getId( "K'_10" ) ) );
	- gKRho_.push_back( 0.254 );
	- gKPi_.push_back( 2.509 );
	+ m_mK.push_back( EvtPDL::getMeanMass( EvtPDL::getId( "K'_10" ) ) );
	+ m_gammaK.push_back( EvtPDL::getWidth( EvtPDL::getId( "K'_10" ) ) );
	+ m_gKRho.push_back( 0.254 );
	+ m_gKPi.push_back( 2.509 );
	}

	EvtComplex EvtWHad::BWKK( double s, int i ) const
	{
	- const double m2 = mRho_[i] * mRho_[i];
	+ const double m2 = m_mRho[i] * m_mRho[i];
	const EvtComplex qs = pcm( s );
	const EvtComplex qm = pcm( m2 );
	if ( abs( qm ) < 1e-10 ) {
	@@ -94,7 +94,7 @@
	return 0;
	}

	- const EvtComplex gamma = m2 * rat3 * gamma0_[i] / s;
	+ const EvtComplex gamma = m2 * rat3 * m_gamma0[i] / s;
	const EvtComplex I( 0.0, 1.0 );

	const EvtComplex denBW = m2 - s - I * sqrt( s ) * gamma;
	@@ -102,7 +102,7 @@
	return 0;
	}

	- return cK_[i] * m2 / denBW;
	+ return m_cK[i] * m2 / denBW;
	}

	EvtVector4C EvtWHad::WCurrent_KSK( const EvtVector4R& pKS,
	@@ -199,8 +199,8 @@
	const EvtComplex I( 0.0, 1.0 );

	const EvtComplex den1 = 1.0 / ( q2 - mA1 * mA1 + I * mA1 * gammaA1 );
	- const EvtComplex den2 = 1.0 / ( pK2 - mK_[0] * mK_[0] +
	- I * mK_[0] * gammaK_[0] ); //K(892)
	+ const EvtComplex den2 = 1.0 / ( pK2 - m_mK[0] * m_mK[0] +
	+ I * m_mK[0] * m_gammaK[0] ); //K(892)

	const EvtTensor4C ten = EvtTensor4C::g() -
	( 1.0 / q2 ) * EvtGenFunctions::directProd( q, q );
	@@ -297,29 +297,29 @@
	// W+ -> K1+(1270) -> K+ rho0 -> K+ pi+ pi-

	pp2 = ( pPiPlus + pPiMinus ).mass2();
	- curr1 = ( pPiPlus - pPiMinus ) * Den( q2, mK_[1], gammaK_[1], gKRho_[1] ) *
	- Den( pp2, mRho_[0], gamma0_[0], gRho_PiPi ); //K1(1270) and rho(770)
	+ curr1 = ( pPiPlus - pPiMinus ) * Den( q2, m_mK[1], m_gammaK[1], m_gKRho[1] ) *
	+ Den( pp2, m_mRho[0], m_gamma0[0], gRho_PiPi ); //K1(1270) and rho(770)
	curr = curr + cK1r * curr1;

	// W+ -> K1+(1270) -> K*(892)0 pi+ -> K+ pi- pi-

	pp2 = ( pKplus + pPiMinus ).mass2();
	- curr1 = ( pKplus - pPiMinus ) * Den( q2, mK_[1], gammaK_[1], gKPi_[1] ) *
	- Den( pp2, mK_[0], gammaK_[0], gKPi_[0] ); //K1(1270) and K(892)
	+ curr1 = ( pKplus - pPiMinus ) * Den( q2, m_mK[1], m_gammaK[1], m_gKPi[1] ) *
	+ Den( pp2, m_mK[0], m_gammaK[0], m_gKPi[0] ); //K1(1270) and K(892)
	curr = curr + cK1p * curr1;

	// W+ -> K1+(1400) -> K+ rho0 -> K+ pi+ pi-

	pp2 = ( pPiMinus + pPiPlus ).mass2();
	- curr1 = ( pPiPlus - pPiMinus ) * Den( q2, mK_[2], gammaK_[2], gKRho_[2] ) *
	- Den( pp2, mRho_[0], gamma0_[0], gRho_PiPi ); //K1(1400) and rho(770)
	+ curr1 = ( pPiPlus - pPiMinus ) * Den( q2, m_mK[2], m_gammaK[2], m_gKRho[2] ) *
	+ Den( pp2, m_mRho[0], m_gamma0[0], gRho_PiPi ); //K1(1400) and rho(770)
	curr = curr + cK2r * curr1;

	// W+ -> K1+(1400) -> K*(892)0 pi+ -> K+ pi- pi+

	pp2 = ( pKplus + pPiMinus ).mass2();
	- curr1 = ( pKplus - pPiPlus ) * Den( q2, mK_[2], gammaK_[2], gKPi_[2] ) *
	- Den( pp2, mK_[0], gammaK_[0], gKPi_[0] ); //K1(1400) and K(892)
	+ curr1 = ( pKplus - pPiPlus ) * Den( q2, m_mK[2], m_gammaK[2], m_gKPi[2] ) *
	+ Den( pp2, m_mK[0], m_gammaK[0], m_gKPi[0] ); //K1(1400) and K(892)
	curr = curr + cK2p * curr1;

	const EvtTensor4C ten = EvtTensor4C::g() -
	@@ -369,17 +369,17 @@
	const double beta( -0.108 );

	const double s = q.mass2();
	- const EvtComplex BW_rho = BW( s, mRho_[0], gamma0_[0], mPi_, mPi_ );
	- const EvtComplex BW_rhopr = BW( s, mRho_[1], gamma0_[1], mPi_, mPi_ );
	+ const EvtComplex BW_rho = BW( s, m_mRho[0], m_gamma0[0], m_mPi, m_mPi );
	+ const EvtComplex BW_rhopr = BW( s, m_mRho[1], m_gamma0[1], m_mPi, m_mPi );
	return ( BW_rho + beta * BW_rhopr ) / ( 1.0 + beta );
	}

	double EvtWHad::pi3G( double Q2 ) const
	{
	- const double mRhoPi = mRho_[0] + mPi_;
	+ const double mRhoPi = m_mRho[0] + m_mPi;
	// Parameterisation of scaling factor for a1 (to 3pi) decay width
	if ( Q2 < mRhoPi * mRhoPi ) {
	- const double arg = Q2 - 9. * mPiSq_;
	+ const double arg = Q2 - 9. * m_mPiSq;
	const double arg2 = arg * arg;
	const double arg3 = arg * arg2;
	return 4.1 * arg3 * ( 1. - 3.3 * arg + 5.8 * arg2 );
	@@ -446,8 +446,8 @@
	{
	const EvtComplex I( 0, 1 );
	const EvtVector4R pKstar = p1 + p4, pa1 = p2 + p3 + p5;
	- EvtComplex denKstar = pKstar * pKstar - mK_[0] * mK_[0] +
	- I * mK_[0] * gammaK_[0]; //K(892)
	+ EvtComplex denKstar = pKstar * pKstar - m_mK[0] * m_mK[0] +
	+ I * m_mK[0] * m_gammaK[0]; //K(892)
	if ( abs( denKstar ) < 1e-10 ) {
	denKstar = 1e10;
	}
	diff --git a/src/EvtGenModels/EvtWilsonCoefficients.cpp b/src/EvtGenModels/EvtWilsonCoefficients.cpp
	--- a/src/EvtGenModels/EvtWilsonCoefficients.cpp
	+++ b/src/EvtGenModels/EvtWilsonCoefficients.cpp
	@@ -24,7 +24,7 @@
	#include "EvtGenBase/EvtPatches.hh"
	#include "EvtGenBase/EvtReport.hh"

	-#include <stdlib.h>
	+#include <cstdlib>

	double li2spence( double );

	@@ -53,16 +53,16 @@
	{ 0, 0, +0.8966, -0.1960, -0.2011, 0.1328, -0.0292, -0.1858 },
	{ 0, 0, -0.1193, +0.1003, -0.0473, 0.2323, -0.0133, -0.1799 } };
	for ( i = 0; i < 8; i++ ) {
	- a[i] = tmpa[i];
	- h[i] = tmph[i];
	- p[i] = tmpp[i];
	- s[i] = tmps[i];
	- q[i] = tmpq[i];
	- g[i] = tmpg[i];
	+ m_a[i] = tmpa[i];
	+ m_h[i] = tmph[i];
	+ m_p[i] = tmpp[i];
	+ m_s[i] = tmps[i];
	+ m_q[i] = tmpq[i];
	+ m_g[i] = tmpg[i];
	for ( j = 0; j < 6; j++ )
	- k[j][i] = tmpk[j][i];
	+ m_k[j][i] = tmpk[j][i];
	for ( j = 0; j < 2; j++ )
	- r[j][i] = tmpr[j][i];
	+ m_r[j][i] = tmpr[j][i];
	}
	m_n_f = 5;
	m_Lambda = 0.2167;
	@@ -176,7 +176,7 @@
	int i;
	EvtComplex myC1( 0, 0 );
	for ( i = 0; i < 8; i++ )
	- myC1 += k[0][i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] );
	+ myC1 += m_k[0][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
	return myC1;
	}

	@@ -186,7 +186,7 @@
	int i;
	EvtComplex myC2( 0, 0 );
	for ( i = 0; i < 8; i++ )
	- myC2 += k[1][i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] );
	+ myC2 += m_k[1][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
	return myC2;
	}

	@@ -196,7 +196,7 @@
	int i;
	EvtComplex myC3( 0, 0 );
	for ( i = 0; i < 8; i++ )
	- myC3 += k[2][i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] );
	+ myC3 += m_k[2][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
	return myC3;
	}

	@@ -206,7 +206,7 @@
	int i;
	EvtComplex myC4( 0, 0 );
	for ( i = 0; i < 8; i++ )
	- myC4 += k[3][i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] );
	+ myC4 += m_k[3][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
	return myC4;
	}

	@@ -216,7 +216,7 @@
	int i;
	EvtComplex myC5( 0, 0 );
	for ( i = 0; i < 8; i++ )
	- myC5 += k[4][i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] );
	+ myC5 += m_k[4][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
	return myC5;
	}

	@@ -226,7 +226,7 @@
	int i;
	EvtComplex myC6( 0, 0 );
	for ( i = 0; i < 8; i++ )
	- myC6 += k[5][i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] );
	+ myC6 += m_k[5][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
	return myC6;
	}

	@@ -247,7 +247,7 @@
	int i;
	EvtComplex myC7eff( 0, 0 );
	for ( i = 0; i < 8; i++ )
	- myC7eff += h[i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] );
	+ myC7eff += m_h[i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
	myC7eff *= C2( mu, n_f, Lambda, M_W );
	myC7eff += pow( eta( mu, n_f, Lambda, M_W ), 16. / 23. ) * C7( M_t, M_W );
	myC7eff += 8. / 3. *
	@@ -264,7 +264,7 @@
	int i;
	EvtComplex myC8eff( 0, 0 );
	for ( i = 0; i < 8; i++ )
	- myC8eff += g[i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] );
	+ myC8eff += m_g[i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
	myC8eff += pow( eta( mu, n_f, Lambda, M_W ), 14. / 23. ) * C8( M_t, M_W );
	return myC8eff;
	}
	@@ -357,15 +357,15 @@
	int i;
	EvtComplex myP0( 0, 0 );
	for ( i = 0; i < 8; i++ )
	- myP0 += p[i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] + 1 );
	+ myP0 += m_p[i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] + 1 );
	myP0 = EvtConst::pi / alphaS( M_W, n_f, Lambda ) * ( -0.1875 + myP0 );
	myP0 += 1.2468 -
	ksi * 4. / 9. *
	( 3 * C1( mu, n_f, Lambda, M_W ) + C2( mu, n_f, Lambda, M_W ) -
	C3( mu, n_f, Lambda, M_W ) - 3 * C4( mu, n_f, Lambda, M_W ) );
	for ( i = 0; i < 8; i++ )
	- myP0 += pow( eta( mu, n_f, Lambda, M_W ), a[i] ) *
	- ( r[ksi][i] + s[i] * eta( mu, n_f, Lambda, M_W ) );
	+ myP0 += pow( eta( mu, n_f, Lambda, M_W ), m_a[i] ) *
	+ ( m_r[ksi][i] + m_s[i] * eta( mu, n_f, Lambda, M_W ) );
	return myP0;
	}

	@@ -375,7 +375,7 @@
	int i;
	double myPE = 0.1405;
	for ( i = 0; i < 8; i++ )
	- myPE += q[i] * pow( eta( mu, n_f, Lambda, M_W ), a[i] + 1 );
	+ myPE += m_q[i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] + 1 );
	return myPE;
	}

	diff --git a/src/EvtGenModels/EvtXPsiGamma.cpp b/src/EvtGenModels/EvtXPsiGamma.cpp
	--- a/src/EvtGenModels/EvtXPsiGamma.cpp
	+++ b/src/EvtGenModels/EvtXPsiGamma.cpp
	@@ -185,7 +185,7 @@
	parent->getDaug( 1 )->mass() ) );
	}

	- calcAmp( *parent, _amp2 );
	+ calcAmp( *parent, m_amp2 );
	}

	void EvtXPsiGamma::calcAmp( EvtParticle& parent, EvtAmp& amp )
	diff --git a/src/EvtGenModels/EvtbTosllAli.cpp b/src/EvtGenModels/EvtbTosllAli.cpp
	--- a/src/EvtGenModels/EvtbTosllAli.cpp
	+++ b/src/EvtGenModels/EvtbTosllAli.cpp
	@@ -48,9 +48,9 @@
	void EvtbTosllAli::decay( EvtParticle* p )
	{
	setWeight( p->initializePhaseSpace( getNDaug(), getDaugs(), false,
	- _poleSize, 1, 2 ) );
	+ m_poleSize, 1, 2 ) );

	- _calcamp->CalcAmp( p, _amp2, _aliffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_aliffmodel.get() );
	}

	void EvtbTosllAli::initProbMax()
	@@ -62,9 +62,9 @@
	l1num = getDaug( 1 );
	l2num = getDaug( 2 );

	- //This routine sets the _poleSize.
	- double mymaxprob = _calcamp->CalcMaxProb( parnum, mesnum, l1num, l2num,
	- _aliffmodel.get(), _poleSize );
	+ //This routine sets the m_poleSize.
	+ double mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, l1num, l2num,
	+ m_aliffmodel.get(), m_poleSize );
	mymaxprob *= 1.25; // Increase to avoid maxprob errors
	setProbMax( mymaxprob );
	}
	@@ -95,11 +95,11 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::DIRAC );

	- _aliffmodel = std::make_unique<EvtbTosllAliFF>();
	+ m_aliffmodel = std::make_unique<EvtbTosllAliFF>();
	if ( mesontype == EvtSpinType::SCALAR ) {
	- _calcamp = std::make_unique<EvtbTosllScalarAmp>();
	+ m_calcamp = std::make_unique<EvtbTosllScalarAmp>();
	}
	if ( mesontype == EvtSpinType::VECTOR ) {
	- _calcamp = std::make_unique<EvtbTosllVectorAmp>();
	+ m_calcamp = std::make_unique<EvtbTosllVectorAmp>();
	}
	}
	diff --git a/src/EvtGenModels/EvtbTosllBall.cpp b/src/EvtGenModels/EvtbTosllBall.cpp
	--- a/src/EvtGenModels/EvtbTosllBall.cpp
	+++ b/src/EvtGenModels/EvtbTosllBall.cpp
	@@ -48,9 +48,9 @@
	void EvtbTosllBall::decay( EvtParticle* p )
	{
	setWeight( p->initializePhaseSpace( getNDaug(), getDaugs(), false,
	- _poleSize, 1, 2 ) );
	+ m_poleSize, 1, 2 ) );

	- _calcamp->CalcAmp( p, _amp2, _ballffmodel.get() );
	+ m_calcamp->CalcAmp( p, m_amp2, m_ballffmodel.get() );
	}

	void EvtbTosllBall::initProbMax()
	@@ -62,9 +62,9 @@
	l1num = getDaug( 1 );
	l2num = getDaug( 2 );

	- //This routine sets the _poleSize.
	- double mymaxprob = _calcamp->CalcMaxProb( parnum, mesnum, l1num, l2num,
	- _ballffmodel.get(), _poleSize );
	+ //This routine sets the m_poleSize.
	+ double mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, l1num, l2num,
	+ m_ballffmodel.get(), m_poleSize );

	setProbMax( mymaxprob );
	}
	@@ -109,10 +109,10 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::DIRAC );

	- _ballffmodel = std::make_unique<EvtbTosllBallFF>( theFormFactorModel );
	+ m_ballffmodel = std::make_unique<EvtbTosllBallFF>( theFormFactorModel );
	if ( mesontype == EvtSpinType::SCALAR ) {
	- _calcamp = std::make_unique<EvtbTosllScalarAmp>();
	+ m_calcamp = std::make_unique<EvtbTosllScalarAmp>();
	} else if ( mesontype == EvtSpinType::VECTOR ) {
	- _calcamp = std::make_unique<EvtbTosllVectorAmp>();
	+ m_calcamp = std::make_unique<EvtbTosllVectorAmp>();
	}
	}
	diff --git a/src/EvtGenModels/EvtbTosllBallFF.cpp b/src/EvtGenModels/EvtbTosllBallFF.cpp
	--- a/src/EvtGenModels/EvtbTosllBallFF.cpp
	+++ b/src/EvtGenModels/EvtbTosllBallFF.cpp
	@@ -27,14 +27,14 @@

	EvtbTosllBallFF::EvtbTosllBallFF( int ffmodel )
	{
	- _theFFModel = ffmodel;
	+ m_theFFModel = ffmodel;
	}

	void EvtbTosllBallFF::getScalarFF( EvtId parent, EvtId daught, double t,
	double /mass/, double& fp, double& f0,
	double& ft )
	{
	- int model = _theFFModel;
	+ int model = m_theFFModel;

	double m = EvtPDL::getMeanMass( parent );
	double md = EvtPDL::getMeanMass( daught );
	@@ -190,7 +190,7 @@
	double& a0, double& v, double& t1,
	double& t2, double& t3 )
	{
	- int model = _theFFModel;
	+ int model = m_theFFModel;

	double m = EvtPDL::getMeanMass( parent );
	double md = EvtPDL::getMeanMass( daught );
	diff --git a/src/EvtGenModels/EvtbTosllMS.cpp b/src/EvtGenModels/EvtbTosllMS.cpp
	--- a/src/EvtGenModels/EvtbTosllMS.cpp
	+++ b/src/EvtGenModels/EvtbTosllMS.cpp
	@@ -36,12 +36,12 @@

	EvtbTosllMS::~EvtbTosllMS()
	{
	- // if ( _wilscoeff ) delete _wilscoeff;
	- // if ( _msffmodel ) delete _msffmodel;
	- // if ( _calcamp ) delete _calcamp ;
	- delete _wilscoeff;
	- delete _msffmodel;
	- delete _calcamp;
	+ // if ( m_wilscoeff ) delete m_wilscoeff;
	+ // if ( m_msffmodel ) delete m_msffmodel;
	+ // if ( m_calcamp ) delete m_calcamp ;
	+ delete m_wilscoeff;
	+ delete m_msffmodel;
	+ delete m_calcamp;
	}

	// The module name specification
	@@ -102,13 +102,13 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::DIRAC );

	- _msffmodel = new EvtbTosllMSFF();
	- _wilscoeff = new EvtbTosllWilsCoeffNLO();
	+ m_msffmodel = new EvtbTosllMSFF();
	+ m_wilscoeff = new EvtbTosllWilsCoeffNLO();
	if ( mesontype == EvtSpinType::VECTOR ) {
	- _calcamp = new EvtbTosllVectorAmpNew();
	+ m_calcamp = new EvtbTosllVectorAmpNew();
	}
	if ( mesontype == EvtSpinType::SCALAR ) {
	- _calcamp = new EvtbTosllScalarAmpNew();
	+ m_calcamp = new EvtbTosllScalarAmpNew();
	}
	}

	@@ -136,9 +136,10 @@
	double CKM_barrho = getArg( 6 );
	double CKM_bareta = getArg( 7 );

	- mymaxprob = _calcamp->CalcMaxProb( parnum, mesnum, l1num, l2num, _msffmodel,
	- _wilscoeff, mu, Nf, res_swch, ias, CKM_A,
	- CKM_lambda, CKM_barrho, CKM_bareta );
	+ mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, l1num, l2num,
	+ m_msffmodel, m_wilscoeff, mu, Nf,
	+ res_swch, ias, CKM_A, CKM_lambda,
	+ CKM_barrho, CKM_bareta );

	if ( mymaxprob <= 0.0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -169,8 +170,8 @@
	// and
	// the class "EvtbTosllMSFF" is the derived class of the
	// class "EvtbTosllFFNew" (see the file "EvtbTosllMSFF.hh")
	- _calcamp->CalcAmp( p, _amp2, _msffmodel, _wilscoeff, mu, Nf, res_swch, ias,
	- CKM_A, CKM_lambda, CKM_barrho, CKM_bareta );
	+ m_calcamp->CalcAmp( p, m_amp2, m_msffmodel, m_wilscoeff, mu, Nf, res_swch,
	+ ias, CKM_A, CKM_lambda, CKM_barrho, CKM_bareta );

	// EvtGenReport(EVTGEN_NOTICE,"EvtGen") << "\n The function EvtbTosllMS::decay(...) passed with arguments:"
	// << "\n mu = " << mu << " Nf =" << Nf
	diff --git a/src/EvtGenModels/EvtbTosllMSExt.cpp b/src/EvtGenModels/EvtbTosllMSExt.cpp
	--- a/src/EvtGenModels/EvtbTosllMSExt.cpp
	+++ b/src/EvtGenModels/EvtbTosllMSExt.cpp
	@@ -36,9 +36,9 @@

	EvtbTosllMSExt::~EvtbTosllMSExt()
	{
	- delete _msffmodel;
	- if ( _calcamp )
	- delete _calcamp;
	+ delete m_msffmodel;
	+ if ( m_calcamp )
	+ delete m_calcamp;
	}

	// The module name specification
	@@ -102,13 +102,13 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::DIRAC );

	- _msffmodel = new EvtbTosllMSFF();
	- _wilscoeff = new EvtbTosllWilsCoeffNLO();
	+ m_msffmodel = new EvtbTosllMSFF();
	+ m_wilscoeff = new EvtbTosllWilsCoeffNLO();
	if ( mesontype == EvtSpinType::VECTOR ) {
	- _calcamp = new EvtbTosllVectorAmpNewExt();
	+ m_calcamp = new EvtbTosllVectorAmpNewExt();
	}
	if ( mesontype == EvtSpinType::SCALAR ) {
	- _calcamp = new EvtbTosllScalarAmpNewExt();
	+ m_calcamp = new EvtbTosllScalarAmpNewExt();
	}
	}

	@@ -140,10 +140,10 @@
	double ReA10 = getArg( 10 );
	double ImA10 = getArg( 11 );

	- mymaxprob = _calcamp->CalcMaxProb( parnum, mesnum, l1num, l2num, _msffmodel,
	- _wilscoeff, mu, Nf, res_swch, ias, CKM_A,
	- CKM_lambda, CKM_barrho, CKM_bareta, ReA7,
	- ImA7, ReA10, ImA10 );
	+ mymaxprob = m_calcamp->CalcMaxProb( parnum, mesnum, l1num, l2num, m_msffmodel,
	+ m_wilscoeff, mu, Nf, res_swch, ias,
	+ CKM_A, CKM_lambda, CKM_barrho,
	+ CKM_bareta, ReA7, ImA7, ReA10, ImA10 );

	if ( mymaxprob <= 0.0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -178,9 +178,9 @@
	// and
	// the class "EvtbTosllMSFF" is the derived class of the
	// class "EvtbTosllFFNew" (see the file "EvtbTosllMSFF.hh")
	- _calcamp->CalcAmp( p, _amp2, _msffmodel, _wilscoeff, mu, Nf, res_swch, ias,
	- CKM_A, CKM_lambda, CKM_barrho, CKM_bareta, ReA7, ImA7,
	- ReA10, ImA10 );
	+ m_calcamp->CalcAmp( p, m_amp2, m_msffmodel, m_wilscoeff, mu, Nf, res_swch,
	+ ias, CKM_A, CKM_lambda, CKM_barrho, CKM_bareta, ReA7,
	+ ImA7, ReA10, ImA10 );

	// EvtGenReport(EVTGEN_NOTICE,"EvtGen") << "\n The function EvtbTosllMSExt::decay(...) passed with arguments:"
	// << "\n mu = " << mu << " Nf =" << Nf
	diff --git a/src/EvtGenModels/EvtbTosllVectorAmpNew.cpp b/src/EvtGenModels/EvtbTosllVectorAmpNew.cpp
	--- a/src/EvtGenModels/EvtbTosllVectorAmpNew.cpp
	+++ b/src/EvtGenModels/EvtbTosllVectorAmpNew.cpp
	@@ -338,8 +338,6 @@

	EvtTensor4C T1, T2; // hadronic matrix element tensor structures

	- EvtVector4C epsV; // vector meson polarisation vector
	-
	int i; // vector meson polarisations counter

	EvtVector4C lvc11, lvc12; // spin structures for
	diff --git a/src/EvtGenModels/EvtbTosllVectorAmpNewExt.cpp b/src/EvtGenModels/EvtbTosllVectorAmpNewExt.cpp
	--- a/src/EvtGenModels/EvtbTosllVectorAmpNewExt.cpp
	+++ b/src/EvtGenModels/EvtbTosllVectorAmpNewExt.cpp
	@@ -345,8 +345,6 @@

	EvtTensor4C T1, T2; // hadronic matrix element tensor structures

	- EvtVector4C epsV; // vector meson polarisation vector
	-
	int i; // vector meson polarisations counter

	EvtVector4C lvc11, lvc12; // spin structures for
	diff --git a/src/EvtGenModels/Evtbs2llGammaAmp.cpp b/src/EvtGenModels/Evtbs2llGammaAmp.cpp
	--- a/src/EvtGenModels/Evtbs2llGammaAmp.cpp
	+++ b/src/EvtGenModels/Evtbs2llGammaAmp.cpp
	@@ -361,8 +361,6 @@
	EvtVector4C E1, E2;
	EvtComplex E3;

	- EvtVector4C epsG; // photon polarisation vector
	-
	int i; // photon polarisations counter

	EvtVector4C lvc11, lvc12; // spin structures for
	@@ -552,26 +550,30 @@
	CKM_factor = 0.0 * unit1;
	}

	- amp.vertex(
	- i, 1, 1,
	- conj( CKM_factor ) *
	- ( lvc11 * E1 + lac11 * E2 + uniti * lsc11 * E3 + // -?
	- uniti * ( ( ltc11.cont2( hatp ) ) * epsG ) * brammT ) );
	- amp.vertex(
	- i, 1, 0,
	- conj( CKM_factor ) *
	- ( lvc12 * E1 + lac12 * E2 + uniti * lsc12 * E3 + // -?
	- uniti * ( ( ltc12.cont2( hatp ) ) * epsG ) * brammT ) );
	- amp.vertex(
	- i, 0, 1,
	- conj( CKM_factor ) *
	- ( lvc21 * E1 + lac21 * E2 + uniti * lsc21 * E3 + // -?
	- uniti * ( ( ltc21.cont2( hatp ) ) * epsG ) * brammT ) );
	- amp.vertex(
	- i, 0, 0,
	- conj( CKM_factor ) *
	- ( lvc22 * E1 + lac22 * E2 + uniti * lsc22 * E3 + // -?
	- uniti * ( ( ltc22.cont2( hatp ) ) * epsG ) * brammT ) );
	+ amp.vertex( i, 1, 1,
	+ conj( CKM_factor ) *
	+ ( lvc11 * E1 + lac11 * E2 +
	+ uniti * lsc11 * E3 + // -?
	+ uniti * ( ( ltc11.cont2( hatp ) ) * barepsG ) *
	+ brammT ) );
	+ amp.vertex( i, 1, 0,
	+ conj( CKM_factor ) *
	+ ( lvc12 * E1 + lac12 * E2 +
	+ uniti * lsc12 * E3 + // -?
	+ uniti * ( ( ltc12.cont2( hatp ) ) * barepsG ) *
	+ brammT ) );
	+ amp.vertex( i, 0, 1,
	+ conj( CKM_factor ) *
	+ ( lvc21 * E1 + lac21 * E2 +
	+ uniti * lsc21 * E3 + // -?
	+ uniti * ( ( ltc21.cont2( hatp ) ) * barepsG ) *
	+ brammT ) );
	+ amp.vertex( i, 0, 0,
	+ conj( CKM_factor ) *
	+ ( lvc22 * E1 + lac22 * E2 +
	+ uniti * lsc22 * E3 + // -?
	+ uniti * ( ( ltc22.cont2( hatp ) ) * barepsG ) *
	+ brammT ) );
	}

	} else {
	diff --git a/src/EvtGenModels/Evtbs2llGammaISRFSR.cpp b/src/EvtGenModels/Evtbs2llGammaISRFSR.cpp
	--- a/src/EvtGenModels/Evtbs2llGammaISRFSR.cpp
	+++ b/src/EvtGenModels/Evtbs2llGammaISRFSR.cpp
	@@ -34,9 +34,9 @@

	Evtbs2llGammaISRFSR::~Evtbs2llGammaISRFSR()
	{
	- delete _mntffmodel;
	- if ( _calcamp )
	- delete _calcamp;
	+ delete m_mntffmodel;
	+ if ( m_calcamp )
	+ delete m_calcamp;
	}

	// The module name specification
	@@ -101,10 +101,10 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::DIRAC );

	- _mntffmodel = new Evtbs2llGammaFFMNT();
	- _wilscoeff = new EvtbTosllWilsCoeffNLO();
	+ m_mntffmodel = new Evtbs2llGammaFFMNT();
	+ m_wilscoeff = new EvtbTosllWilsCoeffNLO();
	if ( photontype == EvtSpinType::PHOTON ) {
	- _calcamp = new Evtbs2llGammaISRFSRAmp();
	+ m_calcamp = new Evtbs2llGammaISRFSRAmp();
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "The init()-function in the Evtbs2llGammaISRFSR generator:"
	@@ -140,10 +140,11 @@
	if ( getNArg() == 11 )
	mumumass_min = getArg( 10 );

	- mymaxprob = _calcamp->CalcMaxProb( parnum, photnum, l1num, l2num, _mntffmodel,
	- _wilscoeff, mu, Nf, sr, res_swch, ias,
	- Egamma_min, CKM_A, CKM_lambda,
	- CKM_barrho, CKM_bareta, mumumass_min );
	+ mymaxprob = m_calcamp->CalcMaxProb( parnum, photnum, l1num, l2num,
	+ m_mntffmodel, m_wilscoeff, mu, Nf, sr,
	+ res_swch, ias, Egamma_min, CKM_A,
	+ CKM_lambda, CKM_barrho, CKM_bareta,
	+ mumumass_min );

	if ( mymaxprob <= 0.0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -176,9 +177,9 @@

	// The class "Evtbs2llGammaFFMNT" is the derived class of the
	// class "Evtbs2llGammaFF" (see the file "Evtbs2llGammaFF.hh")
	- _calcamp->CalcAmp( p, _amp2, _mntffmodel, _wilscoeff, mu, Nf, sr, res_swch,
	- ias, Egamma_min, CKM_A, CKM_lambda, CKM_barrho,
	- CKM_bareta, mumumass_min );
	+ m_calcamp->CalcAmp( p, m_amp2, m_mntffmodel, m_wilscoeff, mu, Nf, sr,
	+ res_swch, ias, Egamma_min, CKM_A, CKM_lambda,
	+ CKM_barrho, CKM_bareta, mumumass_min );

	// EvtGenReport(EVTGEN_NOTICE,"EvtGen") << "\n "
	//<< "\n The function Evtbs2llGammaISRFSR::decay(...) passed with arguments:"
	diff --git a/src/EvtGenModels/Evtbs2llGammaISRFSRAmp.cpp b/src/EvtGenModels/Evtbs2llGammaISRFSRAmp.cpp
	--- a/src/EvtGenModels/Evtbs2llGammaISRFSRAmp.cpp
	+++ b/src/EvtGenModels/Evtbs2llGammaISRFSRAmp.cpp
	@@ -385,8 +385,6 @@
	EvtVector4C E1, E2;
	EvtComplex E3;

	- EvtVector4C epsG; // photon polarisation vector
	-
	int i; // photon polarisations counter

	EvtVector4C lvc11, lvc12; // spin structures for
	@@ -578,26 +576,30 @@
	CKM_factor = 0.0 * unit1;
	}

	- amp.vertex(
	- i, 1, 1,
	- conj( CKM_factor ) *
	- ( lvc11 * E1 + lac11 * E2 + uniti * lsc11 * E3 + // -?
	- uniti * ( ( ltc11.cont2( hatp ) ) * epsG ) * brammT ) );
	- amp.vertex(
	- i, 1, 0,
	- conj( CKM_factor ) *
	- ( lvc12 * E1 + lac12 * E2 + uniti * lsc12 * E3 + // -?
	- uniti * ( ( ltc12.cont2( hatp ) ) * epsG ) * brammT ) );
	- amp.vertex(
	- i, 0, 1,
	- conj( CKM_factor ) *
	- ( lvc21 * E1 + lac21 * E2 + uniti * lsc21 * E3 + // -?
	- uniti * ( ( ltc21.cont2( hatp ) ) * epsG ) * brammT ) );
	- amp.vertex(
	- i, 0, 0,
	- conj( CKM_factor ) *
	- ( lvc22 * E1 + lac22 * E2 + uniti * lsc22 * E3 + // -?
	- uniti * ( ( ltc22.cont2( hatp ) ) * epsG ) * brammT ) );
	+ amp.vertex( i, 1, 1,
	+ conj( CKM_factor ) *
	+ ( lvc11 * E1 + lac11 * E2 +
	+ uniti * lsc11 * E3 + // -?
	+ uniti * ( ( ltc11.cont2( hatp ) ) * barepsG ) *
	+ brammT ) );
	+ amp.vertex( i, 1, 0,
	+ conj( CKM_factor ) *
	+ ( lvc12 * E1 + lac12 * E2 +
	+ uniti * lsc12 * E3 + // -?
	+ uniti * ( ( ltc12.cont2( hatp ) ) * barepsG ) *
	+ brammT ) );
	+ amp.vertex( i, 0, 1,
	+ conj( CKM_factor ) *
	+ ( lvc21 * E1 + lac21 * E2 +
	+ uniti * lsc21 * E3 + // -?
	+ uniti * ( ( ltc21.cont2( hatp ) ) * barepsG ) *
	+ brammT ) );
	+ amp.vertex( i, 0, 0,
	+ conj( CKM_factor ) *
	+ ( lvc22 * E1 + lac22 * E2 +
	+ uniti * lsc22 * E3 + // -?
	+ uniti * ( ( ltc22.cont2( hatp ) ) * barepsG ) *
	+ brammT ) );
	}

	} else {
	diff --git a/src/EvtGenModels/Evtbs2llGammaMNT.cpp b/src/EvtGenModels/Evtbs2llGammaMNT.cpp
	--- a/src/EvtGenModels/Evtbs2llGammaMNT.cpp
	+++ b/src/EvtGenModels/Evtbs2llGammaMNT.cpp
	@@ -34,9 +34,9 @@

	Evtbs2llGammaMNT::~Evtbs2llGammaMNT()
	{
	- delete _mntffmodel;
	- if ( _calcamp )
	- delete _calcamp;
	+ delete m_mntffmodel;
	+ if ( m_calcamp )
	+ delete m_calcamp;
	}

	// The module name specification
	@@ -97,10 +97,10 @@
	checkSpinDaughter( 1, EvtSpinType::DIRAC );
	checkSpinDaughter( 2, EvtSpinType::DIRAC );

	- _mntffmodel = new Evtbs2llGammaFFMNT();
	- _wilscoeff = new EvtbTosllWilsCoeffNLO();
	+ m_mntffmodel = new Evtbs2llGammaFFMNT();
	+ m_wilscoeff = new EvtbTosllWilsCoeffNLO();
	if ( photontype == EvtSpinType::PHOTON ) {
	- _calcamp = new Evtbs2llGammaAmp();
	+ m_calcamp = new Evtbs2llGammaAmp();
	} else {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	<< "The init()-function in the Evtbs2llGammaMNT generator:"
	@@ -132,10 +132,10 @@
	double CKM_barrho = getArg( 7 );
	double CKM_bareta = getArg( 8 );

	- mymaxprob = _calcamp->CalcMaxProb( parnum, photnum, l1num, l2num,
	- _mntffmodel, _wilscoeff, mu, Nf,
	- res_swch, ias, Egamma_max, CKM_A,
	- CKM_lambda, CKM_barrho, CKM_bareta );
	+ mymaxprob = m_calcamp->CalcMaxProb( parnum, photnum, l1num, l2num,
	+ m_mntffmodel, m_wilscoeff, mu, Nf,
	+ res_swch, ias, Egamma_max, CKM_A,
	+ CKM_lambda, CKM_barrho, CKM_bareta );

	if ( mymaxprob <= 0.0 ) {
	EvtGenReport( EVTGEN_ERROR, "EvtGen" )
	@@ -164,8 +164,9 @@

	// The class "Evtbs2llGammaFFMNT" is the derived class of the
	// class "Evtbs2llGammaFF" (see the file "Evtbs2llGammaFF.hh")
	- _calcamp->CalcAmp( p, _amp2, _mntffmodel, _wilscoeff, mu, Nf, res_swch, ias,
	- Egamma_max, CKM_A, CKM_lambda, CKM_barrho, CKM_bareta );
	+ m_calcamp->CalcAmp( p, m_amp2, m_mntffmodel, m_wilscoeff, mu, Nf, res_swch,
	+ ias, Egamma_max, CKM_A, CKM_lambda, CKM_barrho,
	+ CKM_bareta );

	// EvtGenReport(EVTGEN_NOTICE,"EvtGen") << "\n "
	// << "\n The function Evtbs2llGammaMNT::decay(...) passed with arguments:"

File Metadata

Mime Type: text/plain
Expires: Mon, Sep 29, 2:32 PM (21 h, 31 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 7a/3f/0bd091ffb75e6d3ffba849dfed26
Default Alt Text: D58.1759152743.diff (1 MB)

D58.1759152743.diffNo OneTemporaryActions

D58.1759152743.diffView Options

File Metadata

Event Timeline

D58.1759152743.diff
No OneTemporary
Actions

D58.1759152743.diff
View Options