diff --git a/src/bin/HEJ.cc b/src/bin/HEJ.cc
index 56a7433..399664c 100644
--- a/src/bin/HEJ.cc
+++ b/src/bin/HEJ.cc
@@ -1,435 +1,434 @@
 /**
  *  \authors   The HEJ collaboration (see AUTHORS for details)
  *  \date      2019-2022
  *  \copyright GPLv2 or later
  */
 #include <array>
 #include <chrono>
 #include <iostream>
 #include <limits>
 #include <memory>
 #include <numeric>
 #include <optional>
 
 
 #include "yaml-cpp/yaml.h"
 
 #include "fastjet/ClusterSequence.hh"
 
 #include "HEJ/CombinedEventWriter.hh"
 #include "HEJ/Config.hh"
 #include "HEJ/CrossSectionAccumulator.hh"
 #include "HEJ/Event.hh"
 #include "HEJ/EventReader.hh"
 #include "HEJ/BufferedEventReader.hh"
 #include "HEJ/EventReweighter.hh"
 #include "HEJ/get_analysis.hh"
 #include "HEJ/make_RNG.hh"
 #include "HEJ/ProgressBar.hh"
 #include "HEJ/stream.hh"
 #include "HEJ/Unweighter.hh"
 #include "HEJ/Version.hh"
 #include "HEJ/YAMLreader.hh"
 
 HEJ::Config load_config(char const * filename){
   try{
     return HEJ::load_config(filename);
   }
   catch(std::exception const & exc){
     std::cerr << "Error: " << exc.what() << '\n';
     std::exit(EXIT_FAILURE);
   }
 }
 
 std::vector<std::unique_ptr<HEJ::Analysis>> get_analyses(
     std::vector<YAML::Node> const & parameters, LHEF::HEPRUP const & heprup
 ){
   try{
     return HEJ::get_analyses(parameters, heprup);
   }
   catch(std::exception const & exc){
     std::cerr << "Failed to load analysis: " << exc.what() << '\n';
     std::exit(EXIT_FAILURE);
   }
 }
 
 // unique_ptr is a workaround:
 // std::optional is a better fit, but gives spurious errors with g++ 7.3.0
 std::unique_ptr<HEJ::ProgressBar<double>> make_progress_bar(
     std::vector<double> const & xs
 ) {
   if(xs.empty()) return {};
   const double Born_xs = std::accumulate(begin(xs), end(xs), 0.);
   if(Born_xs == 0.) return {};
   return std::make_unique<HEJ::ProgressBar<double>>(std::cout, Born_xs);
 }
 
 std::string time_to_string(const time_t time){
   char s[30];
   struct tm * p = localtime(&time);
   strftime(s, 30, "%a %b %d %Y %H:%M:%S", p);
   return s;
 }
 
 void check_one_parton_per_jet(HEJ::Event const & ev) {
   const std::size_t npartons = std::count_if(
     ev.outgoing().begin(), ev.outgoing().end(),
     [](HEJ::Particle const & p) { return is_parton(p); }
   );
   if(ev.jets().size() < npartons) {
     throw std::invalid_argument{
       "Number of partons (" + std::to_string(npartons) + ") in input event"
         " does not match number of jets (" + std::to_string(ev.jets().size())+  ")"
       };
   }
 }
 
 HEJ::Event to_event(
     LHEF::HEPEUP const & hepeup,
     HEJ::JetParameters const & fixed_order_jets,
     HEJ::EWConstants const & ew_parameters,
     const double off_shell_tolerance
 ) {
     HEJ::Event::EventData event_data{hepeup};
     event_data.reconstruct_intermediate(ew_parameters);
     event_data.repair_momenta(off_shell_tolerance);
 
     HEJ::Event ev{
       std::move(event_data).cluster(
           fixed_order_jets.def, fixed_order_jets.min_pt
       )
     };
     check_one_parton_per_jet(ev);
     return ev;
 }
 
 void unweight(
   HEJ::Unweighter & unweighter,
   HEJ::WeightType weight_type,
   std::vector<HEJ::Event> & events,
   HEJ::RNG & ran
 ) {
     if(weight_type == HEJ::WeightType::unweighted_resum){
       unweighter.set_cut_to_maxwt(events);
     }
     events.erase(
       unweighter.unweight(begin(events), end(events), ran),
       end(events)
     );
 }
 
 // peek up to nevents events from reader
 std::vector<LHEF::HEPEUP> peek_events(
     HEJ::BufferedEventReader & reader,
     const int nevents
 ) {
   std::vector<LHEF::HEPEUP> events;
   while(
       static_cast<int>(events.size()) < nevents
       && reader.read_event()
   ) {
     events.emplace_back(reader.hepeup());
   }
   // put everything back into the reader
   for(auto it = rbegin(events); it != rend(events); ++it) {
     reader.emplace(*it);
   }
   return events;
 }
 
 void append_resummed_events(
     std::vector<HEJ::Event> & resummation_events,
     HEJ::EventReweighter & reweighter,
     LHEF::HEPEUP const & hepeup,
     const size_t trials,
     HEJ::JetParameters const & fixed_order_jets,
     HEJ::EWConstants const & ew_parameters,
     const double off_shell_tolerance
 ) {
   const HEJ::Event FO_event = to_event(
     hepeup,
     fixed_order_jets,
     ew_parameters,
     off_shell_tolerance
   );
   if(reweighter.treatment(FO_event.type()) != HEJ::EventTreatment::reweight) {
     return;
   }
   const auto resummed = reweighter.reweight(FO_event, trials);
   resummation_events.insert(
       end(resummation_events),
       begin(resummed), end(resummed)
   );
 }
 
 
 void train(
     HEJ::Unweighter & unweighter,
     HEJ::BufferedEventReader & reader,
     HEJ::EventReweighter & reweighter,
     const size_t total_trials,
     const double max_dev,
     double reweight_factor,
     HEJ::JetParameters const & fixed_order_jets,
     HEJ::EWConstants const & ew_parameters,
     const double off_shell_tolerance
 ) {
   std::cout << "Reading up to " << total_trials << " training events...\n";
   auto FO_events = peek_events(reader, total_trials);
   if(FO_events.empty()) {
     throw std::runtime_error{
       "No events generated to calibrate the unweighting weight!"
       "Please increase the number \"trials\" or deactivate the unweighting."
     };
   }
   const size_t trials = total_trials/FO_events.size();
   // adjust reweight factor so that the overall normalisation
   // is the same as in the full run
   reweight_factor *= trials;
   for(auto & hepeup: FO_events) {
     hepeup.XWGTUP *= reweight_factor;
   }
   std::cout << "Training unweighter with "
             << trials << '*' << FO_events.size() << " events\n";
 
   auto progress = HEJ::ProgressBar<int>{
      std::cout, static_cast<int>(FO_events.size())
   };
   std::vector<HEJ::Event> resummation_events;
   for(auto const & hepeup: FO_events) {
     append_resummed_events(
         resummation_events,
         reweighter, hepeup, trials, fixed_order_jets,
         ew_parameters,
         off_shell_tolerance
     );
     ++progress;
   }
 
   unweighter.set_cut_to_peakwt(resummation_events, max_dev);
   std::cout << "\nUnweighting events with weight up to "
             << unweighter.get_cut() << '\n';
 }
 
 int main(int argn, char** argv) {
   using clock = std::chrono::system_clock;
 
   if (argn != 3) {
     std::cerr << "\n# Usage:\n."<< argv[0] <<" config_file input_file\n\n";
     return EXIT_FAILURE;
   }
 
   const auto start_time = clock::now();
   {
     std::cout << "Starting " << HEJ::Version::package_name_full()
       << ", revision " << HEJ::Version::revision() << " ("
       << time_to_string(clock::to_time_t(start_time)) << ")" << std::endl;
   }
   fastjet::ClusterSequence::print_banner();
 
   // read configuration
   const HEJ::Config config = load_config(argv[1]);
   auto reader = HEJ::make_reader(argv[2]);
   assert(reader);
 
   auto heprup{ reader->heprup() };
   heprup.generators.emplace_back(LHEF::XMLTag{});
   heprup.generators.back().name = HEJ::Version::package_name();
   heprup.generators.back().version = HEJ::Version::String();
 
   auto analyses = get_analyses( config.analyses_parameters, heprup );
   assert(analyses.empty() || analyses.front() != nullptr);
 
   HEJ::CombinedEventWriter writer{config.output, std::move(heprup)};
 
   double global_reweight = 1.;
   auto const & max_events = config.max_events;
   // if we need the event number:
   if(std::abs(heprup.IDWTUP) == 4 || std::abs(heprup.IDWTUP) == 1 || max_events){
     // try to read from LHE head
     auto input_events{reader->number_events()};
     if(!input_events) {
       // else count manually
       auto t_reader = HEJ::make_reader(argv[2]);
       input_events = 0;
       while(t_reader->read_event()) ++(*input_events);
     }
     if(std::abs(heprup.IDWTUP) == 4 || std::abs(heprup.IDWTUP) == 1){
       // IDWTUP 4 or 1 assume average(weight)=xs, but we need sum(weights)=xs
       std::cout << "Found IDWTUP " << heprup.IDWTUP << ": "
         << "assuming \"cross section = average weight\".\n"
         << "converting to \"cross section = sum of weights\" ";
       global_reweight /= *input_events;
     }
     if(max_events && (*input_events > *max_events)){
       // maximal number of events given
       global_reweight *= *input_events/static_cast<double>(*max_events);
       std::cout << "Processing " << *max_events
                 << " out of " << *input_events << " events\n";
     }
   }
 
   HEJ::ScaleGenerator scale_gen{
     config.scales.base,
     config.scales.factors,
     config.scales.max_ratio
   };
   std::shared_ptr<HEJ::RNG> ran{
     HEJ::make_RNG(config.rng.name, config.rng.seed)};
   assert(ran != nullptr);
   HEJ::EventReweighter hej{
     reader->heprup(),
     std::move(scale_gen),
     to_EventReweighterConfig(config),
     ran
   };
 
   std::optional<HEJ::Unweighter> unweighter{};
   if(config.weight_type != HEJ::WeightType::weighted) {
     unweighter = HEJ::Unweighter{};
   }
   if(config.weight_type == HEJ::WeightType::partially_unweighted) {
     HEJ::BufferedEventReader buffered_reader{std::move(reader)};
     assert(config.unweight_config);
     train(
         *unweighter,
         buffered_reader,
         hej,
         config.unweight_config->trials,
         config.unweight_config->max_dev,
         global_reweight/config.trials,
         config.fixed_order_jets,
         config.ew_parameters,
         config.off_shell_tolerance
     );
     reader = std::make_unique<HEJ::BufferedEventReader>(
         std::move(buffered_reader)
     );
   }
 
   // status infos & eye candy
   if (config.nlo.enabled){
     std::cout << "HEJ@NLO Truncation Enabled for NLO order: "
     << config.nlo.nj << std::endl;
   }
   size_t nevent = 0;
   std::array<int, HEJ::event_type::last_type + 1>
     nevent_type{0}, nfailed_type{0};
   auto progress = make_progress_bar(reader->heprup().XSECUP);
   HEJ::CrossSectionAccumulator xs;
   std::map<HEJ::StatusCode, int> status_counter;
   size_t total_trials = 0;
   size_t total_resum = 0;
 
 
   // Loop over the events in the input file
   while(reader->read_event() && (!max_events || nevent < *max_events) ){
     ++nevent;
 
     // reweight events so that the total cross section is conserved
     auto hepeup = reader->hepeup();
     hepeup.XWGTUP *= global_reweight;
 
     const auto FO_event = to_event(
       hepeup,
       config.fixed_order_jets,
       config.ew_parameters,
       config.off_shell_tolerance
     );
     if(FO_event.central().weight == 0) {
       static const bool warned_once = [argv,nevent](){
         std::cerr
           << "WARNING: event number " << nevent
           << " in " << argv[2] << " has zero weight. "
           "Ignoring this and all further events with vanishing weight.\n";
         return true;
       }();
       (void) warned_once; // shut up compiler warnings
       continue;
     }
 
     auto resummed_events{ hej.reweight(FO_event, config.trials) };
 
     // some bookkeeping
     for(auto const & s: hej.status())
       ++status_counter[s];
     total_trials+=hej.status().size();
     ++nevent_type[FO_event.type()];
 
     if(resummed_events.empty()) ++nfailed_type[FO_event.type()];
 
     if(unweighter) {
       unweight(*unweighter, config.weight_type, resummed_events, *ran);
     }
 
     // analysis
     for(auto & ev: resummed_events){
       //TODO: move pass_cuts to after phase space point generation
       bool passed = analyses.empty();
       for(auto const & analysis: analyses){
         if(analysis->pass_cuts(ev, FO_event)){
           passed = true;
           analysis->fill(ev, FO_event);
         };
       }
       if(passed){
         writer.write(ev);
       } else {
         ev.parameters()*=0; // do not use discarded events afterwards
       }
     }
     xs.fill_correlated(resummed_events);
     total_resum += resummed_events.size();
     if(progress) progress->increment(FO_event.central().weight);
   } // main event loop
   std::cout << '\n';
   // scale to account for num_trials of sherpa
-  if (reader->heprup().IDWTUP==3) { //if using sherpa events
-    double scalefactor(reader->scalefactor());
+  if(const double scalefactor = reader->scalefactor(); scalefactor != 1.) {
     for(auto const & analysis: analyses){
       analysis->scale(scalefactor);
     }
     xs.scale(scalefactor);
   }
 
   for(auto const & analysis: analyses){
     analysis->finalise();
   }
   writer.finish();
 
   using namespace HEJ::event_type;
   std::cout<< "Events processed: " << nevent << " (" << total_resum << " resummed)"<< '\n';
   std::cout << '\t' << name(EventType::first_type) << ": "
             << nevent_type[EventType::first_type]
             << ", failed to reconstruct " << nfailed_type[EventType::first_type]
             << '\n';
   for(auto i=EventType::first_type+1; i<=EventType::last_type; i*=2){
     std::cout << '\t' << name(static_cast<EventType>(i)) << ": "
               << nevent_type[i]
               << ", failed to reconstruct " << nfailed_type[i]
               << '\n';
   }
 
   std::cout << '\n' << xs << '\n';
 
   std::cout << "Generation statistic: "
     << status_counter[HEJ::StatusCode::good] << "/" << total_trials
     << " trials successful.\n";
   for(auto && entry: status_counter){
     const double fraction = static_cast<double>(entry.second)/total_trials;
     const int percent = std::round(100*fraction);
     std::cout << std::left << std::setw(17) << (to_string(entry.first) + ":")
               << " [";
     for(int i = 0; i < percent/2; ++i) std::cout << '#';
     for(int i = percent/2; i < 50; ++i) std::cout << ' ';
     std::cout << "] " <<std::setw(2)<<std::right<< percent << "%\n";
   }
 
   std::chrono::duration<double> run_time = (clock::now() - start_time);
   std::cout << "\nFinished " << HEJ::Version::package_name() << " at "
     << time_to_string(clock::to_time_t(clock::now()))
     << "\n=> Runtime: " << run_time.count() << " sec ("
     << nevent/run_time.count() << " Events/sec).\n";
 
   return EXIT_SUCCESS;
 }
diff --git a/t/check_res.cc b/t/check_res.cc
index b21d082..b16a2f1 100644
--- a/t/check_res.cc
+++ b/t/check_res.cc
@@ -1,158 +1,154 @@
 /**
  *  \authors   The HEJ collaboration (see AUTHORS for details)
  *  \date      2019-2020
  *  \copyright GPLv2 or later
  */
 #include "hej_test.hh"
 
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
 #include <iostream>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "HEJ/Config.hh"
 #include "HEJ/CrossSectionAccumulator.hh"
 #include "HEJ/Event.hh"
 #include "HEJ/event_types.hh"
 #include "HEJ/EventReweighter.hh"
 #include "HEJ/EWConstants.hh"
 #include "HEJ/Fraction.hh"
 #include "HEJ/HiggsCouplingSettings.hh"
 #include "HEJ/make_RNG.hh"
 #include "HEJ/Mixmax.hh"
 #include "HEJ/Parameters.hh"
 #include "HEJ/ScaleFunction.hh"
 #include "HEJ/EventReader.hh"
 #include "HEJ/YAMLreader.hh"
 
 #include "fastjet/JetDefinition.hh"
 
 #include "LHEF/LHEF.h"
 
 namespace HEJ { struct RNG; }
 
 namespace {
   using EventTreatment = HEJ::EventTreatment;
   using namespace HEJ::event_type;
   HEJ::EventTreatMap TREAT{
     {not_enough_jets, EventTreatment::discard},
     {bad_final_state, EventTreatment::discard},
     {non_resummable, EventTreatment::discard},
     {unof, EventTreatment::discard},
     {unob, EventTreatment::discard},
     {qqbar_exb, EventTreatment::discard},
     {qqbar_exf, EventTreatment::discard},
     {qqbar_mid, EventTreatment::discard},
     {FKL, EventTreatment::reweight}
   };
 
   bool correct_colour(HEJ::Event const & ev){
     if(!HEJ::event_type::is_resummable(ev.type()))
       return true;
     return ev.is_leading_colour();
   }
 } // namespace
 
 int main(int argn, char** argv) {
 
   if(argn == 6 && std::string(argv[5]) == "unof"){
     --argn;
     TREAT[unof] = EventTreatment::reweight;
     TREAT[unob] = EventTreatment::discard;
     TREAT[FKL] = EventTreatment::discard;
   }
   else if(argn == 6 && std::string(argv[5]) == "unob"){
     --argn;
     TREAT[unof] = EventTreatment::discard;
     TREAT[unob] = EventTreatment::reweight;
     TREAT[FKL] = EventTreatment::discard;
   }
   else if(argn == 6 && std::string(argv[5]) == "splitf"){
     --argn;
     TREAT[qqbar_exb] = EventTreatment::discard;
     TREAT[qqbar_exf] = EventTreatment::reweight;
     TREAT[FKL] = EventTreatment::discard;
   }
   else if(argn == 6 && std::string(argv[5]) == "splitb"){
     --argn;
     TREAT[qqbar_exb] = EventTreatment::reweight;
     TREAT[qqbar_exf] = EventTreatment::discard;
     TREAT[FKL] = EventTreatment::discard;
   }
   else if(argn == 6 && std::string(argv[5]) == "qqbar_mid"){
     --argn;
     TREAT[qqbar_mid] = EventTreatment::reweight;
     TREAT[FKL] = EventTreatment::discard;
   }
   if(argn != 5){
     std::cerr << "Usage: check_res yaml eventfile xsection tolerance [uno] \n";
     return EXIT_FAILURE;
   }
 
   HEJ::Config config = HEJ::load_config(argv[1]);
   auto reader = HEJ::make_reader(argv[2]);
   const double xsec_ref = std::stod(argv[3]);
   const double tolerance = std::stod(argv[4]);
 
   reader->read_event();
 
   HEJ::EventReweighterConfig conf = HEJ::to_EventReweighterConfig(config);
   conf.treat = TREAT;
   HEJ::MatrixElementConfig ME_conf = HEJ::to_MatrixElementConfig(config);
   HEJ::PhaseSpacePointConfig psp_conf = HEJ::to_PhaseSpacePointConfig(config);
   const fastjet::JetDefinition BORN_JET_DEF = config.fixed_order_jets.def;
   const double BORN_JETPTMIN = config.fixed_order_jets.min_pt;
   const int NUM_TRIES = config.trials;
   HEJ::ScaleGenerator scale_gen{
     config.scales.base,
     config.scales.factors,
     config.scales.max_ratio
   };
   std::shared_ptr<HEJ::RNG> ran{
     HEJ::make_RNG(config.rng.name,config.rng.seed)
   };
 
 
   HEJ::EventReweighter hej{reader->heprup(), std::move(scale_gen), conf, ran};
 
   HEJ::CrossSectionAccumulator xs;
   do{
     auto ev_data = HEJ::Event::EventData{reader->hepeup()};
     shuffle_particles(ev_data);
     ev_data.reconstruct_intermediate(ME_conf.ew_parameters);
     HEJ::Event ev{
       ev_data.cluster(
         BORN_JET_DEF, BORN_JETPTMIN
       )
     };
     auto resummed_events = hej.reweight(ev, NUM_TRIES);
     for(auto const & res_ev: resummed_events) {
       ASSERT(correct_colour(res_ev));
       ASSERT(std::isfinite(res_ev.central().weight));
       // we fill the xs uncorrelated since we only want to test the uncertainty
       // of the resummation
       xs.fill(res_ev);
     }
   } while(reader->read_event());
-  // scale to account for num_trials of sherpa
-  if (reader->heprup().IDWTUP==3) { //if using sherpa events
-    double scalefactor(reader->scalefactor());
-    xs.scale(scalefactor);
-  }
+  xs.scale(reader->scalefactor());
   const double xsec = xs.total().value;
   const double xsec_err = std::sqrt(xs.total().error);
   const double significance =
     std::abs(xsec - xsec_ref) / std::sqrt( xsec_err*xsec_err + tolerance*tolerance );
   std::cout << xsec_ref << " +/- " << tolerance << " ~ "
     << xsec << " +- " << xsec_err << " => " << significance << " sigma\n";
 
   if(significance > 3.){
     std::cerr << "Cross section is off by over 3 sigma!\n";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }