diff --git a/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/BremsstrahlungStrategy.h b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/BremsstrahlungStrategy.h
new file mode 100755
index 0000000000000000000000000000000000000000..a29868355b367330480243b4e9ebc92c0028e070
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/BremsstrahlungStrategy.h
@@ -0,0 +1,15 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef BremsstrahlungStrategy_H
+#define BremsstrahlungStrategy_H
+
+#include "MCTruth/TruthStrategy.h"
+class BremsstrahlungStrategy: public TruthStrategy {
+public:
+	BremsstrahlungStrategy(const std::string);
+	bool AnalyzeVertex(const G4Step*);
+};
+
+#endif
diff --git a/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/CaloCatchAllStrategy.h b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/CaloCatchAllStrategy.h
new file mode 100755
index 0000000000000000000000000000000000000000..13c17b97626af07afb1181b27d7e39f11a810ae9
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/CaloCatchAllStrategy.h
@@ -0,0 +1,15 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef CaloCatchAllStrategy_H
+#define CaloCatchAllStrategy_H
+
+#include "MCTruth/TruthStrategy.h"
+class CaloCatchAllStrategy: public TruthStrategy {
+public:
+	CaloCatchAllStrategy(const std::string);
+	bool AnalyzeVertex(const G4Step*);
+};
+
+#endif
diff --git a/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/ComptonStrategy.h b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/ComptonStrategy.h
new file mode 100755
index 0000000000000000000000000000000000000000..4ba689c79babf79b8cc11c7937827687398a702f
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/ComptonStrategy.h
@@ -0,0 +1,15 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ComptonStrategy_H
+#define ComptonStrategy_H
+
+#include "MCTruth/TruthStrategy.h"
+class ComptonStrategy: public TruthStrategy {
+public:
+	ComptonStrategy(const std::string);
+	bool AnalyzeVertex(const G4Step*);
+};
+
+#endif
diff --git a/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/ConversionStrategy.h b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/ConversionStrategy.h
new file mode 100755
index 0000000000000000000000000000000000000000..022028324c3deb77138644c0a867517fd934f88e
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/ConversionStrategy.h
@@ -0,0 +1,15 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ConversionStrategy_H
+#define ConversionStrategy_H
+
+#include "MCTruth/TruthStrategy.h"
+class ConversionStrategy: public TruthStrategy {
+public:
+	ConversionStrategy(const std::string);
+	bool AnalyzeVertex(const G4Step*);
+};
+
+#endif
diff --git a/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/DecayStrategy.h b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/DecayStrategy.h
new file mode 100755
index 0000000000000000000000000000000000000000..4cc089329d7b90dda2087c240ec037315e2135ea
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/DecayStrategy.h
@@ -0,0 +1,15 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DecayStrategy_H
+#define DecayStrategy_H
+
+#include "MCTruth/TruthStrategy.h"
+class DecayStrategy: public TruthStrategy {
+public:
+	DecayStrategy(const std::string);
+	bool AnalyzeVertex(const G4Step*);
+};
+
+#endif
diff --git a/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/HadronicInteractionStrategy.h b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/HadronicInteractionStrategy.h
new file mode 100755
index 0000000000000000000000000000000000000000..f0ed8bd236f38da8ae7dec71b72b5147d87f3f43
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/HadronicInteractionStrategy.h
@@ -0,0 +1,15 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef HadronicInteractionStrategy_H
+#define HadronicInteractionStrategy_H
+
+#include "MCTruth/TruthStrategy.h"
+class HadronicInteractionStrategy: public TruthStrategy {
+public:
+	HadronicInteractionStrategy(const std::string);
+	bool AnalyzeVertex(const G4Step*);
+};
+
+#endif
diff --git a/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/IonizationStrategy.h b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/IonizationStrategy.h
new file mode 100755
index 0000000000000000000000000000000000000000..2918f1a420c156d08fafe668ddce18807efb188a
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/IonizationStrategy.h
@@ -0,0 +1,15 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef IonizationStrategy_H
+#define IonizationStrategy_H
+
+#include "MCTruth/TruthStrategy.h"
+class IonizationStrategy: public TruthStrategy {
+public:
+	IonizationStrategy(const std::string);
+	bool AnalyzeVertex(const G4Step*);
+};
+
+#endif
diff --git a/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/LLPStrategy.h b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/LLPStrategy.h
new file mode 100755
index 0000000000000000000000000000000000000000..045bb5d4a867fb5bf67b6427866ff1b31c914d23
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/LLPStrategy.h
@@ -0,0 +1,18 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef LLPStrategy_H
+#define LLPStrategy_H
+
+#include "MCTruth/TruthStrategy.h"
+
+class LLPStrategy: public TruthStrategy {
+  public:
+   LLPStrategy(const std::string);
+   bool AnalyzeVertex(const G4Step*);
+  private:
+   bool isSUSYParticle(const int) const;
+};
+
+#endif
diff --git a/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/MuonCatchAllStrategy.h b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/MuonCatchAllStrategy.h
new file mode 100755
index 0000000000000000000000000000000000000000..b69e2f38b73f8d436b6e66288cbedb0749ca2b30
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/G4TruthStrategies/MuonCatchAllStrategy.h
@@ -0,0 +1,15 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef MuonCatchAllStrategy_H
+#define MuonCatchAllStrategy_H
+
+#include "MCTruth/TruthStrategy.h"
+class MuonCatchAllStrategy: public TruthStrategy {
+public:
+	MuonCatchAllStrategy(const std::string);
+	bool AnalyzeVertex(const G4Step*);
+};
+
+#endif
diff --git a/Simulation/G4Utilities/G4TruthStrategies/cmt/requirements b/Simulation/G4Utilities/G4TruthStrategies/cmt/requirements
new file mode 100755
index 0000000000000000000000000000000000000000..88b1580a0e52d604e3970a40967f7d4c064aad7a
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/cmt/requirements
@@ -0,0 +1,20 @@
+package G4TruthStrategies
+author ADA <dellacqu@mail.cern.ch>
+
+branches src cmt
+
+use AtlasPolicy         AtlasPolicy-*
+
+use MCTruth 		MCTruth-*		Simulation/G4Sim
+
+private
+use Geant4              Geant4-*                External
+use SimHelpers          SimHelpers-*         Simulation/G4Sim
+use AtlasCLHEP			AtlasCLHEP-*			External
+end_private
+
+include_dirs "$(G4TruthStrategies_root)"
+
+library G4TruthStrategies ../src/*.cxx
+
+apply_pattern installed_library
diff --git a/Simulation/G4Utilities/G4TruthStrategies/doc/mainpage.h b/Simulation/G4Utilities/G4TruthStrategies/doc/mainpage.h
new file mode 100644
index 0000000000000000000000000000000000000000..78af5a99aa83b71b36511c1c87911cdd4b9b6000
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/doc/mainpage.h
@@ -0,0 +1,40 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+@mainpage  G4TruthStrategies
+@author Andrea Dell'Acqua (dellacqu@mail.cern.ch)
+
+@section G4TruthStrategies Introduction
+
+This class provides all the truth strategies to be used in the simulation.  These strategies decide when a vertex will be saved to the truth tree.  Each is constructed and included in G4AtlasApps, where it is also assigned to the appropriate region of the detector.  Cuts for the strategies are all configurable from job options.
+
+@section G4TruthStrategies Class Overview
+
+The truth strategies included in this package are:
+
+ - BremsstrahlungStrategy : For saving hard Brems (in the ID)
+ - CaloCatchAllStrategy : Currently empty
+ - ComptonStrategy : For saving hard compton scatters (in the ID)
+ - ConversionStrategy : For saving photon conversions (in the ID)
+ - DecayStrategy : For saving particle decays (in the ID)
+ - HadronicInteractionStrategy : For saving hadronic interactions (in the ID)
+ - IonizationStrategy : For saving hard ionizations (in the ID)
+ - MuonCatchAllStrategy : For saving hard brems from muons (in the calorimetry)
+
+@ref used_G4TruthStrategies
+
+@ref requirements_G4TruthStrategies
+
+*/
+
+/**
+@page used_G4TruthStrategies Used Packages
+@htmlinclude used_packages.html
+*/
+
+/**
+@page requirements_G4TruthStrategies Requirements
+@include requirements
+*/
diff --git a/Simulation/G4Utilities/G4TruthStrategies/src/BremsstrahlungStrategy.cxx b/Simulation/G4Utilities/G4TruthStrategies/src/BremsstrahlungStrategy.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..3b2c5c0e046cf9d00d8a0730fc1582ae02eb11e9
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/src/BremsstrahlungStrategy.cxx
@@ -0,0 +1,67 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4TruthStrategies/BremsstrahlungStrategy.h"
+#include "SimHelpers/StepHelper.h"
+#include "G4Step.hh"
+#include "G4Track.hh"
+#include <iostream>
+#include <vector>
+
+#include "CLHEP/Units/PhysicalConstants.h"
+
+static BremsstrahlungStrategy Strategy("Bremsstrahlung");
+
+BremsstrahlungStrategy::BremsstrahlungStrategy(const std::string n):
+			TruthStrategy(n)
+{
+	double prim_thr = 100*CLHEP::MeV;
+	double seco_thr = 100*CLHEP::MeV;
+
+	// don't overwrite the values already in the strategy manager
+	if(theTruthManager->GetTruthParameter("BremsPrimaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"BremsPrimaryMinEnergy: setting default value of 100 MeV"<<std::endl;  
+	  theTruthManager->SetTruthParameter("BremsPrimaryMinEnergy",prim_thr);
+	}
+	if(theTruthManager->GetTruthParameter("BremsSecondaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"BremsSecondaryMinEnergy: setting default value of 100 MeV"<<std::endl;  
+	  theTruthManager->SetTruthParameter("BremsSecondaryMinEnergy",seco_thr);
+	}
+}
+
+bool BremsstrahlungStrategy::AnalyzeVertex(const G4Step* aStep)
+{
+
+	
+	static StepHelper sHelper;
+	static double eMinPrimary=theTruthManager->GetTruthParameter("BremsPrimaryMinEnergy");
+	static double eMinSecondary=theTruthManager->GetTruthParameter("BremsSecondaryMinEnergy");
+	sHelper.SetStep(aStep);
+        G4int pSubType = sHelper.GetProcessSubType();
+
+        if(pSubType==fBremsstrahlung)
+	{
+		double trackKEner= aStep->GetPreStepPoint()->GetMomentum().perp();
+		if (trackKEner<eMinPrimary) return true;
+
+ 		std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+		if (tracks.size() != 1) 
+		{	
+			int trackToUse=tracks.size()-1;
+			G4Track* temp=tracks[trackToUse];
+			tracks.clear();
+			tracks.push_back(temp);
+		}
+		if (tracks.size()!=1) log()<<MSG::WARNING<<" BremsstrahlungStrategy: something is VERY wrong then!"<<std::endl;
+		trackKEner= tracks[0]->GetMomentum().perp();
+		if (trackKEner<eMinSecondary) return true;
+		
+		// we register the vertex using TruthManager's appropriate method
+		theTruthManager->SaveSecondaryVertex(aStep->GetTrack(),
+					             aStep->GetPostStepPoint(),
+						     tracks);
+		return true;
+	}
+	else return false;
+}
diff --git a/Simulation/G4Utilities/G4TruthStrategies/src/CaloCatchAllStrategy.cxx b/Simulation/G4Utilities/G4TruthStrategies/src/CaloCatchAllStrategy.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..bb25bcc07729caf87164ebe2341b203f0150e66e
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/src/CaloCatchAllStrategy.cxx
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4TruthStrategies/CaloCatchAllStrategy.h"
+#include "SimHelpers/StepHelper.h"
+#include "G4Step.hh"
+#include <iostream>
+
+#include "CLHEP/Units/PhysicalConstants.h"
+
+static CaloCatchAllStrategy caloStrategy("CALOCatchAll");
+
+CaloCatchAllStrategy::CaloCatchAllStrategy(const std::string n):
+			TruthStrategy(n)
+{
+
+	if(theTruthManager->GetTruthParameter("CaloMuBremsPrimaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"CaloMuBremsPrimaryMinEnergy: setting default value of 1GeV"<<std::endl;
+	  theTruthManager->SetTruthParameter("CaloMuBremsPrimaryMinEnergy", 1000.);
+	}
+	if(theTruthManager->GetTruthParameter("CaloMuBremsSecondaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"CaloMuBremsPrimaryMinEnergy: setting default value of 500MeV"<<std::endl;
+	  theTruthManager->SetTruthParameter("CaloMuBremsSecondaryMinEnergy", 500.);
+	}
+	if(theTruthManager->GetTruthParameter("CaloDecayPrimaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"CaloDecayPrimaryMinEnergy: setting default value of 1GeV"<<std::endl;
+	  theTruthManager->SetTruthParameter("CaloDecayPrimaryMinEnergy",1000.);
+	}
+}
+
+bool CaloCatchAllStrategy::AnalyzeVertex(const G4Step* aStep)
+{
+	static StepHelper sHelper;
+	sHelper.SetStep(aStep);
+	
+	G4int pSubType = sHelper.GetProcessSubType();
+	G4int PDGcode = sHelper.ParticlePDGCode();
+	if((PDGcode==13||PDGcode==-13) && pSubType==fBremsstrahlung)
+	{
+		
+		static double eMuBremsMinPrimary=theTruthManager->GetTruthParameter("CaloMuBremsPrimaryMinEnergy");
+		static double eMuBremsMinSecondary=theTruthManager->GetTruthParameter("CaloMuBremsSecondaryMinEnergy");
+		
+		//primary tracks
+	        double trackKEner=aStep->GetPreStepPoint()->GetKineticEnergy()/CLHEP::MeV;
+		if (trackKEner<eMuBremsMinPrimary){
+	                return true;
+	        }
+		//secondary tracks
+		std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+		if (tracks.size() != 1)
+		{
+			int trackToUse=tracks.size()-1;
+			G4Track* temp=tracks[trackToUse];
+			tracks.clear();
+			tracks.push_back(temp);
+		}
+		if (tracks.size()!=1) log()<<MSG::WARNING<<" CaloCatchAllStrategy: something is VERY wrong then!"<<std::endl;
+		trackKEner=tracks[0]->GetKineticEnergy();
+		if (trackKEner<eMuBremsMinSecondary) return true;
+
+		// we register the vertex using TruthManager's appropriate method
+		theTruthManager->SaveSecondaryVertex(aStep->GetTrack(),
+			aStep->GetPostStepPoint(),tracks);
+		return true;
+	}//MuBrems
+	else return false;
+	
+	return true;
+}
diff --git a/Simulation/G4Utilities/G4TruthStrategies/src/ComptonStrategy.cxx b/Simulation/G4Utilities/G4TruthStrategies/src/ComptonStrategy.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..0fcf6aa2e42886bc482765ec3732bc9f11d57393
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/src/ComptonStrategy.cxx
@@ -0,0 +1,69 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4TruthStrategies/ComptonStrategy.h"
+#include "SimHelpers/StepHelper.h"
+#include "G4Step.hh"
+#include "G4Track.hh"
+#include <iostream>
+#include <vector>
+
+#include "CLHEP/Units/PhysicalConstants.h"
+
+static ComptonStrategy Strategy("Compton");
+
+ComptonStrategy::ComptonStrategy(const std::string n):
+			TruthStrategy(n)
+{
+	double prim_thr = 100*CLHEP::MeV;
+	double seco_thr = 100*CLHEP::MeV;
+
+	// don't overwrite the values already in the strategy manager
+	if(theTruthManager->GetTruthParameter("ComptonPrimaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"ComptonPrimaryMinEnergy: setting default value of 100 MeV"<<std::endl;  
+	  theTruthManager->SetTruthParameter("ComptonPrimaryMinEnergy",prim_thr);
+	}
+	if(theTruthManager->GetTruthParameter("ComptonSecondaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"ComptonSecondaryMinEnergy: setting default value of 100 MeV"<<std::endl;  
+	  theTruthManager->SetTruthParameter("ComptonSecondaryMinEnergy",seco_thr);
+	}
+}
+
+bool ComptonStrategy::AnalyzeVertex(const G4Step* aStep)
+{
+
+	static StepHelper sHelper;
+	static double eMinPrimary=theTruthManager->GetTruthParameter("ComptonPrimaryMinEnergy");
+	static double eMinSecondary=theTruthManager->GetTruthParameter("ComptonSecondaryMinEnergy");
+	sHelper.SetStep(aStep);
+	G4int pSubType = sHelper.GetProcessSubType();
+
+	if(pSubType==fComptonScattering)
+	{
+                double trackKEner= aStep->GetPreStepPoint()->GetMomentum().perp();
+		if (trackKEner<eMinPrimary) return true;
+
+ 		std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+		if (tracks.size() != 1) 
+		{	
+			int trackToUse=tracks.size()-1;
+			G4Track* temp=tracks[trackToUse];
+			tracks.clear();
+			tracks.push_back(temp);
+		}
+		if (tracks.size()!=1) log()<<MSG::WARNING<<" ComptonStrategy: something is VERY wrong then!"<<std::endl;
+                trackKEner= tracks[0]->GetMomentum().perp();
+		if (trackKEner<eMinSecondary) 
+		{
+			return true;
+		}
+		
+		// we register the vertex using TruthManager's appropriate method
+		theTruthManager->SaveSecondaryVertex(aStep->GetTrack(),
+					             aStep->GetPostStepPoint(),
+						     tracks);
+		return true;
+	}
+	else return false;
+}
diff --git a/Simulation/G4Utilities/G4TruthStrategies/src/ConversionStrategy.cxx b/Simulation/G4Utilities/G4TruthStrategies/src/ConversionStrategy.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..37b4071b6444ae156128661fbbe6968402215ef6
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/src/ConversionStrategy.cxx
@@ -0,0 +1,64 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4TruthStrategies/ConversionStrategy.h"
+#include "SimHelpers/StepHelper.h"
+#include "G4Step.hh"
+#include <iostream>
+
+#include "CLHEP/Units/PhysicalConstants.h"
+
+static ConversionStrategy Strategy("Conversion");
+
+ConversionStrategy::ConversionStrategy(const std::string n):
+			TruthStrategy(n)
+{
+	double prim_thr = 100*CLHEP::MeV;
+        double seco_thr = 100*CLHEP::MeV;
+	if(theTruthManager->GetTruthParameter("ConversionPrimaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"ConversionPrimaryMinEnergy: setting default value of 100 MeV"<<std::endl;  
+	  theTruthManager->SetTruthParameter("ConversionPrimaryMinEnergy",prim_thr);
+	}
+	if(theTruthManager->GetTruthParameter("ConversionSecondaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"ConversionSecondaryMinEnergy: setting default value of 100 MeV"<<std::endl;  
+	  theTruthManager->SetTruthParameter("ConversionSecondaryMinEnergy",seco_thr);
+	}	
+}
+
+bool ConversionStrategy::AnalyzeVertex(const G4Step* aStep)
+{
+	static StepHelper sHelper;
+	static double eMinPrimary=theTruthManager->GetTruthParameter("ConversionPrimaryMinEnergy");
+	static double eMinSecondary=theTruthManager->GetTruthParameter("ConversionSecondaryMinEnergy");
+	
+	sHelper.SetStep(aStep);
+	G4int pSubType = sHelper.GetProcessSubType();
+	if(pSubType==fGammaConversion ||
+           pSubType==fGammaConversionToMuMu ||
+           pSubType==fPairProdByCharged)
+	{
+                double trackKEner= aStep->GetPreStepPoint()->GetMomentum().perp();
+		if (trackKEner<eMinPrimary) return true;
+
+		std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+		double secondaryMom = 0.;
+		for (unsigned int i=0;i<tracks.size();i++){
+	                double thisTrackKEner= tracks[i]->GetMomentum().perp();
+			if (thisTrackKEner>secondaryMom) secondaryMom = thisTrackKEner;
+		}
+		if (secondaryMom<eMinSecondary){
+		  return true;
+		}
+	
+		// we register the vertex using TruthManager's appropriate method
+		theTruthManager->SaveSecondaryVertex(0,
+					     aStep->GetPostStepPoint(),
+					     tracks);
+	
+		return true;
+	
+	}
+	else return false;
+	
+}
diff --git a/Simulation/G4Utilities/G4TruthStrategies/src/DecayStrategy.cxx b/Simulation/G4Utilities/G4TruthStrategies/src/DecayStrategy.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..048159add98561dbabaa2402355513f888600e0b
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/src/DecayStrategy.cxx
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4TruthStrategies/DecayStrategy.h"
+#include "SimHelpers/StepHelper.h"
+//#include "MCTruth/EventInformation.h"
+//#include "HepMC/GenParticle.h"
+#include "G4Step.hh"
+#include <iostream>
+
+#include "CLHEP/Units/PhysicalConstants.h"
+
+static DecayStrategy Strategy("Decay");
+
+DecayStrategy::DecayStrategy(const std::string n):
+			TruthStrategy(n)
+{
+	double prim_thr = 100*CLHEP::MeV;
+	double seco_thr = 100*CLHEP::MeV;
+	if(theTruthManager->GetTruthParameter("DecayPrimaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"DecayPrimaryMinEnergy: setting default value of 100 MeV"<<std::endl;
+	  theTruthManager->SetTruthParameter("DecayPrimaryMinEnergy",prim_thr);
+	}
+	if(theTruthManager->GetTruthParameter("DecaySecondaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"DecaySecondaryMinEnergy: setting default value of 100 MeV"<<std::endl;
+	  theTruthManager->SetTruthParameter("DecaySecondaryMinEnergy",seco_thr);
+	}
+}
+
+bool DecayStrategy::AnalyzeVertex(const G4Step* aStep)
+{
+	
+	static StepHelper sHelper;
+	static double eMinPrimary=theTruthManager->GetTruthParameter("DecayPrimaryMinEnergy");
+	static double  eMinSecondary=theTruthManager->GetTruthParameter("DecaySecondaryMinEnergy");
+	
+        sHelper.SetStep(aStep);
+	G4int pSubType = sHelper.GetProcessSubType();
+	if( (pSubType>200 && pSubType<299) || // All kinds of decay processes are included here..................
+            pSubType==fAnnihilation ||
+            pSubType==fAnnihilationToMuMu ||
+            pSubType==fAnnihilationToHadrons )
+	{
+//		EventInformation* eventInfo=theTruthManager->GetEventInformation();
+				
+                double trackKEner= aStep->GetPreStepPoint()->GetMomentum().perp();
+		
+		if (trackKEner<eMinPrimary) return true;
+		
+		double secondaryMom = 0.;
+		std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+                for (unsigned int i=0;i<tracks.size();i++){
+                        double thisTrackKEner= tracks[i]->GetMomentum().perp();
+                        if (thisTrackKEner>secondaryMom) secondaryMom = thisTrackKEner;
+                }
+                if (secondaryMom<eMinSecondary) return true;
+	
+		// we register the vertex using TruthManager's appropriate method
+		theTruthManager->SaveSecondaryVertex(0,
+					     	     aStep->GetPostStepPoint(),
+					     	     tracks);
+	
+		return true;
+	}
+	else return false;
+	
+}
diff --git a/Simulation/G4Utilities/G4TruthStrategies/src/HadronicInteractionStrategy.cxx b/Simulation/G4Utilities/G4TruthStrategies/src/HadronicInteractionStrategy.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..f7b202fc7ac61b2d90425cf71048a7ae5c899f69
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/src/HadronicInteractionStrategy.cxx
@@ -0,0 +1,73 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4TruthStrategies/HadronicInteractionStrategy.h"
+#include "SimHelpers/StepHelper.h"
+#include "G4Step.hh"
+#include "G4Track.hh"
+#include "G4TrackStatus.hh"
+#include "G4ProcessType.hh"
+#include "G4VProcess.hh"
+#include <iostream>
+#include <vector>
+#include <string>
+
+#include "CLHEP/Units/PhysicalConstants.h"
+
+static HadronicInteractionStrategy Strategy("HadronicInteraction");
+
+HadronicInteractionStrategy::HadronicInteractionStrategy(const std::string n):
+			TruthStrategy(n)
+{
+	double prim_thr = 100*CLHEP::MeV;
+	if(theTruthManager->GetTruthParameter("HadronicPrimaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"HadronicPrimaryMinEnergy: setting default value of 100 MeV"<<std::endl;
+	  theTruthManager->SetTruthParameter("HadronicPrimaryMinEnergy",prim_thr);
+	}
+        double seco_thr = 100*CLHEP::MeV;
+        if(theTruthManager->GetTruthParameter("HadronicSecondaryMinEnergy")==0){
+          log()<<MSG::INFO<<"HadronicSecondaryMinEnergy: setting default value of 100 MeV"<<std::endl;  
+          theTruthManager->SetTruthParameter("HadronicSecondaryMinEnergy",seco_thr);
+        }
+}
+
+bool HadronicInteractionStrategy::AnalyzeVertex(const G4Step* aStep)
+{
+	static double eMinPrimary=theTruthManager->GetTruthParameter("HadronicPrimaryMinEnergy");
+	static double eMinSecondary=theTruthManager->GetTruthParameter("HadronicSecondaryMinEnergy");
+	
+ 	static StepHelper sHelper;
+ 	sHelper.SetStep(aStep);
+	G4ProcessType pType=sHelper.GetProcess()->GetProcessType();
+	if(fHadronic==pType)
+	{
+
+	        double trackKEner= aStep->GetPreStepPoint()->GetMomentum().perp();
+	        double secondaryMom = 0.;
+	        if (trackKEner<eMinPrimary){
+			// Check for de-excitation
+	                std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+	                for (unsigned int i=0;i<tracks.size();i++){
+	                        double thisTrackKEner= tracks[i]->GetMomentum().perp();
+	                        if (thisTrackKEner>secondaryMom)secondaryMom=thisTrackKEner;
+	                }
+	                if (secondaryMom<eMinSecondary){
+	                	return true;
+	                }
+		}
+		G4TrackStatus tStatus=aStep->GetTrack()->GetTrackStatus();
+		std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+		if (tStatus==fAlive)
+			theTruthManager->SaveSecondaryVertex(aStep->GetTrack(),
+ 						             aStep->GetPostStepPoint(),
+ 							     	 tracks);
+		else
+			theTruthManager->SaveSecondaryVertex(0,
+ 						             aStep->GetPostStepPoint(),
+ 							     	 tracks);
+		return true;
+	}
+		
+	return false;
+}
diff --git a/Simulation/G4Utilities/G4TruthStrategies/src/IonizationStrategy.cxx b/Simulation/G4Utilities/G4TruthStrategies/src/IonizationStrategy.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..9efa26b121fee5308821d69f589600f370ae34ad
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/src/IonizationStrategy.cxx
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4TruthStrategies/IonizationStrategy.h"
+#include "MCTruth/EventInformation.h"
+#include "MCTruth/TrackInformation.h"
+#include "MCTruth/TrackHelper.h"
+#include "SimHelpers/StepHelper.h"
+#include "G4Step.hh"
+#include "G4Track.hh"
+#include <iostream>
+#include <vector>
+
+#include "CLHEP/Units/PhysicalConstants.h"
+
+static IonizationStrategy Strategy("Ionization");
+
+IonizationStrategy::IonizationStrategy(const std::string n):
+			TruthStrategy(n)
+{
+	
+	double prim_thr = 100*CLHEP::MeV;
+        double seco_thr = 100*CLHEP::MeV;
+	if(theTruthManager->GetTruthParameter("IonizationPrimaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"IonizationPrimaryMinEnergy: setting default value of 100 MeV"<<std::endl;
+	  theTruthManager->SetTruthParameter("IonizationPrimaryMinEnergy",prim_thr);
+	}
+	if(theTruthManager->GetTruthParameter("IonizationSecondaryMinEnergy")==0){
+	  log()<<MSG::INFO<<"IonizationSecondaryMinEnergy: setting default value of 100 MeV"<<std::endl;
+	  theTruthManager->SetTruthParameter("IonizationSecondaryMinEnergy",seco_thr);
+	}
+}
+
+bool IonizationStrategy::AnalyzeVertex(const G4Step* aStep)
+{
+	
+	static StepHelper sHelper;
+	static double eMinPrimary=theTruthManager->GetTruthParameter("IonizationPrimaryMinEnergy");
+	static double eMinSecondary=theTruthManager->GetTruthParameter("IonizationSecondaryMinEnergy");
+	
+        sHelper.SetStep(aStep);
+	G4int pSubType = sHelper.GetProcessSubType();
+	if(pSubType==fIonisation ||
+           pSubType==fPhotoElectricEffect)
+	{
+			
+                double trackKEner= aStep->GetPreStepPoint()->GetMomentum().perp();
+		if (trackKEner<eMinPrimary) return true;
+		
+		std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+		if (tracks.size() > 1) 
+		{	
+			int trackToUse=tracks.size()-1;
+			G4Track* temp=tracks[trackToUse];
+			tracks.clear();
+			tracks.push_back(temp);
+		}
+		if (tracks.size()!=1) log()<<MSG::WARNING<<" IonizationStrategy: something is VERY wrong then!"<<std::endl;
+                trackKEner= tracks[0]->GetMomentum().perp();
+		if (trackKEner<eMinSecondary) return true;
+		
+		// we register the vertex using TruthManager's appropriate method
+		theTruthManager->SaveSecondaryVertex(aStep->GetTrack(),
+					             aStep->GetPostStepPoint(),
+						     tracks);
+		return true;
+	}
+	
+	else return false;
+}
diff --git a/Simulation/G4Utilities/G4TruthStrategies/src/LLPStrategy.cxx b/Simulation/G4Utilities/G4TruthStrategies/src/LLPStrategy.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..0bc76d3c960d91aea1b924dad0516a514b1f190b
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/src/LLPStrategy.cxx
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4TruthStrategies/LLPStrategy.h"
+#include "SimHelpers/StepHelper.h"
+#include "MCTruth/EventInformation.h"
+#include "G4Step.hh"
+#include "G4ProcessType.hh"
+#include "G4VProcess.hh"
+#include <iostream>
+
+static LLPStrategy Strategy("LLP");
+
+LLPStrategy::LLPStrategy(const std::string n)
+  : TruthStrategy(n)
+{;}
+
+bool LLPStrategy::AnalyzeVertex(const G4Step* aStep)
+{
+  static StepHelper sHelper;
+
+  sHelper.SetStep(aStep);
+  G4int pSubType = sHelper.GetProcessSubType();
+  if( (pSubType>200 && pSubType<299) ){ // All kinds of decay processes are included here...
+
+    // Check if this is a sparticle - if not, return
+    int pdg = aStep->GetTrack()->GetDefinition()->GetPDGEncoding();
+    if ( !isSUSYParticle( abs(pdg) ) ) return false;
+
+    // we register the vertex using TruthManager's appropriate method
+    std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+    theTruthManager->SaveSecondaryVertex(0,aStep->GetPostStepPoint(),tracks);
+    std::cout<<"ACHLLP: saved a truth vertex for pdg "<<pdg<<std::endl;
+    return true;
+  }
+
+  G4ProcessType pType=sHelper.GetProcess()->GetProcessType();
+  if(fUserDefined==pType){//save all interactions for user-defined processes, like rhadron interactions
+    G4TrackStatus tStatus=aStep->GetTrack()->GetTrackStatus();
+    std::vector<G4Track*> tracks =theTruthManager->GetSecondaries();
+
+    if (tStatus==fAlive) theTruthManager->SaveSecondaryVertex(aStep->GetTrack(), aStep->GetPostStepPoint(), tracks);
+    else theTruthManager->SaveSecondaryVertex(0, aStep->GetPostStepPoint(), tracks);
+
+    int pdg = aStep->GetTrack()->GetDefinition()->GetPDGEncoding();
+    std::cout<<"ACHLLP: saved a truth interaction fUserDefined for pdg "<<pdg<<std::endl;
+    return true;
+  }
+  
+  return false;	
+}
+
+bool LLPStrategy::isSUSYParticle(const int id) const
+{
+  return ( (id>1000000 && id<1000007) || (id>1000010 && id<1000017) || 
+           (id>2000000 && id<2000007) || (id>2000010 && id<2000017) || // squarks and sleptons
+           (id>1000020 && id<1000026) || (id>1000034 && id<1000040) || // higgses etc 
+           id==1000512 || id==1000522 || id==1000991 || id==1000993 || // R-hadrons
+           id==1000612 || id==1000622 || id==1000632 || id==1000642 || id==1000652 || id==1005211 ||
+           id==1006113 || id==1006211 || id==1006213 || id==1006223 || id==1006311 ||
+           id==1006313 || id==1006321 || id==1006323 || id==1006333 ||
+           id==1009111 || id==1009113 || id==1009211 || id==1009213 || id==1009311 ||
+           id==1009313 || id==1009321 || id==1009323 || id==1009223 || id==1009333 ||
+           id==1092112 || id==1091114 || id==1092114 || id==1092212 || id==1092214 || id==1092224 ||
+           id==1093114 || id==1093122 || id==1093214 || id==1093224 || id==1093314 || id==1093324 || id==1093334 );
+}
+
diff --git a/Simulation/G4Utilities/G4TruthStrategies/src/MuonCatchAllStrategy.cxx b/Simulation/G4Utilities/G4TruthStrategies/src/MuonCatchAllStrategy.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..6feff3e93516eea5e4f6651d9d6af061628b6a52
--- /dev/null
+++ b/Simulation/G4Utilities/G4TruthStrategies/src/MuonCatchAllStrategy.cxx
@@ -0,0 +1,32 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4TruthStrategies/MuonCatchAllStrategy.h"
+#include "SimHelpers/StepHelper.h"
+#include "G4Step.hh"
+
+#include <iostream>
+
+static MuonCatchAllStrategy muonStrategy("DMuonCatchAll");
+
+MuonCatchAllStrategy::MuonCatchAllStrategy(const std::string n):
+			TruthStrategy(n)
+{
+//   std::cout<<"MCTruth::MuonCatchAllStrategy, building strategy "<<n<<std::endl;
+//   std::cout<<" * the strategy "<<n<<
+//             " is not yet associated to a volume, is inactive!!."<<std::endl;
+}
+
+bool MuonCatchAllStrategy::AnalyzeVertex(const G4Step* /*aStep*/)
+{
+   	//static StepHelper sHelper;
+   	//sHelper.SetStep(aStep);
+	//std::cout<<"this is MuonCatchAllStrategy::AnalyzeVertex"<<std::endl;
+   	//std::cout<<"nr. of secondaries in the last step "<<
+   	//	theTruthManager->GetNrOfSecondaries()<<std::endl;
+   	//std::string pName=sHelper.GetProcessName();
+	//std::cout<<pName<<" in MUON with "<<theTruthManager->GetNrOfSecondaries()<<"\n";
+	//if("Decay"==pName)std::cout<<"Decay in MUON"<<std::endl;
+	return true;
+}