diff --git a/CepGen/CMakeLists.txt b/CepGen/CMakeLists.txt
index 1ca3189..e303fde 100644
--- a/CepGen/CMakeLists.txt
+++ b/CepGen/CMakeLists.txt
@@ -1,127 +1,128 @@
 file(GLOB core_sources Core/*.cpp *.cpp)
 file(GLOB phys_sources Physics/*.cpp)
 file(GLOB sf_sources StructureFunctions/*.cpp)
 file(GLOB io_sources IO/GenericExportHandler.cpp IO/TextHandler.cpp)
 file(GLOB hadr_sources Hadronisers/GenericHadroniser.cpp)
 
 include_directories(${PROJECT_SOURCE_DIR})
 
 #----- check the external dependencies for SFs
 
 set(GRV_PATH ${PROJECT_SOURCE_DIR}/External)
 file(GLOB grv_sources ${GRV_PATH}/grv_*.f)
 if(grv_sources)
   message(STATUS "GRV PDFset found in ${grv_sources}!")
   add_definitions(-DGRVPDF)
   list(APPEND sf_sources ${grv_sources})
 else()
   message(STATUS "GRV PDFset not found. Will proceed without it")
 endif()
 
 #----- check the external dependencies for physics utilities
 
 if(alphas_sources)
   list(APPEND phys_sources ${alphas_sources})
 endif()
 
 set(addons_libraries "")
 set(strf_libraries ${GSL_LIB} ${GSL_CBLAS_LIB})
 
 #--- linking with LHAPDF
 
 if(LHAPDF)
   message(STATUS "LHAPDF found in ${LHAPDF}")
   list(APPEND strf_libraries ${LHAPDF})
   include_directories(${LHAPDF_INCLUDE})
 else()
   file(GLOB partonic_sf StructureFunctions/Partonic.cpp)
   list(REMOVE_ITEM sf_sources ${partonic_sf})
 endif()
 
 #--- linking with Pythia 6
 
 if(PYTHIA6)
   message(STATUS "Pythia 6 found in ${PYTHIA6}")
   list(APPEND hadr_sources "Hadronisers/Pythia6Hadroniser.cpp")
   list(APPEND addons_libraries ${PYTHIA6})
   if(PYTHIA6DUMMY)
     message(STATUS "Pythia 6 addons found in ${PYTHIA6DUMMY}")
     list(APPEND addons_libraries ${PYTHIA6DUMMY})
   endif()
 elseif(EXISTS $ENV{PYTHIA6_SRC})
   file(GLOB pythia6_src $ENV{PYTHIA6_SRC})
   message(STATUS "Pythia 6 source found in ${pythia6_src}")
   set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -Wno-tabs -Wno-maybe-uninitialized -Wno-integer-division -Wno-unused-variable -Wno-unused-dummy-argument")
   add_library(pythia6 SHARED ${pythia6_src})
   list(APPEND hadr_sources "Hadronisers/Pythia6Hadroniser.cpp")
   list(APPEND addons_libraries pythia6)
 endif()
 
 #--- linking with Pythia 8
 
 if(PYTHIA8)
   message(STATUS "Pythia 8 found in ${PYTHIA8}")
   message(STATUS "Pythia 8 will be used for LHEF output")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-misleading-indentation")
   include_directories(${PYTHIA8_INCLUDE})
   add_definitions(-DPYTHIA8)
   list(APPEND hadr_sources "Hadronisers/Pythia8Hadroniser.cpp")
   list(APPEND io_sources "IO/PythiaEventInterface.cpp")
   list(APPEND io_sources "IO/LHEFPythiaHandler.cpp")
   list(APPEND addons_libraries ${PYTHIA8} dl)
 endif()
 
 #--- linking with HepMC
 
 if(HEPMC_LIB)
   message(STATUS "HepMC found in ${HEPMC_LIB}")
   if(HEPMC_LIB MATCHES ".*HepMC3.?.so")
     message(STATUS "HepMC version 3 found")
     if(HEPMC_ROOT_LIB)
       message(STATUS "HepMC ROOT I/O library found")
       add_definitions(-DHEPMC3_ROOTIO)
       list(APPEND addons_libraries ${HEPMC_ROOT_LIB})
     endif()
     add_definitions(-DHEPMC3)
   endif()
   list(APPEND io_sources "IO/HepMCHandler.cpp")
   if(NOT PYTHIA8)
     message(STATUS "HepMC will be used for LHEF output")
     list(APPEND io_sources "IO/LHEFHepMCHandler.cpp")
   endif()
   list(APPEND addons_libraries ${HEPMC_LIB})
   include_directories(${HEPMC_INCLUDE})
 endif()
 
 #--- linking with ROOT/Delphes
 
 if(ROOT_FOUND)
   message(STATUS "ROOT found in ${ROOT_LIBRARY_DIR}")
   list(APPEND addons_libraries ${ROOT_LIBRARIES})
   list(APPEND io_sources "IO/ROOTTreeHandler.cpp")
   include_directories(${ROOT_INCLUDE_DIRS})
   link_directories(${ROOT_LIBRARY_DIR})
   if(DELPHES)
     message(STATUS "Delphes found in ${DELPHES}")
     list(APPEND addons_libraries ${DELPHES} ${TBB})
     list(APPEND io_sources "IO/DelphesHandler.cpp")
     include_directories(${DELPHES_INCLUDE})
+    include_directories(${DELPHES_INCLUDE}/external)
     message(STATUS ${DELPHES_INCLUDE})
   endif()
 endif()
 
 #----- build the objects
 
 add_library(CepGenCore SHARED ${core_sources} ${phys_sources} ${sf_sources})
 target_link_libraries(CepGenCore ${CEPGEN_EXTERNAL_CORE_REQS})
 target_link_libraries(CepGenCore ${strf_libraries})
 
 add_library(CepGenAddOns SHARED ${io_sources} ${hadr_sources})
 target_link_libraries(CepGenAddOns ${addons_libraries})
 target_link_libraries(CepGenAddOns CepGenEvent)
 
 #----- installation rules
 
 install(TARGETS CepGenCore DESTINATION lib)
 install(TARGETS CepGenAddOns DESTINATION lib)
 
diff --git a/CepGen/IO/DelphesHandler.cpp b/CepGen/IO/DelphesHandler.cpp
index 6252752..620ee32 100644
--- a/CepGen/IO/DelphesHandler.cpp
+++ b/CepGen/IO/DelphesHandler.cpp
@@ -1,93 +1,123 @@
 #include "CepGen/IO/ExportHandler.h"
 
 #include "CepGen/Parameters.h"
 #include "CepGen/Core/ParametersList.h"
 #include "CepGen/Core/Exception.h"
 
 #include "CepGen/Event/Event.h"
 
 #include "modules/Delphes.h"
 #include "classes/DelphesFactory.h"
 #include "classes/DelphesClasses.h"
 
+#include "ExRootAnalysis/ExRootTreeWriter.h"
+
+#include "TFile.h"
+
 #include <sstream>
 
 namespace cepgen
 {
-  namespace output
+  namespace io
   {
     /**
      * \brief Export handler for Delphes
      * \author Laurent Forthomme <laurent.forthomme@cern.ch>
      * \date Jul 2019
      */
     class DelphesHandler : public GenericExportHandler
     {
       public:
         struct CepGenConfReader : public ExRootConfReader
         {
           using ExRootConfReader::ExRootConfReader;
           void feedParameters( const Parameters& );
         };
         /// Class constructor
         explicit DelphesHandler( const ParametersList& );
         ~DelphesHandler();
 
         void initialise( const Parameters& ) override;
         /// Writer operator
         void operator<<( const Event& ) override;
         void setCrossSection( double, double ) override {}
 
       private:
+        std::unique_ptr<TFile> output_;
+        const std::string input_card_;
         std::unique_ptr<Delphes> delphes_;
+        std::unique_ptr<ExRootConfReader> conf_reader_;
+        std::unique_ptr<ExRootTreeWriter> tree_writer_;
+        TObjArray* out_all_parts_, *out_stab_parts_, *out_partons_;
+        DelphesFactory* factory_;
     };
 
     DelphesHandler::DelphesHandler( const ParametersList& params ) :
-      delphes_( new Delphes )
-    {}
+      GenericExportHandler( "delphes" ),
+      output_( new TFile( params.get<std::string>( "filename", "output.delphes.root" ).c_str(), "recreate" ) ),
+      input_card_( params.get<std::string>( "inputCard", "input.tcl" ) ),
+      delphes_( new Delphes ),
+      conf_reader_( new ExRootConfReader ),
+      tree_writer_( new ExRootTreeWriter( output_.get(), "Delphes") ),
+      out_all_parts_( nullptr ), out_stab_parts_( nullptr ), out_partons_( nullptr ),
+      factory_( nullptr )
+    {
+      conf_reader_->ReadFile( input_card_.c_str() );
+      delphes_->SetTreeWriter( tree_writer_.get() );
+      delphes_->SetConfReader( conf_reader_.get() );
+    }
 
     DelphesHandler::~DelphesHandler()
     {
       delphes_->FinishTask();
+      tree_writer_->Write();
     }
 
     void
     DelphesHandler::initialise( const Parameters& params )
     {
-      CepGenConfReader conf;
+      /*CepGenConfReader conf;
       conf.feedParameters( params );
-      delphes_->SetConfReader( &conf );
+      delphes_->SetConfReader( &conf );*/
+      factory_ = delphes_->GetFactory();
+      out_all_parts_ = delphes_->ExportArray( "allParticles" );
+      out_stab_parts_ = delphes_->ExportArray( "stableParticles" );
+      out_partons_ = delphes_->ExportArray( "partons" );
       delphes_->InitTask();
     }
 
     void
     DelphesHandler::operator<<( const Event& ev )
     {
       delphes_->Clear();
-      auto factory = delphes_->GetFactory();
+      tree_writer_->Clear();
       //...
       for ( const auto& part : ev.particles() ) {
-        auto cand = factory->NewCandidate();
+        auto cand = factory_->NewCandidate();
         cand->PID = part.integerPdgId();
         cand->Status = (int)part.status();
         cand->Charge = part.charge();
         cand->Mass = part.mass();
         const auto& mom = part.momentum();
         cand->Momentum.SetPxPyPzE( mom.px(), mom.py(), mom.pz(), mom.energy() );
         cand->M1 = part.primary() ? 0 : *part.mothers().begin();
         cand->M2 = part.mothers().size() < 2 ? 0 : *part.mothers().rbegin();
         cand->D1 = part.daughters().empty() ? -1 : *part.daughters().begin();
         cand->D2 = part.daughters().size() < 2 ? -1 : *part.daughters().rbegin();
+        out_all_parts_->Add( cand );
+        if ( cand->Status == 1 )
+          out_stab_parts_->Add( cand );
       }
       //...
       delphes_->ProcessTask();
+      tree_writer_->Fill();
     }
 
     void
     DelphesHandler::CepGenConfReader::feedParameters( const Parameters& params )
     {
     }
   }
 }
 
 REGISTER_IO_MODULE( delphes, DelphesHandler )
