diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/Asymmetric_mT2_332_CalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/Asymmetric_mT2_332_CalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7a02fe8511310e5725d7ebf3b1a1272ed657ba5
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/Asymmetric_mT2_332_CalcTool.h
@@ -0,0 +1,109 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_ASYMMETRIC_MT2_332_CALCTOOL_H
+#define STRANSVERSEMASSUTILS_ASYMMETRIC_MT2_332_CALCTOOL_H
+
+//////////////////////////////////////////////
+//C S Cowden			5 Feb 2010
+//Tool to calculate Assymetric mT2 
+//////////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+#include "StransverseMassUtils/mT2Defs.h"
+
+#include "Mt2/Basic_Mt2_Asymmetric332_Calculator.h"
+
+#include<string>
+
+static const InterfaceID IID_Asymmetric_mT2_332_CalcTool("Asymmetric_mT2_332_CalcTool",1,0);
+
+class Asymmetric_mT2_332_CalcTool : public AlgTool {
+public:
+
+  Asymmetric_mT2_332_CalcTool(const std::string& type, const std::string& name, const IInterface *parent);
+
+  static const InterfaceID& interfaceID() { return IID_Asymmetric_mT2_332_CalcTool; }
+
+  ~Asymmetric_mT2_332_CalcTool();
+
+  /** initialize the tool */
+  virtual StatusCode initialize();
+  /** execute the tool */
+  virtual StatusCode execute();
+  /** finalize the tool */
+  virtual StatusCode finalize();
+
+  /** clear pointers */
+  inline void clear();
+  /** set Chi */
+  inline void setChi( double Chi ){ m_Chi = Chi; }
+  /** set momentum for the event */
+  inline StatusCode setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b,Mt2::AtlMET mpt); 
+  inline StatusCode setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b,Mt2::Atl4Vec const mpt);
+  /** calculate Assymetric mT2 */
+  inline StatusCode calc( double &mT2 );
+  /** set ratio of masses */
+  inline void setTheta(double theta){m_theta=theta;}
+
+private:
+
+  Mt2::Basic_Mt2_Asymmetric332_Calculator * m_calc;
+
+  Mt2::LorentzTransverseVector *m_VecA, *m_VecB;
+  Mt2::TwoVector *m_mpt;
+
+  double m_Chi,m_theta;
+
+};
+
+void Asymmetric_mT2_332_CalcTool::clear(){
+  if( m_VecA ){
+    delete m_VecA;
+    m_VecA=NULL;
+  }
+  if( m_VecB ){
+    delete m_VecB;
+    m_VecB=NULL;
+  }
+  if( m_mpt ){
+    delete m_mpt;
+    m_mpt=NULL;
+  }
+}
+
+
+StatusCode Asymmetric_mT2_332_CalcTool::setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b,Mt2::AtlMET mpt){
+  if( !a || !b || !mpt ) return StatusCode::FAILURE;
+
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_mpt = new Mt2::TwoVector(mpt->etx(),mpt->ety());
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode Asymmetric_mT2_332_CalcTool::setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b, Mt2::Atl4Vec const mpt){
+  if( !a || !b || !mpt ) return StatusCode::FAILURE;
+
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_mpt = new Mt2::TwoVector(mpt->px(),mpt->py());
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode Asymmetric_mT2_332_CalcTool::calc(double &mT2){
+  if( !m_VecA || !m_VecB || !m_mpt ) return StatusCode::FAILURE;
+  mT2 = m_calc->mt2_Asymmetric332(m_theta,*m_VecA,*m_VecB,*m_mpt,m_Chi);
+  return StatusCode::SUCCESS;
+}
+
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/M2C_332_CalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/M2C_332_CalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..f295a9cda6a00ea6c24035cc0363b4b5fce98875
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/M2C_332_CalcTool.h
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_M2C_332_CALCTOOL_H
+#define STRANSVERSEMASSUTILS_M2C_332_CALCTOOL_H
+
+//////////////////////////////////////////////
+//C S Cowden			8 Feb 2010
+//Interface tool to calculate m_2C
+/////////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+#include "StransverseMassUtils/mT2Defs.h"
+
+#include "Mt2/Basic_M2C_332_Calculator.h"
+
+#include<string>
+
+static const InterfaceID IID_M2C_332_CalcTool("M2C_332_CalcTool",1,0);
+
+class M2C_332_CalcTool : public AlgTool {
+public:
+
+  M2C_332_CalcTool(const std::string& type,const std::string& name, const IInterface *parent);
+
+  static const InterfaceID& interfaceID(){return IID_M2C_332_CalcTool; }
+
+  ~M2C_332_CalcTool();
+
+  /** initialize the tool */
+  virtual StatusCode initialize();
+  /** execute the tool */
+  virtual StatusCode execute();
+  /** finalize the tool */
+  virtual StatusCode finalize();
+  
+  /** clear pointers */
+  inline void clear();
+  /** set momentum of event */
+  inline StatusCode setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b, Mt2::AtlMET mpt);
+  inline StatusCode setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b, Mt2::Atl4Vec const mpt);
+  /** set Delta M (mass difference read from three body decay end-point ) */
+  inline void setDeltaM(double &Dm){m_DM=Dm;}
+  /** calculate m_2C */
+  inline StatusCode calc( double &m2c );
+
+private:
+  Mt2::LorentzTransverseVector *m_VecA,*m_VecB;
+  Mt2::TwoVector *m_mpt;
+
+  double m_DM;
+
+};
+
+  
+void M2C_332_CalcTool::clear(){
+  if( m_VecA ) {
+    delete m_VecA;
+    m_VecA=NULL;
+  }
+  if( m_VecB ) {
+    delete m_VecB;
+    m_VecB=NULL;
+  }
+  if( m_mpt ){
+    delete m_mpt;
+    m_mpt=NULL;
+  }
+}
+
+StatusCode M2C_332_CalcTool::setMom(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b,Mt2::AtlMET mpt){
+  if( !a || !b || !mpt ) return StatusCode::FAILURE;
+
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_mpt = new Mt2::TwoVector(mpt->etx(),mpt->ety());
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode M2C_332_CalcTool::setMom(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b,Mt2::Atl4Vec const mpt){
+  if( !a || !b || !mpt ) return StatusCode::FAILURE;
+
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_mpt = new Mt2::TwoVector(mpt->px(),mpt->py());
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode M2C_332_CalcTool::calc( double &m2c ){
+  if( !m_VecA || !m_VecB || !m_mpt ) return StatusCode::FAILURE;
+  m2c = M2C_332Calculator(*m_VecA,*m_VecB,*m_mpt,m_DM);
+  return StatusCode::SUCCESS;
+}
+  
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/Nt2_332_CalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/Nt2_332_CalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b1b8f8f6e0df5b2b4c635526a5d78dcb5f2c48f
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/Nt2_332_CalcTool.h
@@ -0,0 +1,115 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_NT2_332_CALCTOOL_H
+#define STRANSVERSEMASSUTILS_NT2_332_CALCTOOL_H
+
+///////////////////////////////////////////////
+//C S Cowden			8 Feb 2010
+//Interface AlgTool to compute Nt2
+///////////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+#include "StransverseMassUtils/mT2Defs.h"
+
+#include "Mt2/Basic_Nt2_332_Calculator.h"
+
+#include<string>
+
+static const InterfaceID IID_Nt2_332_CalcTool("Nt2_332_CalcTool",1,0);
+
+class Nt2_332_CalcTool : public AlgTool {
+public:
+  
+  Nt2_332_CalcTool(const std::string& type, const std::string& name, const IInterface *parent);
+
+  static const InterfaceID& interfaceID() { return IID_Nt2_332_CalcTool; }
+
+  ~Nt2_332_CalcTool();
+
+  /** initialize the tool */
+  virtual StatusCode initialize();
+  /** execute the tool */
+  virtual StatusCode execute();
+  /** finalize the tool */
+  virtual StatusCode finalize();
+
+  /** clear pointers */
+  inline void clear();
+  /** set momentum for the event */
+  inline StatusCode setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b, Mt2::AtlMET mpt);
+  inline StatusCode setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b, Mt2::Atl4Vec const mpt);
+  /** calculate Nt2 */
+  inline StatusCode calc( double &nT2 );
+  /** set parent1 mass */
+  inline void setP1Mass( double &m1 ){ m_P1 = m1; }
+  /** set parent2 mass */
+  inline void setP2Mass( double &m2 ){ m_P2 = m2; }
+  /** set masses */
+  inline void setMass(double &m1, double &m2 ){ m_P1=m1; m_P2=m2; }
+
+private:
+  Mt2::Basic_Nt2_332_Calculator *m_calc;
+
+  Mt2::LorentzTransverseVector *m_VecA,*m_VecB;
+  Mt2::TwoVector *m_mpt;
+
+  double m_P1,m_P2;
+
+};
+
+
+
+
+
+void Nt2_332_CalcTool::clear(){
+  if( m_VecA ){
+    delete m_VecA;
+    m_VecA=NULL;
+  }
+  if( m_VecB ){
+    delete m_VecB;
+    m_VecB=NULL;
+  }
+  if( m_mpt ){
+    delete m_mpt;
+    m_mpt=NULL;
+  }
+}
+
+
+
+
+StatusCode Nt2_332_CalcTool::setMom(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b,Mt2::AtlMET mpt){
+  if( !a || !b || !mpt ) return StatusCode::FAILURE;
+
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_mpt = new Mt2::TwoVector(mpt->etx(),mpt->ety());
+
+  return StatusCode::SUCCESS;
+}  
+
+StatusCode Nt2_332_CalcTool::setMom(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b,Mt2::Atl4Vec const mpt){
+  if( !a || !b || !mpt ) return StatusCode::FAILURE;
+
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_mpt = new Mt2::TwoVector(mpt->px(),mpt->py());
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode Nt2_332_CalcTool::calc( double &nT2 ){
+  if( !m_VecA || !m_VecB || !m_mpt) return StatusCode::FAILURE;
+  nT2 = m_calc->nt2_332(*m_VecA,*m_VecB,*m_mpt,m_P1,m_P2);
+  return StatusCode::SUCCESS;
+}
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mCTCalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mCTCalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..27da0a8d9d29d82820c6f1ba2b919b811ccbec83
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mCTCalcTool.h
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MCTCALCTOOL_H
+#define STRANSVERSEMASSUTILS_MCTCALCTOOL_H
+/////////////////////////////////////////////////////
+//C S Cowden			4 February 2010
+//Tool to calculate mCT.
+/////////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+
+#include "StransverseMassUtils/mT2Defs.h"
+
+
+#include "Mt2/MCT_330_Calculator.h"
+#include "Mt2/Mt2Vectors.h"
+
+#include<string>
+
+static const InterfaceID IID_mCTCalcTool("mCTCalcTool",1,0);
+
+class mCTCalcTool : public AlgTool {
+
+public:
+
+  mCTCalcTool(const std::string& type, const std::string& name,
+	const IInterface* parent);
+
+  static const InterfaceID& interfaceID() { return IID_mCTCalcTool; };
+
+  ~mCTCalcTool();
+
+  /** initialize the tool */
+  virtual StatusCode initialize();
+  /** execute funtion (inherited from AlgTool) */
+  virtual StatusCode execute();
+  /** finalize tool ( delete pointers and stuff ) */
+  virtual StatusCode finalize();
+
+  /** perform calculation */
+  inline StatusCode calc( double &mct );
+  /** setMomentum for event. Return FAILURE if either Mt2::Atl4Vec are NULL */
+  inline StatusCode setMom( Mt2::Atl4Vec const a, Mt2::Atl4Vec const b);
+
+private:
+
+  Mt2::LorentzTransverseVector *m_VecA,*m_VecB;
+
+};
+
+
+StatusCode mCTCalcTool::calc( double &mCT ) {
+  if( !m_VecA || !m_VecB ) return StatusCode::FAILURE;
+  mCT = Mt2::mct_330(*m_VecA,*m_VecB);
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode mCTCalcTool::setMom( Mt2::Atl4Vec const a, Mt2::Atl4Vec const b){
+  if( !a || !b ) return StatusCode::FAILURE;
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+
+  return StatusCode::SUCCESS;
+}
+
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mCTparCalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mCTparCalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d8b47a72c4f46edb096df044d1d5f383bef693e
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mCTparCalcTool.h
@@ -0,0 +1,86 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MCTPARCALCTOOL_H
+#define STRANSVERSEMASSUTILS_MCTPARCALCTOOL_H
+
+///////////////////////////////////////////
+//C S Cowden			5 Feb 2010
+//interface tool to calculate mCT_parallel
+///////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+#include "StransverseMassUtils/mT2Defs.h"
+
+#include "Mt2/MCTll_332_Calculator.h"
+
+#include<string>
+
+static const InterfaceID IID_mCTparCalcTool("mCTparCalcTool",1,0);
+
+class mCTparCalcTool : public AlgTool {
+public:
+
+  mCTparCalcTool(const std::string& type, const std::string& name,
+	const IInterface* parent);
+
+  static const InterfaceID& interfaceID() { return IID_mCTparCalcTool; }
+
+  ~mCTparCalcTool();
+
+  /** initialize the tool */
+  virtual StatusCode initialize();
+  /** execute the tool */
+  virtual StatusCode execute();
+  /** finalize the tool */
+  virtual StatusCode finalize();
+
+  /** clear pointers */
+  inline void clear();
+  /** set momentum */
+  inline StatusCode setMom(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b,Mt2::Atl4Vec const utm);
+  /** calculate mCT_parallel */
+  inline StatusCode calc(double &mCTpar );
+
+private:
+
+  Mt2::LorentzTransverseVector *m_VecA, *m_VecB;
+  Mt2::TwoVector *m_utm;
+
+};
+
+void mCTparCalcTool::clear(){
+  if( m_VecA ){
+    delete m_VecA;
+    m_VecA=NULL;
+  }
+  if( m_VecB ){
+    delete m_VecB;
+    m_VecB=NULL;
+  }
+  if( m_utm ){
+    delete m_utm;
+    m_utm=NULL;
+  }
+}
+
+StatusCode mCTparCalcTool::setMom(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b, Mt2::Atl4Vec const utm){
+  if( !a || !b || !utm ) return StatusCode::FAILURE;
+  
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_utm = new Mt2::TwoVector(utm->px(),utm->py());
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mCTparCalcTool::calc(double &mCTpar ){
+  if( !m_VecA || !m_VecB || !m_utm ) return StatusCode::FAILURE;
+  mCTpar = Mt2::mctll_332(*m_VecA,*m_VecB,*m_utm);
+  return StatusCode::FAILURE;
+}
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mCTperpCalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mCTperpCalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..503e3671b43f2e4fe056634a1ce3075c5a391a7c
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mCTperpCalcTool.h
@@ -0,0 +1,93 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MCTPERPCALCTOOL_H
+#define STRANSVERSEMASSUTILS_MCTPERPCALCTOOL_H
+////////////////////////////////////////////////////
+//C S Cowden			4 Feb 2010
+//An interface tool to the mCT_perp claculators.
+////////////////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+#include "EventKernel/I4Momentum.h"
+
+#include "StransverseMassUtils/mT2Defs.h"
+
+#include "Mt2/MCTT_332_Calculator.h"
+#include "Mt2/Mt2Vectors.h"
+
+#include<string>
+
+static const InterfaceID IID_mCTperpCalcTool("mCTperpCalcTool",1,0);
+
+class mCTperpCalcTool : public AlgTool {
+
+public:
+
+  mCTperpCalcTool(const std::string& type, const std::string& name,
+	const IInterface* parent);
+
+  static const InterfaceID& interfaceID() { return IID_mCTperpCalcTool; }
+
+  ~mCTperpCalcTool();
+
+  /** initialize the tool */
+  virtual StatusCode initialize();
+  /** execute the tool  ( inherited from AlgTool ) */
+  virtual StatusCode execute();
+  /** finalize the tool */
+  virtual StatusCode finalize();
+
+  /** set momentem for calculation, returns FAILURE if either vector is NULL pointer */
+  inline StatusCode setMom( Mt2::Atl4Vec const a, Mt2::Atl4Vec const b, Mt2::Atl4Vec const utm);
+
+  /** clear the event */
+  inline void clear();
+
+  /** calculate the observable */
+  inline StatusCode calc( double & mct );
+
+private:
+
+  Mt2::LorentzTransverseVector *m_VecA, *m_VecB;
+  Mt2::TwoVector *m_utm;
+
+};
+
+
+StatusCode mCTperpCalcTool::setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b, Mt2::Atl4Vec const utm){
+  if( !a || !b || !utm ) return StatusCode::FAILURE;
+
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_utm = new Mt2::TwoVector(utm->px(),utm->py());
+
+  return StatusCode::SUCCESS;
+}
+
+void mCTperpCalcTool::clear(){
+  if(m_VecA){
+    delete m_VecA;
+    m_VecA = NULL;
+  }
+  if(m_VecB){
+    delete m_VecB;
+    m_VecB = NULL;
+  }
+  if(m_utm){
+    delete m_utm;
+    m_utm=NULL;
+  }
+}
+
+StatusCode mCTperpCalcTool::calc(double &mct){
+  if( !m_VecA || !m_VecB || !m_utm ) return StatusCode::FAILURE;
+  mct = Mt2::mctt_332(*m_VecA,*m_VecB,*m_utm);
+  return StatusCode::SUCCESS;
+} 
+
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2Defs.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2Defs.h
new file mode 100644
index 0000000000000000000000000000000000000000..f147929bf0e1f3b520af2b749227574f61857e92
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2Defs.h
@@ -0,0 +1,43 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MT2DEFS_H
+#define STRANSVERSEMASSUTILS_MT2DEFS_H
+
+//////////////////////////////////////////////////
+//mT2Defs
+//This includes some useful typedefs and calculator types.
+//The enum Mt2CalculatorType is a list a available calculator
+//types.  
+//The typedefs are defined to be the necessary base classes
+//of the ESD/AOD level objects one is anticipated to 
+//encounter, so don't worry ElectronAODContainer is full
+//of type<const Electron *> or something.
+//////////////////////////////////////////////////
+
+#include "EventKernel/I4Momentum.h"
+#include "MissingETEvent/MissingET.h"
+
+#include "Mt2/Mt2Vectors.h"
+
+namespace Mt2{
+  enum Mt2_332_CalculatorType{
+    Basic332=0,
+    Bisect
+  };
+
+  enum Mt2_330_CalculatorType{
+    Analytic330=0
+  };
+
+  typedef I4Momentum * Atl4Vec;
+  typedef const MissingET * AtlMET;
+
+
+
+}
+
+
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2Event.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2Event.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe7d7a42f7deabbe3be11f8b6f66cabb279c3c36
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2Event.h
@@ -0,0 +1,27 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MT2EVENT_H
+#define STRANSVERSEMASSUTILS_MT2EVENT_H
+
+////////////////////////////////////////////////////////////////
+//C S Cowde				17 August 2009
+//class to hold mT2 event data; store in storegate svc for 
+//data persistency
+//At the moment this is just filler for perhaps later use.
+///////////////////////////////////////////////////////////////
+
+class mT2Event {
+
+public:
+
+  mT2Event();
+  ~mT2Event();
+
+
+
+
+};
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2Rec.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2Rec.h
new file mode 100644
index 0000000000000000000000000000000000000000..a3c9ca6d4cab7f241243c8f079eced1ae9cc4103
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2Rec.h
@@ -0,0 +1,34 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MT2REC_H
+#define STRANSVERSEMASSUTILS_MT2REC_H
+
+//////////////////////////////////////////////////////////////////
+//C S Cowden					17 August 2009
+//Algorithm to calculate mT2/mTGen and setup mT2 event reconstruction
+//At the moment this is just filler for later use...perhaps.
+//////////////////////////////////////////////////////////////////
+
+#include "GaudiKernel/Algorithm.h"
+
+#include<string>
+
+class mT2Rec : public Algorithm {
+
+public:
+  mT2Rec(const std::string& name, ISvcLocator* pSvcLocator);
+  ~mT2Rec();
+
+  StatusCode initialize();
+  StatusCode execute();
+  StatusCode finalize();
+
+
+
+
+};
+
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2_330_CalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2_330_CalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e6e71c2cbac124f98aa88dea0ef92330b7d41d4
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2_330_CalcTool.h
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MT2_330_CALCTOOL_H
+#define STRANSVERSEMASSUTILS_MT2_330_CALCTOOL_H
+
+//////////////////////////////////////////////
+//C S Cowden			7 Feb 2010
+//Tool to calculate mT2 330 analytically
+/////////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+#include "EventKernel/I4Momentum.h"
+#include "MissingETEvent/MissingET.h"
+
+#include "StransverseMassUtils/mT2Defs.h"
+
+#include "Mt2/Analytic_Mt2_330_Calculator.h"
+#include "Mt2/Mt2Vectors.h"
+
+#include<string>
+
+static const InterfaceID IID_mT2_330_CalcTool("mT2_330_CalcTool",1,0);
+
+class mT2_330_CalcTool : public AlgTool {
+
+public:
+
+  mT2_330_CalcTool(const std::string& type, const std::string& name,
+	const IInterface* parent);
+
+  static const InterfaceID& interfaceID() { return IID_mT2_330_CalcTool; };
+
+  ~mT2_330_CalcTool();
+
+  virtual StatusCode initialize();
+  virtual StatusCode execute();
+  virtual StatusCode finalize();
+
+  inline void clear();
+  inline void setChi( double Chi){m_Chi=Chi; }
+  inline StatusCode setType( Mt2::Mt2_330_CalculatorType T );
+  inline StatusCode setMom( Mt2::Atl4Vec const a, Mt2::Atl4Vec const b);
+  inline StatusCode calc(double &mt2);
+
+  private:
+
+  Mt2::Mt2_330_Calculator * m_calc;
+
+  Mt2::LorentzTransverseVector *m_VecA, *m_VecB;  
+
+  double m_Chi;
+  
+
+};
+
+StatusCode mT2_330_CalcTool::calc(double &mt2){
+  if( !m_VecA || !m_VecB ) return StatusCode::FAILURE;
+  mt2 = m_calc->mt2_330(*m_VecA,*m_VecB,m_Chi);
+  return StatusCode::SUCCESS;
+}
+
+void mT2_330_CalcTool::clear(){
+  if(m_VecA){
+    delete m_VecA;
+    m_VecA=NULL;
+  }
+  if(m_VecB){
+    delete m_VecB;
+    m_VecB=NULL;
+  }
+
+}
+
+StatusCode mT2_330_CalcTool::setMom(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b){
+  if( !a || !b ) return StatusCode::FAILURE;
+
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode mT2_330_CalcTool::setType( Mt2::Mt2_330_CalculatorType T){
+  if( m_calc ){
+    delete m_calc;
+    m_calc=NULL;
+  }
+
+  if( T == Mt2::Analytic330 ){
+    m_calc = new Mt2::Analytic_Mt2_330_Calculator();
+    return StatusCode::SUCCESS;
+  }
+
+  return StatusCode::FAILURE;
+}
+
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2_332_CalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2_332_CalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..460e798615a736f21fd170838da3cde0a6b9d343
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mT2_332_CalcTool.h
@@ -0,0 +1,152 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MT2_332_CALCTOOL_H
+#define STRANSVERSEMASSUTILS_MT2_332_CALCTOOL_H
+
+/////////////////////////////////////////////////////////
+//C S Cowden                        17 August 2009
+//Tool to calculate mT2; act as a wrapper to external
+//mT2 library.
+//This class inherits from the AlgTool base class and can
+//be added to an Athena Algorithm in a standard way using
+//the tool handles.  It should be fairly easy to expand
+//this class as new mT2 calculators are introduced by users
+//and developers.
+/////////////////////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+#include "EventKernel/I4Momentum.h"
+#include "MissingETEvent/MissingET.h"
+
+#include "StransverseMassUtils/mT2Defs.h"
+
+#include "Mt2/Basic_Mt2_332_Calculator.h"
+#include "Mt2/TemporaryZhenyuHanWrapper_Mt2_332_Calculator.h"
+#include "Mt2/Mt2Vectors.h"
+
+#include<string>
+
+static const InterfaceID IID_mT2_332_CalcTool("mT2_332_CalcTool",1,0);
+
+class mT2_332_CalcTool : public AlgTool {
+
+public:
+
+  mT2_332_CalcTool(const std::string& type, const std::string& name,
+	const IInterface* parent);
+
+  static const InterfaceID& interfaceID() { return IID_mT2_332_CalcTool; };
+
+  ~mT2_332_CalcTool();
+
+  virtual StatusCode initialize();
+  /** initialize the tool with an event in mind and Chi mass */
+  StatusCode initialize(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b,Mt2::AtlMET mpt,double Chi); 
+  virtual StatusCode execute();
+  virtual StatusCode finalize();
+
+  /** calculate mt2 */
+  inline StatusCode calc(double &mt2);
+
+
+  /** set the Chi guess mass */
+  inline void setChi(double Chi){ m_Chi=Chi; }
+  /** set event momenta */
+  inline StatusCode setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b,Mt2::AtlMET mpt);
+  inline StatusCode setMom(Mt2::Atl4Vec const a, Mt2::Atl4Vec const b,Mt2::Atl4Vec mpt);
+  /** unset event momenta */
+  inline void clear();
+
+  /** set the type of mt2 calculator 
+   type are defined in mT2Defs.h*/
+  inline StatusCode setType(Mt2::Mt2_332_CalculatorType T);
+
+private:
+
+  Mt2::Basic_Mt2_332_Calculator *m_Basic_mt2;
+  Mt2::TemporaryZhenyuHanWrapper_Mt2_332_Calculator *m_Bisect_mt2;
+
+  Mt2::Mt2_332_Calculator *m_calc;
+
+  Mt2::LorentzTransverseVector *m_VecA,*m_VecB;
+  Mt2::TwoVector *m_mpt;
+
+  double m_Chi;
+
+
+};
+
+
+StatusCode mT2_332_CalcTool::calc(double& mt2){
+  if( !m_VecA || !m_VecB || !m_mpt ) return StatusCode::FAILURE;
+  mt2 = m_calc->mt2_332(*m_VecA,*m_VecB,*m_mpt,m_Chi);
+  return StatusCode::SUCCESS;
+}
+
+void mT2_332_CalcTool::clear(){
+  if(m_VecA){
+    delete m_VecA;
+    m_VecA=NULL;
+  }
+  if(m_VecB){
+    delete m_VecB;
+    m_VecB=NULL;
+  }
+  if(m_mpt){
+    delete m_mpt;
+    m_mpt=NULL;
+  }
+}
+
+StatusCode mT2_332_CalcTool::setMom(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b,Mt2::AtlMET mpt){
+
+  if( !a || !b || !mpt ) return StatusCode::FAILURE;
+
+  this->clear();
+
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_mpt = new Mt2::TwoVector(mpt->etx(),mpt->ety());
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mT2_332_CalcTool::setMom(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b,Mt2::Atl4Vec const mpt){
+
+  if( !a || !b || !mpt ) return StatusCode::FAILURE;
+
+  this->clear();
+ 
+  m_VecA = new Mt2::LorentzTransverseVector(a->et(),a->px(),a->py());
+  m_VecB = new Mt2::LorentzTransverseVector(b->et(),b->px(),b->py());
+  m_mpt = new Mt2::TwoVector(mpt->px(),mpt->py());
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mT2_332_CalcTool::setType(Mt2::Mt2_332_CalculatorType T){
+
+  if( m_calc ){
+    delete m_calc;
+    m_calc=NULL;
+  }
+
+  if( T == Mt2::Basic332 ){
+    m_calc = new Mt2::Basic_Mt2_332_Calculator();
+    //m_calc=m_Basic_mt2;
+    return StatusCode::SUCCESS;
+  }
+  else if ( T == Mt2::Bisect ){ 
+    m_calc = new Mt2::TemporaryZhenyuHanWrapper_Mt2_332_Calculator();
+    //m_calc=m_Bisect_mt2;
+    return StatusCode::SUCCESS;
+  }
+  else return StatusCode::FAILURE;
+}
+
+
+#endif
+
+
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mTGen_330_CalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mTGen_330_CalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..99eb9913bd4cba07d0f12eae7f570af8d5967a89
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mTGen_330_CalcTool.h
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MTGEN_330_CALCTOOL_H
+#define STRANSVERSEMASSUTILS_MTGEN_330_CALCTOOL_H
+
+////////////////////////////////////////////////
+//C S Cowden			Feb 2010
+//Tool to calculate mTGen 330 using an analytic solution
+////////////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+#include "EventKernel/I4Momentum.h"
+#include "MissingETEvent/MissingET.h"
+
+#include "StransverseMassUtils/mT2Defs.h"
+
+#include "Mt2/Basic_MtGen_330_Calculator.h"
+#include "Mt2/Analytic_Mt2_330_Calculator.h"
+#include "Mt2/MtGen_330_Calculator.h"
+#include "Mt2/Mt2Vectors.h"
+
+#include<string>
+
+static const InterfaceID IID_mTGen_330_CalcTool("mTGen_330_CalcTool",1,0);
+
+class mTGen_330_CalcTool : public AlgTool {
+
+public:
+  
+  mTGen_330_CalcTool(const std::string& type, const std::string& name,
+	const IInterface* parent);
+
+  static const InterfaceID& interfaceID() { return IID_mTGen_330_CalcTool; };
+
+  ~mTGen_330_CalcTool();
+
+  virtual StatusCode initialize();
+  virtual StatusCode execute();
+  virtual StatusCode finalize();
+
+  inline void clear();
+  inline StatusCode push_back(Mt2::Atl4Vec const a);
+  inline StatusCode calc(double &mt2);
+  inline void setChi(double Chi){m_mChi=Chi;}
+
+  inline StatusCode setType(Mt2::Mt2_330_CalculatorType T);
+
+private:
+
+  std::vector<Mt2::LorentzVector> m_theEvent;
+
+  Mt2::Mt2_330_Calculator * m_mTGen_Calc;
+  Mt2::Basic_MtGen_330_Calculator * m_mTGen;
+
+  double m_mChi;
+
+};
+
+void mTGen_330_CalcTool::clear(){
+  m_theEvent.clear();
+}
+
+
+StatusCode mTGen_330_CalcTool::push_back(Mt2::Atl4Vec const a){
+  if( !a ) return StatusCode::FAILURE;
+
+  Mt2::LorentzVector::InitEPxPyPz tmpVec(a->e(),a->px(),a->py(),a->pz());
+  m_theEvent.push_back(Mt2::LorentzVector(tmpVec));
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode mTGen_330_CalcTool::calc(double &mt2){
+  mt2=m_mTGen->mtGen_330(m_theEvent,m_mChi);
+  return StatusCode::SUCCESS;
+}
+
+StatusCode  mTGen_330_CalcTool::setType(Mt2::Mt2_330_CalculatorType T){
+  if(m_mTGen_Calc){
+    delete m_mTGen_Calc;
+    m_mTGen_Calc=NULL;
+  }
+  if(m_mTGen){
+    delete m_mTGen;
+    m_mTGen=NULL;
+  }
+
+  if( T == Mt2::Analytic330 ){
+    m_mTGen_Calc = new Mt2::Analytic_Mt2_330_Calculator();
+    m_mTGen = new Mt2::Basic_MtGen_330_Calculator(*m_mTGen_Calc);
+    return StatusCode::SUCCESS;
+  } 
+  else return StatusCode::SUCCESS;
+
+  return StatusCode::SUCCESS;
+}
+
+
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mTGen_332_CalcTool.h b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mTGen_332_CalcTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..93d9ef6e7a7626089aa2ec51c423612fa3e6ec37
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/StransverseMassUtils/mTGen_332_CalcTool.h
@@ -0,0 +1,164 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef STRANSVERSEMASSUTILS_MTGEN332CALCTOOL_H
+#define STRANSVERSEMASSUTILS_MTGEN332CALCTOOL_H
+
+//////////////////////////////////////////////////////////
+//C S Cowden				17 August 2009
+//tool to calculate mTGen; wrapper to external mT2 library
+//This class is similar to the mT2CalcTool also in this 
+//package.  It inherits from the AlgTool bas class and can 
+//also be added to an Athena Algorithm by using the tool 
+//handle method.  It can also be expanded to include new
+//calculator methods.
+//////////////////////////////////////////////////////////
+
+#include "GaudiKernel/AlgTool.h"
+
+#include "EventKernel/INavigable4Momentum.h"
+#include "MissingETEvent/MissingET.h"
+
+#include "StransverseMassUtils/mT2Defs.h"
+
+#include "Mt2/Basic_MtGen_332_Calculator.h"
+#include "Mt2/TemporaryZhenyuHanWrapper_Mt2_332_Calculator.h"
+#include "Mt2/Basic_Mt2_332_Calculator.h"
+#include "Mt2/Mt2_332_Calculator.h"
+#include "Mt2/Mt2Vectors.h"
+
+#include<vector>
+#include<string>
+
+
+static const InterfaceID IID_mTGen_332_CalcTool("mTGen_332_CalcTool",1,0);
+
+class mTGen_332_CalcTool : public AlgTool {
+
+public:
+  mTGen_332_CalcTool(const std::string& type, const std::string& name,
+	const IInterface* parent);
+
+  static const InterfaceID& interfaceID() { return IID_mTGen_332_CalcTool; };
+
+
+  ~mTGen_332_CalcTool();
+
+  virtual StatusCode initialize();
+  virtual StatusCode execute();
+  virtual StatusCode finalize();
+
+  inline void clear();
+  /** add a four vector to the collection to be used in the calculation */
+  inline StatusCode push_back(Mt2::Atl4Vec const a);
+  /** add and MPT two vector */
+  inline StatusCode push_mpt_back(Mt2::AtlMET MET);
+  inline StatusCode push_mpt_back(Mt2::Atl4Vec const a);
+  /** calculate mTGen */
+  inline StatusCode calc(double &mt2);
+  /** set the Chi guess mass */
+  inline void setChi(double Chi){m_mChi=Chi;}
+
+  /** set the type of calculator for mTGen to use */
+  inline StatusCode setType(Mt2::Mt2_332_CalculatorType T);
+
+private:
+
+  std::vector<Mt2::LorentzTransverseVector> m_theEvent;
+  Mt2::TwoVector *m_mpt;
+
+  std::string m_mTGen_CalcType;
+
+
+  Mt2::Mt2_332_Calculator * m_mTGen_Calc;
+  Mt2::Basic_MtGen_332_Calculator * m_mTGen;
+
+  double m_mChi;
+
+
+};
+
+
+void mTGen_332_CalcTool::clear(){
+  m_theEvent.clear();
+  if(m_mpt){
+    delete m_mpt;
+    m_mpt=0;
+  }
+}
+
+StatusCode mTGen_332_CalcTool::push_back(Mt2::Atl4Vec const a){
+  if( !a )return StatusCode::FAILURE;
+
+  m_theEvent.push_back(Mt2::LorentzTransverseVector(a->et(),a->px(),a->py()));
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mTGen_332_CalcTool::push_mpt_back(Mt2::AtlMET MET){
+  if( !MET )return StatusCode::FAILURE;
+
+  if(m_mpt){
+    delete m_mpt;
+    m_mpt=NULL;
+  }
+
+  m_mpt = new Mt2::TwoVector(MET->etx(),MET->ety());
+
+  return StatusCode::SUCCESS;
+}
+
+
+
+StatusCode mTGen_332_CalcTool::push_mpt_back(Mt2::Atl4Vec const a){
+  if( !a ) return StatusCode::FAILURE;
+
+  if(m_mpt){
+    delete m_mpt;
+    m_mpt = NULL;
+  }
+
+  m_mpt = new Mt2::TwoVector(a->px(),a->py());
+
+  return StatusCode::SUCCESS;
+}
+
+
+
+
+StatusCode mTGen_332_CalcTool::calc(double &mt2){
+  if( !m_mpt ) return StatusCode::FAILURE;
+  mt2=m_mTGen->mtGen_332(m_theEvent,*m_mpt,m_mChi);
+  return StatusCode::SUCCESS;
+}
+
+
+
+StatusCode mTGen_332_CalcTool::setType(Mt2::Mt2_332_CalculatorType T){
+  if(m_mTGen_Calc){
+    delete m_mTGen_Calc;
+    m_mTGen_Calc=0;
+  }
+  if(m_mTGen){
+    delete m_mTGen;
+    m_mTGen=0;
+  }
+
+
+  if( T == Mt2::Basic332 ){
+    m_mTGen_Calc = new Mt2::Basic_Mt2_332_Calculator();
+    m_mTGen = new Mt2::Basic_MtGen_332_Calculator(*m_mTGen_Calc);
+    return StatusCode::SUCCESS;
+  } else if ( T == Mt2::Bisect ){
+    m_mTGen_Calc = new Mt2::TemporaryZhenyuHanWrapper_Mt2_332_Calculator();
+    m_mTGen = new Mt2::Basic_MtGen_332_Calculator(*m_mTGen_Calc);
+    return StatusCode::SUCCESS;
+  } 
+  else return StatusCode::FAILURE;
+  
+ return StatusCode::FAILURE;
+}
+
+
+#endif
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/cmt/requirements b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/cmt/requirements
new file mode 100644
index 0000000000000000000000000000000000000000..74b04b4ad2df353d0e248906be389019e7f136f6
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/cmt/requirements
@@ -0,0 +1,37 @@
+package StransverseMassUtils
+author C S Cowden  <cowden@hep.phy.cam.ac.uk>
+
+public
+use AtlasPolicy 	AtlasPolicy-*
+use GaudiInterface	GaudiInterface-* 	External
+
+use EventKernel		EventKernel-*		Event
+use MissingETEvent	MissingETEvent-*	Reconstruction
+#use FourMom		FourMom-*		Event
+
+use AtlasmT2		AtlasmT2-*		External
+use AtlasROOT		AtlasROOT-*		External
+
+macro StransverseMassUtils_linkopts "$(AtlasmT2_linkopts) -lMinuit2"
+macro StransverseMassUtils_cppflags "-I$(AtlasmT2_home)"
+macro StransverseMassUtils_cflags "$(StransverseMassUtils_cppflags)"
+macro StransverseMassUtils_lib "$(AtlasmT2_lib)"
+
+apply_pattern declare_joboptions files="*.py"
+apply_pattern declare_installed_libraries dir=$(StransverseMassUtils_lib)
+
+
+#This is a disgusting thing needed for configurables (I think)
+private
+apply_tag notAsNeeded
+end_private
+#end extremely disgusting CMT rubbish
+
+
+library StransverseMassUtils *.cxx -s=components *.cxx
+#apply_pattern dual_use_library files=*.cxx
+apply_pattern component_library
+
+#private
+#macro cppdebugflags '$(cppdebugflags_s)'
+#macro_remove componentshr_linkopts "-Wl, -s"
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/cmt/version.cmt b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/cmt/version.cmt
new file mode 100644
index 0000000000000000000000000000000000000000..1ce927f84b0b8212d3449c511fc2dbfa4b37ecc4
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/cmt/version.cmt
@@ -0,0 +1 @@
+StransverseMassUtils-00-00-06
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/Asymmetric_mT2_332_CalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/Asymmetric_mT2_332_CalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..8d1e898d1a72a4df923023c854b267234ca840ea
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/Asymmetric_mT2_332_CalcTool.cxx
@@ -0,0 +1,57 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+#include "StransverseMassUtils/Asymmetric_mT2_332_CalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include "Mt2/Basic_Mt2_Asymmetric332_Calculator.h"
+
+#include<string>
+
+Asymmetric_mT2_332_CalcTool::Asymmetric_mT2_332_CalcTool(const std::string& type, const std::string &name,const IInterface *parent):
+  AlgTool(type,name,parent),
+  m_calc(NULL),
+  m_VecA(NULL),m_VecB(NULL),m_mpt(NULL),
+  m_Chi(0.0),m_theta(1.0)
+{
+
+  declareInterface<Asymmetric_mT2_332_CalcTool>( this );
+
+  m_calc = new Mt2::Basic_Mt2_Asymmetric332_Calculator();
+
+}
+
+Asymmetric_mT2_332_CalcTool::~Asymmetric_mT2_332_CalcTool(){
+  if( m_VecA )delete m_VecA;
+  if( m_VecB )delete m_VecB;
+  if( m_mpt )delete m_mpt;
+
+  if( m_calc )delete m_calc;
+}
+
+StatusCode Asymmetric_mT2_332_CalcTool::initialize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode Asymmetric_mT2_332_CalcTool::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Executing" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode Asymmetric_mT2_332_CalcTool::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing " << endreq;
+  
+  this->clear();
+
+  return StatusCode::SUCCESS;
+}
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/M2C_332_CalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/M2C_332_CalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e02f51161fa7904942e1c6bf904ef035b1d09994
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/M2C_332_CalcTool.cxx
@@ -0,0 +1,53 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+#include "StransverseMassUtils/M2C_332_CalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include<string>
+
+#include "Mt2/Basic_M2C_332_Calculator.h"
+
+M2C_332_CalcTool::M2C_332_CalcTool(const std::string& type,const std::string& name, const IInterface *parent) :
+  AlgTool(type,name,parent),
+  m_VecA(NULL),m_VecB(NULL),m_mpt(NULL),
+  m_DM(0.0)
+{
+
+  declareInterface<M2C_332_CalcTool>( this );
+
+}
+
+M2C_332_CalcTool::~M2C_332_CalcTool(){
+  this->clear();
+}
+
+
+StatusCode M2C_332_CalcTool::initialize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode M2C_332_CalcTool::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Executing" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode M2C_332_CalcTool::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing" << endreq;
+
+  this->clear();
+
+  return StatusCode::SUCCESS;
+}
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/Nt2_332_CalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/Nt2_332_CalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d8a3dc661d02f1b6cb91b596324ca296a761fb06
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/Nt2_332_CalcTool.cxx
@@ -0,0 +1,56 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+#include "StransverseMassUtils/Nt2_332_CalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include "Mt2/Basic_Nt2_332_Calculator.h"
+#include<string>
+
+Nt2_332_CalcTool::Nt2_332_CalcTool(const std::string& type, const std::string& name, const IInterface *parent) :
+  AlgTool(type,name,parent),
+  m_calc(NULL),
+  m_VecA(NULL),m_VecB(NULL),m_mpt(NULL),
+  m_P1(0.0),m_P2(0.0)
+  {
+
+  declareInterface<Nt2_332_CalcTool>( this );
+
+  m_calc = new Mt2::Basic_Nt2_332_Calculator();
+
+}
+
+
+Nt2_332_CalcTool::~Nt2_332_CalcTool(){
+  this->clear();
+  if( m_calc ) delete m_calc;
+}
+
+
+StatusCode Nt2_332_CalcTool::initialize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode Nt2_332_CalcTool::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Executing" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode Nt2_332_CalcTool::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing" << endreq;
+
+  this->clear();
+ 
+  return StatusCode::SUCCESS;
+}
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/components/StransverseMassUtils_entries.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/components/StransverseMassUtils_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..70f8b8c47a799962d8c510283852cc01ad9f8b8e
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/components/StransverseMassUtils_entries.cxx
@@ -0,0 +1,44 @@
+#include "GaudiKernel/DeclareFactoryEntries.h"
+
+#include "StransverseMassUtils/mT2_332_CalcTool.h"
+#include "StransverseMassUtils/mT2Rec.h"
+#include "StransverseMassUtils/mTGen_332_CalcTool.h"
+#include "StransverseMassUtils/mCTCalcTool.h"
+#include "StransverseMassUtils/mCTperpCalcTool.h"
+#include "StransverseMassUtils/mT2_330_CalcTool.h"
+#include "StransverseMassUtils/mTGen_330_CalcTool.h"
+#include "StransverseMassUtils/mCTparCalcTool.h"
+#include "StransverseMassUtils/Asymmetric_mT2_332_CalcTool.h"
+#include "StransverseMassUtils/Nt2_332_CalcTool.h"
+#include "StransverseMassUtils/M2C_332_CalcTool.h"
+
+
+DECLARE_ALGORITHM_FACTORY( mT2Rec )
+
+DECLARE_TOOL_FACTORY( mT2_332_CalcTool )
+DECLARE_TOOL_FACTORY( mTGen_332_CalcTool )
+DECLARE_TOOL_FACTORY( mCTCalcTool )
+DECLARE_TOOL_FACTORY( mCTperpCalcTool )
+DECLARE_TOOL_FACTORY( mT2_330_CalcTool )
+DECLARE_TOOL_FACTORY( mTGen_330_CalcTool )
+DECLARE_TOOL_FACTORY( mCTparCalcTool )
+DECLARE_TOOL_FACTORY( Asymmetric_mT2_332_CalcTool )
+DECLARE_TOOL_FACTORY( Nt2_332_CalcTool )
+DECLARE_TOOL_FACTORY( M2C_332_CalcTool )
+
+DECLARE_FACTORY_ENTRIES( StransverseMassUtils ){
+
+  DECLARE_ALGORITHM( mT2Rec )
+
+  DECLARE_TOOL( mT2_332_CalcTool )
+  DECLARE_TOOL( mTGen_332_CalcTool )
+  DECLARE_TOOL( mCTCalcTool )
+  DECLARE_TOOL( mCTperpCalcTool )
+  DECLARE_TOOL( mT2_330_CalcTool )
+  DECLARE_TOOL( mTGen_330_CalcTool )
+  DECLARE_TOOL( mCTparCalcTool )
+  DECLARE_TOOL( Asymmetric_mT2_332_CalcTool )
+  DECLARE_TOOL( Nt2_332_CalcTool )
+  DECLARE_TOOL( M2C_332_CalcTool )
+
+}
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/components/StransverseMassUtils_load.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/components/StransverseMassUtils_load.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..36d51fd93a83e963094db0ef54aa6346ee5f84a5
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/components/StransverseMassUtils_load.cxx
@@ -0,0 +1,2 @@
+#include "GaudiKernel/LoadFactoryEntries.h"
+LOAD_FACTORY_ENTRIES( StransverseMassUtils )
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mCTCalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mCTCalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..3a13745f87afd1734c40aaee49603d0352f1f767
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mCTCalcTool.cxx
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+#include "StransverseMassUtils/mCTCalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include<string>
+
+
+mCTCalcTool::mCTCalcTool(const std::string& type, const std::string& name, const IInterface* parent):
+  AlgTool(type,name,parent),
+  m_VecA(NULL),m_VecB(NULL)
+ 
+ {
+  
+  declareInterface<mCTCalcTool>( this );
+
+}
+
+mCTCalcTool::~mCTCalcTool() { 
+  if(m_VecA)delete m_VecA;
+  if(m_VecB)delete m_VecB;
+}
+
+StatusCode mCTCalcTool::initialize() {
+  MsgStream mLog( msgSvc(), name() );
+  mLog << MSG::DEBUG << "initialize() has been called" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode mCTCalcTool::execute() {
+  MsgStream mLog ( msgSvc(), name() );
+  mLog << MSG::DEBUG << "execute() has been called" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mCTCalcTool::finalize(){
+  MsgStream mLog( msgSvc(), name() );
+  mLog << MSG::DEBUG << "finalize() has been called" << endreq;
+
+  if(m_VecA){
+    delete m_VecA;
+    m_VecA=NULL;
+  }
+  if(m_VecB){
+    delete m_VecB;
+    m_VecB=NULL;
+  }
+
+  return StatusCode::SUCCESS;
+}
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mCTparCalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mCTparCalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..a3ea84ef8091f7109004dd1fe749fedc470ba9b2
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mCTparCalcTool.cxx
@@ -0,0 +1,49 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+#include "StransverseMassUtils/mCTparCalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include<string>
+
+mCTparCalcTool::mCTparCalcTool(const std::string& type, const std::string& name, const IInterface* parent):
+  AlgTool(type,name,parent),
+  m_VecA(NULL),m_VecB(NULL),m_utm(NULL)
+{
+
+  declareInterface<mCTparCalcTool>( this );
+
+}
+
+mCTparCalcTool::~mCTparCalcTool(){
+  if( m_VecA ) delete m_VecA;
+  if( m_VecB ) delete m_VecB;
+  if( m_utm ) delete m_utm;
+}
+
+StatusCode mCTparCalcTool::initialize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mCTparCalcTool::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Executing" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mCTparCalcTool::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing" << endreq;
+
+  this->clear();
+
+  return StatusCode::SUCCESS;
+}
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mCTperpCalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mCTperpCalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..2801a1fe7925290a57713689756a598b317e8bf6
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mCTperpCalcTool.cxx
@@ -0,0 +1,50 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+#include "StransverseMassUtils/mCTperpCalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include<string>
+
+mCTperpCalcTool::mCTperpCalcTool(const std::string& type, const std::string& name, const IInterface* parent):
+  AlgTool(type,name,parent),
+  m_VecA(NULL),m_VecB(NULL),m_utm(NULL)
+  {
+
+  declareInterface<mCTperpCalcTool>( this );
+
+}
+
+mCTperpCalcTool::~mCTperpCalcTool() {
+  if(m_VecA)delete m_VecA;
+  if(m_VecB)delete m_VecB;
+  if(m_utm)delete m_utm;
+ }
+
+
+StatusCode mCTperpCalcTool::initialize(){
+ MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing " << name() << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mCTperpCalcTool::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "executing " << name() << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mCTperpCalcTool::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing " << name() << endreq;
+
+  this->clear();
+
+  return StatusCode::SUCCESS;
+} 
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2Event.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2Event.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..90037603bc52106d015090edae6ee5f6fef67b05
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2Event.cxx
@@ -0,0 +1,11 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#include "StransverseMassUtils/mT2Event.h"
+
+
+mT2Event::mT2Event() { }
+
+mT2Event::~mT2Event() { }
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2Rec.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2Rec.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..0be5dfa4c0bf52571747fa451b4891e8a7a9efd5
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2Rec.cxx
@@ -0,0 +1,35 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#include "StransverseMassUtils/mT2Rec.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+mT2Rec::mT2Rec(const std::string& name, ISvcLocator* pSvcLocator):
+  Algorithm(name,pSvcLocator)
+{ }
+
+mT2Rec::~mT2Rec() { }
+
+StatusCode mT2Rec::initialize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing " << name() << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mT2Rec::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Executing " << name() << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mT2Rec::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing " << name() << endreq;
+
+  return StatusCode::SUCCESS;
+}
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2_330_CalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2_330_CalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..530d052099354cfb11b60167d4002317245037f6
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2_330_CalcTool.cxx
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+#include "StransverseMassUtils/mT2_330_CalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include "Mt2/Analytic_Mt2_330_Calculator.h"
+#include "Mt2/Mt2Vectors.h"
+
+#include<string>
+
+mT2_330_CalcTool::mT2_330_CalcTool(const std::string& type, const std::string& name, const IInterface* parent):
+  AlgTool(type,name,parent)
+  {
+
+  declareInterface<mT2_330_CalcTool>( this );
+
+}
+
+
+mT2_330_CalcTool::~mT2_330_CalcTool() { }
+
+
+
+StatusCode mT2_330_CalcTool::initialize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing " << name() << endreq;
+ 
+  return StatusCode::SUCCESS;
+}
+
+
+
+StatusCode mT2_330_CalcTool::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Executing " << name() << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+
+
+StatusCode mT2_330_CalcTool::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing " << name() << endreq;
+
+  return StatusCode::SUCCESS;
+}
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2_332_CalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2_332_CalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..5936eee8c74f4021b616d3bb36654ed375fa15c2
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mT2_332_CalcTool.cxx
@@ -0,0 +1,90 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+#include "StransverseMassUtils/mT2_332_CalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include "Mt2/Basic_Mt2_332_Calculator.h"
+#include "Mt2/TemporaryZhenyuHanWrapper_Mt2_332_Calculator.h"
+#include "Mt2/Mt2Vectors.h"
+
+#include<string>
+
+
+
+
+// No longer required: class Mt2::Basic_Mt2_332_Calculator;
+
+
+mT2_332_CalcTool::mT2_332_CalcTool(const std::string& type, const std::string& name, const IInterface* parent):
+  AlgTool(type,name,parent),
+  m_Basic_mt2(NULL),m_Bisect_mt2(NULL),m_calc(NULL),
+  m_VecA(NULL),m_VecB(NULL),m_mpt(NULL),
+  m_Chi(0.0)
+{
+
+  declareInterface<mT2_332_CalcTool>( this );
+
+
+}
+
+
+mT2_332_CalcTool::~mT2_332_CalcTool() {
+  if( m_calc ) delete m_calc;
+  if( m_VecA ) delete m_VecA;
+  if( m_VecB ) delete m_VecB;
+  if( m_mpt ) delete m_mpt;
+}
+
+
+
+StatusCode mT2_332_CalcTool::initialize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing " << name() << endreq;
+
+  this->setType( Mt2::Bisect );
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mT2_332_CalcTool::initialize(Mt2::Atl4Vec const a,Mt2::Atl4Vec const b,Mt2::AtlMET mpt,double Chi){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing " << name() << endreq;
+
+  this->setType( Mt2::Bisect );
+  setMom(a,b,mpt);
+  setChi(Chi);
+
+  return StatusCode::SUCCESS;
+
+}
+
+
+StatusCode mT2_332_CalcTool::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Executing " << name() << endreq;
+
+
+  return StatusCode::SUCCESS;
+}
+
+
+
+StatusCode mT2_332_CalcTool::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing " << name() << endreq;
+  
+  if( m_calc ){
+    delete m_calc;
+    m_calc=NULL;
+  }
+
+  return StatusCode::SUCCESS;
+
+}
+
+
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mTGen_330_CalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mTGen_330_CalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..2831304cdeccd3a7d543c4adbef7fd71b6e2a8d8
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mTGen_330_CalcTool.cxx
@@ -0,0 +1,72 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+
+#include "StransverseMassUtils/mTGen_330_CalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include "Mt2/Basic_MtGen_330_Calculator.h"
+#include "Mt2/Mt2_330_Calculator.h"
+#include "Mt2/Mt2Vectors.h"
+
+#include<string>
+
+mTGen_330_CalcTool::mTGen_330_CalcTool(const std::string& type, const std::string& name, const IInterface* parent):
+  AlgTool(type,name,parent),
+  m_mTGen_Calc(NULL),m_mTGen(NULL),
+  m_mChi(0.0)
+{
+
+  declareInterface<mTGen_330_CalcTool>( this );
+
+  m_theEvent.reserve(20);
+
+}
+
+
+mTGen_330_CalcTool::~mTGen_330_CalcTool() { 
+  if(m_mTGen)delete m_mTGen;
+  if(m_mTGen_Calc)delete m_mTGen_Calc;
+}
+
+
+StatusCode mTGen_330_CalcTool::initialize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing " << name() << endreq;
+
+  StatusCode sc = this->setType(Mt2::Analytic330);
+  if( sc.isFailure() ){
+    mLog << MSG::ERROR << "Could not properly setup mTGen 330 mT2 Calculator" << endreq;
+    return sc;
+  }
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mTGen_330_CalcTool::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Executing " << name() << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+
+StatusCode mTGen_330_CalcTool::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing" << endreq;
+
+  if(m_mTGen){
+    delete m_mTGen;
+    m_mTGen=NULL;
+  }
+  if(m_mTGen_Calc){
+    delete m_mTGen_Calc;
+    m_mTGen_Calc=NULL;
+  }
+
+  return StatusCode::SUCCESS;
+}
diff --git a/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mTGen_332_CalcTool.cxx b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mTGen_332_CalcTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e910d4c4d86866d8e0211012ffae54d99b67395e
--- /dev/null
+++ b/PhysicsAnalysis/AnalysisCommon/StransverseMassUtils/src/mTGen_332_CalcTool.cxx
@@ -0,0 +1,66 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+
+#include "StransverseMassUtils/mTGen_332_CalcTool.h"
+
+#include "GaudiKernel/MsgStream.h"
+
+#include "Mt2/Basic_MtGen_332_Calculator.h"
+#include "Mt2/Mt2_332_Calculator.h"
+
+#include<string>
+
+
+mTGen_332_CalcTool::mTGen_332_CalcTool(const std::string& type, const std::string& name,  const IInterface* parent):
+  AlgTool(type,name,parent),
+  m_mpt(NULL),
+  m_mTGen_Calc(NULL),m_mTGen(NULL),
+  m_mChi(0.0)
+{
+
+  declareInterface<mTGen_332_CalcTool>( this );
+
+  m_theEvent.reserve(20); 
+
+
+}
+
+mTGen_332_CalcTool::~mTGen_332_CalcTool() {
+  if(m_mTGen)delete m_mTGen;
+  if(m_mTGen_Calc)delete m_mTGen_Calc;
+   }
+
+StatusCode mTGen_332_CalcTool::initialize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Initializing " << name() << endreq;
+
+  StatusCode sc = this->setType(Mt2::Basic332);
+  if( sc.isFailure() ){
+    mLog << MSG::ERROR << "Could not properly setup mTGen mT2 Calculator" << endreq;
+    return sc;
+  }
+  //m_mTGen = new Mt2::Basic_MtGen_332_Calculator(*m_mTGen_Calc);
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mTGen_332_CalcTool::execute(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Executing " << name() << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode mTGen_332_CalcTool::finalize(){
+  MsgStream mLog(msgSvc(),name());
+  mLog << MSG::DEBUG << "Finalizing " << name() << endreq;
+
+  //delete m_mTGen_Calc;
+  delete m_mTGen;
+  m_mTGen=0;
+
+  return StatusCode::SUCCESS;
+}