diff --git a/cmake/UseEnvironment.cmake b/cmake/UseEnvironment.cmake
index d484063..68f5da3 100644
--- a/cmake/UseEnvironment.cmake
+++ b/cmake/UseEnvironment.cmake
@@ -1,93 +1,93 @@
 if(NOT CMAKE_VERSION VERSION_LESS 3.1)
   set(CMAKE_CXX_STANDARD 14)
 else()
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
 endif()
 set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -Wall -cpp")
 #--- check if we are at CERN
 if($ENV{HOSTNAME} MATCHES "^lxplus[0-9]+.cern.ch")
   set(IS_LXPLUS "yes")
 endif()
 #--- ensure a proper version of the compiler is found
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6.1)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic-errors -g")
 else()
   message(STATUS "clang or gcc above 6.1 is required")
   if(IS_LXPLUS)
     set(LXPLUS_SRC_ENV "source ${CMAKE_SOURCE_DIR}/source-lxplus.sh")
     message(STATUS "Compiling on LXPLUS. Did you properly source the environment variables? E.g.\n\n\t${LXPLUS_SRC_ENV}\n")
   endif()
   message(FATAL_ERROR "Please clean up this build environment, i.e.\n\trm -rf CMake*\nand try again...")
 endif()
 #--- set the default paths for external dependencies
 if(IS_LXPLUS)
   set(BASE_DIR "/cvmfs/sft.cern.ch/lcg")
   list(APPEND CMAKE_PREFIX_PATH "${BASE_DIR}/external/CMake/2.8.9/Linux-i386/share/cmake-2.8/Modules")
   set(GSL_DIR "${BASE_DIR}/releases/GSL/2.5-32fc5/x86_64-centos7-gcc62-opt")
   set(HEPMC_DIR "${BASE_DIR}/releases/HepMC/2.06.09-0a23a/x86_64-centos7-gcc62-opt")
   set(LHAPDF_DIR "${BASE_DIR}/releases/MCGenerators/lhapdf/6.2.2-8a3e6/x86_64-centos7-gcc62-opt")
   set(PYTHIA6_DIR "${BASE_DIR}/releases/MCGenerators/pythia6/429.2-c4089/x86_64-centos7-gcc62-opt")
   set(PYTHIA8_DIR "${BASE_DIR}/releases/MCGenerators/pythia8/240p1-ecd34/x86_64-centos7-gcc62-opt")
   set(DELPHES_DIR "${BASE_DIR}/releases/delphes/3.4.0-03b2c/x86_64-centos7-gcc62-opt")
   set(TBB_DIR "${BASE_DIR}/releases/tbb/2019_U7-ba3eb/x86_64-centos7-gcc62-opt")
   set(PYTHON_DIR "${BASE_DIR}/releases/Python/2.7.15-075d4/x86_64-centos7-gcc62-opt")
   set(PYTHON_LIBRARY "${PYTHON_DIR}/lib/libpython2.7.so")
   set(PYTHON_EXECUTABLE "${PYTHON_DIR}/bin/python")
   set(PYTHON_INCLUDE_DIR "${PYTHON_DIR}/include/python2.7")
 
   message(STATUS "Compiling on LXPLUS. Do not forget to source the environment variables!")
   message(STATUS "e.g. `${LXPLUS_SRC_ENV}`")
 endif()
 #--- searching for GSL
 find_library(GSL_LIB gsl HINTS ${GSL_DIR} PATH_SUFFIXES lib REQUIRED)
 find_library(GSL_CBLAS_LIB gslcblas HINTS ${GSL_DIR} PATH_SUFFIXES lib)
 find_path(GSL_INCLUDE gsl HINTS ${GSL_DIR} PATH_SUFFIXES include)
 include_directories(${GSL_INCLUDE})
 #--- searching for LHAPDF
 find_library(LHAPDF LHAPDF HINTS ${LHAPDF_DIR} PATH_SUFFIXES lib)
 find_path(LHAPDF_INCLUDE LHAPDF HINTS ${LHAPDF_DIR} PATH_SUFFIXES include)
 #--- searching for HepMC
 find_library(HEPMC_LIB NAMES HepMC3 HepMC HINTS ${HEPMC_DIR} PATH_SUFFIXES lib)
 find_library(HEPMC_ROOT_LIB NAMES HepMC3rootIO PATH_SUFFIXES root)
 find_path(HEPMC_INCLUDE NAMES HepMC3 HepMC HINTS ${HEPMC_DIR} PATH_SUFFIXES include)
 #--- searching for Pythia 6
 set(PYTHIA6_DIRS $ENV{PYTHIA6_DIR} ${PYTHIA6_DIR} /usr /usr/local /opt/pythia6)
 find_library(PYTHIA6 pythia6 HINTS ${PYTHIA6_DIRS} PATH_SUFFIXES lib)
 find_library(PYTHIA6DUMMY pythia6_dummy HINTS ${PYTHIA6_DIRS} PATH_SUFFIXES lib)
 #--- searching for Pythia 8
 set(PYTHIA8_DIRS $ENV{PYTHIA8_DIR} ${PYTHIA8_DIR} /usr /usr/local /opt/pythia8)
 find_library(PYTHIA8 pythia8 HINTS ${PYTHIA8_DIRS} PATH_SUFFIXES lib)
 find_path(PYTHIA8_INCLUDE Pythia8 HINTS ${PYTHIA8_DIRS} PATH_SUFFIXES include include/Pythia8 include/pythia8)
 #--- searching for Delphes
-find_library(DELPHES Delphes HINTS ${DELPHES_DIR} PATH_SUFFIXES lib)
-find_path(DELPHES_INCLUDE NAMES modules classes HINTS ${DELPHES_DIR} PATH_SUFFIXES include)
+find_library(DELPHES Delphes HINTS $ENV{DELPHES_DIR} ${DELPHES_DIR} PATH_SUFFIXES lib)
+find_path(DELPHES_INCLUDE NAMES modules classes HINTS $ENV{DELPHES_DIR} ${DELPHES_DIR} PATH_SUFFIXES include)
 #--- searching for tbb
 find_library(TBB tbb HINTS ${TBB_DIR} PATH_SUFFIXES lib)
 #--- searching for ROOT
 find_package(ROOT QUIET)
 
 message(STATUS "GSL found in ${GSL_LIB}")
 list(APPEND CEPGEN_EXTERNAL_CORE_REQS ${GSL_LIB} ${GSL_CBLAS_LIB})
 
 find_package(PythonLibs 2.7)
 find_library(MUPARSER muparser)
 if(MUPARSER)
   message(STATUS "muParser found in ${MUPARSER}")
   list(APPEND CEPGEN_EXTERNAL_CORE_REQS ${MUPARSER})
   add_definitions(-DMUPARSER)
 else()
   find_path(EXPRTK exprtk.hpp PATH_SUFFIXES include)
   if(EXPRTK)
     message(STATUS "exprtk found in ${EXPRTK}")
     add_definitions(-DEXPRTK)
     include_directories(${EXPRTK})
   endif()
 endif()
 #--- semi-external dependencies
 set(ALPHAS_PATH ${PROJECT_SOURCE_DIR}/External)
 file(GLOB alphas_sources ${ALPHAS_PATH}/alphaS.f)
 if(alphas_sources)
   message(STATUS "alphaS evolution found in ${alphas_sources}")
   add_definitions(-DALPHA_S)
 endif()