diff --git a/src/base/AxisConfig.cpp b/src/base/AxisConfig.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e83b72889f523f9aa2c2709aee642e0dbf61e23f
--- /dev/null
+++ b/src/base/AxisConfig.cpp
@@ -0,0 +1 @@
+#include "AxisConfig.h"
diff --git a/src/base/AxisConfig.h b/src/base/AxisConfig.h
new file mode 100644
index 0000000000000000000000000000000000000000..df1d042f6c98f90fe72c08fc97c8c22799eb533d
--- /dev/null
+++ b/src/base/AxisConfig.h
@@ -0,0 +1,27 @@
+#ifndef FLOW_SRC_BASE_AXISCONFIG_H_
+#define FLOW_SRC_BASE_AXISCONFIG_H_
+
+#include "AnalysisTree/Variable.hpp"
+#include "QnTools/Axis.hpp"
+
+namespace Qn{
+
+struct AxisConfig{
+  AxisConfig() = default;
+  AxisConfig(AnalysisTree::Variable var, int nbins, float min, float max) :
+    var_(std::move(var)),
+    axis_(AxisD(var_.GetName(), nbins, min, max)) {}
+
+  AxisConfig(AnalysisTree::Variable var, std::vector<double> bin_edges) :
+    var_(std::move(var)),
+    axis_(AxisD(var_.GetName(), std::move(bin_edges))) {}
+
+  const AnalysisTree::Variable& GetVariable() const { return var_; }
+  const AxisD& GetAxis() const { return axis_; }
+
+ private:
+  AnalysisTree::Variable var_{};
+  AxisD axis_{};
+};
+}
+#endif //FLOW_SRC_BASE_AXISCONFIG_H_
diff --git a/src/base/CMakeLists.txt b/src/base/CMakeLists.txt
index 9853bb5e0a5392cb9fbb370ddac42689c7ed1bfc..cb09f536e8ba3fe12b66cffda28949f418539d84 100644
--- a/src/base/CMakeLists.txt
+++ b/src/base/CMakeLists.txt
@@ -1,4 +1,6 @@
 set(SOURCES
+    AxisConfig.cpp
+    CutConfig.cpp
     QvectorConfig.cpp
     QvectorTracksConfig.cpp
     QvectorChannelsConfig.cpp
diff --git a/src/base/CutConfig.cpp b/src/base/CutConfig.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac9be2d951575a069deec5ea0c655acb75b18de5
--- /dev/null
+++ b/src/base/CutConfig.cpp
@@ -0,0 +1 @@
+#include "CutConfig.h"
diff --git a/src/base/CutConfig.h b/src/base/CutConfig.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a0a1d7f51fbed7357f30ed44274205e5c93fbf5
--- /dev/null
+++ b/src/base/CutConfig.h
@@ -0,0 +1,26 @@
+#ifndef FLOW_SRC_BASE_CUTCONFIG_H_
+#define FLOW_SRC_BASE_CUTCONFIG_H_
+
+#include "AnalysisTree/Variable.hpp"
+
+namespace Qn{
+
+struct CutConfig {
+  CutConfig() = default;
+  CutConfig(AnalysisTree::Variable var, std::function<bool(double)> function, std::string description) :
+    var_(std::move(var)),
+    function_(std::move(function)),
+    description_(std::move(description)) {}
+
+  const AnalysisTree::Variable& GetVariable() const { return var_; }
+  const std::function<bool(double)>& GetFunction() const { return function_; }
+  const std::string& GetDescription() const { return description_; }
+
+ private:
+  AnalysisTree::Variable var_{};
+  std::function<bool(double)> function_{};
+  std::string description_{};
+};
+
+}
+#endif //FLOW_SRC_BASE_CUTCONFIG_H_
diff --git a/src/base/GlobalConfig.cpp b/src/base/GlobalConfig.cpp
index 42035c80d6a8c8337b6e4644dc59f4272cff9fbc..105101d40b22c3351c0026510ac6f10586b70be8 100644
--- a/src/base/GlobalConfig.cpp
+++ b/src/base/GlobalConfig.cpp
@@ -1,6 +1,6 @@
 #include "GlobalConfig.h"
 
-void Qn::GlobalConfig::Print() const {
+[[maybe_unused]] void Qn::GlobalConfig::Print() const {
   std::cout << " ***** Tracking detectors ***** :" << std::endl;
   for(const auto& det : track_qvectors_){
     det.Print();
diff --git a/src/base/GlobalConfig.h b/src/base/GlobalConfig.h
index ef8dedece55f61793b151c95ead3e1bb92819119..c7cd9b04da1979a7270916747028c5aba3ec670b 100644
--- a/src/base/GlobalConfig.h
+++ b/src/base/GlobalConfig.h
@@ -48,6 +48,7 @@ class GlobalConfig : public TObject {
     abort();
   }
   const QvectorConfig& GetPsiQvector() const {return psi_qvector_;}
+  QvectorConfig& PsiQvector() {return psi_qvector_;}
   const std::vector <Qn::AxisD>& GetCorrectionAxes() const { return correction_axes_; }
 
   bool IsSimulation() const { return is_simulation_; }
@@ -72,7 +73,7 @@ class GlobalConfig : public TObject {
     event_vars_.emplace_back(var);
   }
 
-  void Print() const;
+  [[maybe_unused]] void Print() const;
 
  protected:
 
diff --git a/src/base/QvectorChannelsConfig.h b/src/base/QvectorChannelsConfig.h
index db2e104d92bf0676cf76c64b045f98f31b08d897..1650f41793f986ba89f71c1b300b6f64d9b941e5 100644
--- a/src/base/QvectorChannelsConfig.h
+++ b/src/base/QvectorChannelsConfig.h
@@ -20,9 +20,9 @@ public:
     QvectorConfig(name, phi, weight),
     module_ids_(ids)
   {
-    phi_.SetName(name_ + "_" + phi_.GetFieldName());
+//    phi_.SetName(name_ + "_" + phi_.GetName());
     phi_.SetSize(module_ids_.size());
-    weight_.SetName(name_ + "_" + weight_.GetFieldName());
+//    weight_.SetName(name_ + "_" + weight_.GetName());
     weight_.SetSize(module_ids_.size());
   }
 
diff --git a/src/base/QvectorConfig.h b/src/base/QvectorConfig.h
index a6760d4b3617342c966680e6659a6346066df59f..31fe34ee1de5658d689519a02696beecf35abe56 100644
--- a/src/base/QvectorConfig.h
+++ b/src/base/QvectorConfig.h
@@ -12,6 +12,8 @@
 
 #include "AnalysisTree/Variable.hpp"
 
+#include "AxisConfig.h"
+
 namespace Qn{
 
 class QvectorConfig {
@@ -49,7 +51,7 @@ public:
   AnalysisTree::Variable& WeightVar() { return weight_; }
   AnalysisTree::Variable& PhiVar() { return phi_; }
   std::string GetName() const { return name_; }
-  void SetType(Stats::Weights type) { QvectorConfig::type = type; }
+  void SetType(Stats::Weights type) { type_ = type; }
 
   void SetCorrectionSteps(bool rec, bool twist, bool res) {
     corrertions_[kRecentering] = rec;
@@ -60,7 +62,7 @@ public:
   bool GetIsRecentering() const { return corrertions_[kRecentering]; }
   bool GetIsTwist() const { return corrertions_[kTwist]; }
   bool GetIsRescale() const { return corrertions_[kRescale]; }
-  Stats::Weights GetType() const { return type; }
+  Stats::Weights GetType() const { return type_; }
 
   std::string GetLastStepName() const {
     if(GetIsRescale()) { return "RESCALED"; }
@@ -71,13 +73,28 @@ public:
 
   virtual std::vector<AnalysisTree::Variable> GetListOfVariables() const { return {phi_, weight_}; }
 
-protected:
+  int GetVarEntryId() const { return var_entry_id_; }
+  void SetVarEntryId(int var_entry_id) { var_entry_id_ = var_entry_id; }
+
+  void AddQA1DHistogram(const AxisConfig& axis){ qa_histos_.emplace_back(std::vector<AxisConfig>{axis}); }
+  void AddQA2DHistogram(const std::vector<AxisConfig>& axis){
+    assert(axis.size()==2);
+    qa_histos_.emplace_back(axis);
+  }
+
+  const std::vector<std::vector<AxisConfig>>& GetQaHistos() const {
+    return qa_histos_;
+  }
+ protected:
 
-  std::string name_{""};    ///<  Name of the Q-vector
+  std::string name_;    ///<  Name of the Q-vector
   AnalysisTree::Variable phi_{};
   AnalysisTree::Variable weight_{};
   std::array<bool, nSteps> corrertions_{false, false, false};
-  Qn::Stats::Weights type = Qn::Stats::Weights::OBSERVABLE;
+  Qn::Stats::Weights type_ = Qn::Stats::Weights::OBSERVABLE;
+
+  int var_entry_id_{};
+  std::vector<std::vector<AxisConfig>> qa_histos_;
 
 };
   
diff --git a/src/base/QvectorTracksConfig.cpp b/src/base/QvectorTracksConfig.cpp
index 27c91af4501dcf9477d1f543cb4b93a7acdb5541..426300dbbad5b796ba69fb2a269e0636ef46b296 100644
--- a/src/base/QvectorTracksConfig.cpp
+++ b/src/base/QvectorTracksConfig.cpp
@@ -1 +1,26 @@
-#include "QvectorTracksConfig.h"
\ No newline at end of file
+#include "QvectorTracksConfig.h"
+
+namespace Qn{
+std::vector<AnalysisTree::Variable> QvectorTracksConfig::GetListOfVariables() const {
+  std::vector<AnalysisTree::Variable> vars {phi_, weight_};
+  for(const auto& cut : cuts_){
+    vars.emplace_back(cut.GetVariable());
+  }
+  for(const auto& axis : axes_){
+    vars.emplace_back(axis.GetVariable());
+  }
+  // remove Ones and Filled
+  auto new_end = std::remove_if(vars.begin(), vars.end(),
+    [](const AnalysisTree::Variable &var) { return EndsWith(var.GetName(), "Ones") || EndsWith(var.GetName(),"Filled"); });
+  vars.erase(new_end, vars.end());
+  return vars;
+}
+
+std::vector<AxisD> QvectorTracksConfig::GetAxes() const {
+  std::vector<AxisD> axes{};
+  for(const auto& axis : axes_) {
+    axes.emplace_back(axis.GetAxis());
+  }
+  return axes;
+}
+}
\ No newline at end of file
diff --git a/src/base/QvectorTracksConfig.h b/src/base/QvectorTracksConfig.h
index 624dd3f27f7c18cea17d622895d310c9aadfe7c8..9a083ec46130a54d909c32c3ede2639cb6764fc5 100644
--- a/src/base/QvectorTracksConfig.h
+++ b/src/base/QvectorTracksConfig.h
@@ -12,6 +12,7 @@
 #include "QnTools/Axis.hpp"
 
 #include "QvectorConfig.h"
+#include "CutConfig.h"
 
 namespace Qn{
 
@@ -20,43 +21,36 @@ class QvectorTracksConfig : public QvectorConfig{
 public:
   
   QvectorTracksConfig() = default;
-  QvectorTracksConfig(std::string name, AnalysisTree::Variable phi, AnalysisTree::Variable weight, const std::vector<Qn::AxisD>& axes) :
+  QvectorTracksConfig(std::string name, AnalysisTree::Variable phi, AnalysisTree::Variable weight,
+                      const std::vector<AxisConfig>& axes) :
     QvectorConfig(std::move(name), std::move(phi), std::move(weight)),
     axes_(axes)
     {
-      this->AddCut({{phi_.GetBranchName(), "Filled"}}, [](const double is){ return is>0.; });
+      auto var = AnalysisTree::Variable(*phi_.GetBranches().begin(), "Filled");
+      this->AddCut({var, [](const double is){ return is>0.; }, "is_filled"});
     }
 
-  std::vector<Qn::AxisD> GetAxes() const {
-    std::vector<AxisD> axes = axes_;
-    for(auto& axis : axes) {
-      axis.SetName(phi_.GetBranchName() + "_" + axis.Name());
-    }
-    return axes;
-  }
-//  std::vector<Qn::AxisD>& Axes() { return axes_; }
+  std::vector<Qn::AxisD> GetAxes() const;
 
-  void AddCut(const std::vector<AnalysisTree::Variable>& names, const std::function<bool(double)>& lambda) {
-    cuts_.emplace_back(names, lambda);
+  void AddCut(const CutConfig& cut) {
+    cuts_.emplace_back(cut);
   }
 
-  std::vector<AnalysisTree::Variable> GetListOfVariables() const override {
-    std::vector<AnalysisTree::Variable> vars {phi_, weight_};
-    for(const auto& cut : cuts_){
-      vars.insert( vars.end(), cut.first.begin(), cut.first.end() );
-    }
-    for(const auto& axis : axes_){
-      vars.emplace_back(AnalysisTree::Variable(phi_.GetBranchName(), axis.Name())); //NOTE
-    }
-    return vars;
-  }
-
-  const std::vector<std::pair<std::vector<AnalysisTree::Variable>, std::function<bool(double)>>>& GetCuts() const {return cuts_;}
+  std::vector<AnalysisTree::Variable> GetListOfVariables() const override;
+  const std::vector<CutConfig>& GetCuts() const {return cuts_;};
 
  protected:
 
-  std::vector<Qn::AxisD> axes_{};
-  std::vector<std::pair<std::vector<AnalysisTree::Variable>, std::function<bool(double)>>> cuts_{};  //!
+  static bool EndsWith(std::string const &name, std::string const &ending) {
+    if (name.length() >= ending.length()) {
+      return (0 == name.compare (name.length() - ending.length(), ending.length(), ending));
+    } else {
+      return false;
+    }
+  }
+
+  std::vector<AxisConfig> axes_{};
+  std::vector<CutConfig> cuts_{};
 };
   
 }
diff --git a/src/correct/CorrectTaskManager.cpp b/src/correct/CorrectTaskManager.cpp
index 9832bac56c09728a8db0577c63420329add89eea..2a3b4da737a9cc7245e6b5b7ea4436ccd71bcca5 100644
--- a/src/correct/CorrectTaskManager.cpp
+++ b/src/correct/CorrectTaskManager.cpp
@@ -3,7 +3,25 @@
 void Qn::CorrectTaskManager::AddTask(Qn::CorrectionTask* task) {
   assert(tasks_.empty()); // For the moment one task per Manager
 
-  auto* var_task = new AnalysisTree::VarManager(task->GetListOfVariables());
+  auto* var_task = new AnalysisTree::VarManager();
+
+  // Variables used by tracking Q-vectors
+  for (auto& qvec : task->GetConfig()->QvectorsConfig()) {
+    const auto& vars = qvec.GetListOfVariables();
+    qvec.SetVarEntryId( var_task->AddEntry(AnalysisTree::VarManagerEntry(vars)).first );
+  }
+  // Variables used by channelized Q-vectors
+  for (auto& channel : task->GetConfig()->ChannelConfig()) {
+    channel.SetVarEntryId( var_task->AddEntry(AnalysisTree::VarManagerEntry({channel.GetWeightVar()})).first );
+  }
+  // Psi variable
+  if(task->GetConfig()->IsSimulation()){
+    auto& qvec = task->GetConfig()->PsiQvector();
+    qvec.SetVarEntryId( var_task->AddEntry(AnalysisTree::VarManagerEntry({qvec.GetPhiVar()})).first );
+  }
+  auto event_var_id = var_task->AddEntry(AnalysisTree::VarManagerEntry(task->GetConfig()->GetEventVars())).first;
+
+  var_task->FillBranchNames();
   var_task->SetCutsMap(cuts_map_);
 
   task->SetPointerToVarManager(var_task);
diff --git a/src/correct/CorrectionTask.cpp b/src/correct/CorrectionTask.cpp
index 27278347ead5f04b1194f48d05593ad08c55caa9..f7b422133c2715ca3b6f47226d7cc490c966b049 100644
--- a/src/correct/CorrectionTask.cpp
+++ b/src/correct/CorrectionTask.cpp
@@ -14,32 +14,39 @@ using std::vector;
 void CorrectionTask::InitVariables(){
   // Add all needed variables
   short ivar{0}, ibranch{0};
-  for(auto& branch : var_manager_->Branches()){
-    if(branch.GetType() ==  AnalysisTree::DetType::kModule){ ibranch++; continue; } // Should be handled separately
-    for (auto& var : branch.Variables()) {
-      if(var.GetFieldName() != "Ones") {
+
+  for(auto& entry : var_manager_->VarEntries()){
+    assert(entry.GetNumberOfBranches() == 1);
+
+    if(entry.GetBranches()[0]->GetType() == AnalysisTree::DetType::kModule){ ibranch++; continue; } // Should be handled separately
+
+    for (auto& var : entry.Variables()) {
+      if(var.GetName() != "Ones") {
         var.SetId(ivar);
         manager_.AddVariable(var.GetName(), var.GetId(), var.GetSize());
 //        var.Print();
         ivar += var.GetSize();
       }
     }
-    if(branch.GetType() != AnalysisTree::DetType::kEventHeader && branch.GetType() != AnalysisTree::DetType::kModule){
-      manager_.AddVariable(branch.GetName() + "_Filled", ivar, 1);
+
+    auto type = entry.GetBranches()[0]->GetType();
+    if(type != AnalysisTree::DetType::kEventHeader && type != AnalysisTree::DetType::kModule){
+      manager_.AddVariable(entry.GetBranches()[0]->GetName() + "_Filled", ivar, 1);
       is_filled_.insert(std::make_pair(ibranch, ivar));
       ivar++;
     }
+
     ibranch++;
   }
 
   for(auto& qvec : global_config_->ChannelConfig()){
     auto& phi = qvec.PhiVar();
     phi.SetId(ivar);
-    manager_.AddVariable(phi.GetName(), phi.GetId(), phi.GetSize());
+    manager_.AddVariable(qvec.GetName() + "_" + phi.GetName(), phi.GetId(), phi.GetSize());
     ivar += phi.GetSize();
     auto& weight = qvec.WeightVar();
     weight.SetId(ivar);
-    manager_.AddVariable(weight.GetName(), weight.GetId(), weight.GetSize());
+    manager_.AddVariable(qvec.GetName() + "_" + weight.GetName(), weight.GetId(), weight.GetSize());
 //    weight.Print();
 //    phi.Print();
     ivar += weight.GetSize();
@@ -71,14 +78,14 @@ void CorrectionTask::Init(std::map<std::string, void*>&)
     const string& name = qvec.GetName();
     manager_.AddDetector(name, DetectorType::TRACK, qvec.GetPhiVar().GetName(), qvec.GetWeightVar().GetName(), qvec.GetAxes(), {1,2});
     SetCorrectionSteps(qvec);
-    for(const auto& cut : qvec.GetCuts()) {
-      manager_.AddCutOnDetector(name, {cut.first[0].GetName().c_str()}, cut.second, cut.first[0].GetName());
+    for(const auto& cut : qvec.GetCuts()) { //NOTE cannot apply cuts on more than 1 variable
+      manager_.AddCutOnDetector(name, {cut.GetVariable().GetName().c_str()}, cut.GetFunction(), cut.GetDescription());
     }
   }
 // Add Q-vectors of channelized detectors
   for(const auto& qvec : global_config_->GetChannelConfig()) {
     const string name = qvec.GetName();
-    manager_.AddDetector(name, DetectorType::CHANNEL, qvec.GetPhiVar().GetName(), qvec.GetWeightVar().GetName(), {}, {1});
+    manager_.AddDetector(name, DetectorType::CHANNEL, name + "_" + qvec.GetPhiVar().GetName(), name + "_" + qvec.GetWeightVar().GetName(), {}, {1});
     SetCorrectionSteps(qvec);
   }
 // Add Psi_RP
@@ -102,11 +109,11 @@ void CorrectionTask::Exec() {
   manager_.Reset();
   double* container = manager_.GetVariableContainer();
 
-  for(const auto& branch : var_manager_->GetBranches()) {
-    if(branch.GetType() == AnalysisTree::DetType::kEventHeader){
+  for(const auto& entry : var_manager_->GetVarEntries()) {
+    if(entry.GetBranches()[0]->GetType() == AnalysisTree::DetType::kEventHeader){
       short ivar{0};
-      for(const auto& var : branch.GetVariables()) {
-        container[var.GetId()] = branch.GetValues(ivar).at(0);
+      for(const auto& var : entry.GetVariables()) {
+        container[var.GetId()] = entry.GetValues().at(0)[ivar];
         ivar++;
       }
     }
@@ -114,12 +121,12 @@ void CorrectionTask::Exec() {
   for(const auto& qvec : global_config_->GetChannelConfig()){
     const auto& phi = qvec.GetPhiVar();
     const auto& weight = qvec.GetWeightVar();
-    const auto& branch = var_manager_->GetBranch(phi.GetBranchName());
+    const auto& branch = var_manager_->GetVarEntries().at(qvec.GetVarEntryId());
     int i_channel{0};
     for(int i : qvec.GetModuleIds()) {
       container[phi.GetId()+i_channel] = data_header_->GetModulePhi(0, i); //TODO fix hardcoded 0
-      if(i < branch.GetValues(0).size()){
-        container[weight.GetId()+i_channel] = branch.GetValues(0).at(i);  //TODO fix hardcoded 0
+      if(i < branch.GetValues().size()){
+        container[weight.GetId()+i_channel] = branch.GetValues()[i].at(0);  //TODO fix hardcoded 0
       }
       else{
         container[weight.GetId()+i_channel] = 0.;
@@ -141,19 +148,21 @@ void CorrectionTask::Exec() {
 void CorrectionTask::FillTracksQvectors(){
   double* container = manager_.GetVariableContainer();
   short ibranch{0};
-  for(const auto& branch : var_manager_->GetBranches()) {
-    if(branch.GetType() == AnalysisTree::DetType::kEventHeader || branch.GetType() == AnalysisTree::DetType::kModule){
+  for(const auto& entry : var_manager_->GetVarEntries()) {
+    assert(entry.GetNumberOfBranches() == 1);
+    auto type = entry.GetBranches()[0]->GetType();
+    if(type == AnalysisTree::DetType::kEventHeader || type == AnalysisTree::DetType::kModule){
       ibranch++;
       continue; // skip EventHeader and ModuleDetectors
     }
-    const int n_channels = branch.GetValues(0).size(); //NOTE
+    const int n_channels = entry.GetValues().size();
     for(int i=0; i<n_channels; ++i) {
-      for (auto const& entry : is_filled_) {
-        container[entry.second] = entry.first == ibranch ? 1. : -1.; // 1 for current, -1 for all others
+      for (auto const& fill : is_filled_) {
+        container[fill.second] = fill.first == ibranch ? 1. : -1.; // 1 for current, -1 for all others
       }
       short ivar{0};
-      for(const auto& var : branch.GetVariables()) {
-        container[var.GetId()] = branch.GetValues(ivar).at(i);
+      for(const auto& var : entry.GetVariables()) {
+        container[var.GetId()] = entry.GetValues()[i].at(ivar);
         ivar++;
       }
       manager_.FillTrackingDetectors();
@@ -166,15 +175,17 @@ void CorrectionTask::FillTracksQvectors(){
 * Adding QA histograms to CorrectionManager
 */
 
-void CorrectionTask::AddQAHisto()   //TODO make it automatic
+void CorrectionTask::AddQAHisto()
 {
   for(const auto& qvec: global_config_->GetQvectorsConfig()) {
-    const auto& branch = qvec.GetPhiVar().GetBranchName();
-    manager_.AddHisto1D(qvec.GetName(), {branch+"_pT", 100, 0, 3});
-    manager_.AddHisto1D(qvec.GetName(), {branch+"_rapidity", 100, -2., 3.});
-    manager_.AddHisto1D(qvec.GetName(), {branch+"_phi", 100, -3.2, 3.2});
-    manager_.AddHisto1D(qvec.GetName(), {branch+"_pid", 1000, -500, 2500});
-    manager_.AddHisto1D(qvec.GetName(), {branch+"_Filled", 3, -1.5, 1.5});
+    for(const auto& qa : qvec.GetQaHistos()){
+      if( qa.size() == 1 ){
+        manager_.AddHisto1D(qvec.GetName(), qa.at(0).GetAxis());
+      }
+      else if( qa.size() == 2 ){
+        manager_.AddHisto2D(qvec.GetName(), {qa.at(0).GetAxis(), qa.at(1).GetAxis()});
+      }
+    }
   }
   if(global_config_->IsSimulation()){
     const auto& q_psi = global_config_->GetPsiQvector();
@@ -182,12 +193,23 @@ void CorrectionTask::AddQAHisto()   //TODO make it automatic
   }
 
   for(const auto& qvec: global_config_->GetChannelConfig()){
-    manager_.AddHisto1D(qvec.GetName(), {qvec.GetName()+"_signal", 100, 0, 5}, "Ones");
-    manager_.AddHisto1D(qvec.GetName(), {qvec.GetName()+"_phi", 500, -4, 4}, "Ones");
+    for(const auto& qa : qvec.GetQaHistos()){
+      if( qa.size() == 1 ){
+        auto axis = qa.at(0).GetAxis();
+        axis.SetName(qvec.GetName() + "_" + axis.Name());
+        manager_.AddHisto1D(qvec.GetName(), axis);
+      }
+      else{
+        throw std::runtime_error("FIX ME");
+      }
+    }
+
   }
 
-  for(const auto& histo : qa_histos){
-    auto [name, axis] = histo;
+
+
+  for(const auto& histo : qa_histos_){
+    const auto& [name, axis] = histo;
     if( axis.size() == 1 )
       manager_.AddHisto1D(name, axis.at(0));
     if( axis.size() == 2 )
@@ -214,39 +236,6 @@ void CorrectionTask::Finish() {
 * Fill list of variables needed to construct all Q-vectors and event information.
 * This vector is passed to VarManager later
 */
-void CorrectionTask::FillListOfVariables() {
-  // Variables used by tracking Q-vectors
-  for (auto& qvec : global_config_->QvectorsConfig()) {
-    const auto& vars = qvec.GetListOfVariables();
-    variables_.insert( variables_.end(), std::make_move_iterator(vars.begin()), std::make_move_iterator(vars.end()) );
-  }
-  // Variables used by channelized Q-vectors
-  for (const auto& channel : global_config_->GetChannelConfig()) {
-    variables_.emplace_back(channel.GetWeightVar());  // phi is stored in the DataHeader
-  }
-  // Psi variable
-  if(global_config_->IsSimulation()){
-    variables_.emplace_back(global_config_->GetPsiQvector().GetPhiVar());
-  }
-  // Event variables
-  for (const auto& event_var : global_config_->GetEventVars()) {
-    variables_.emplace_back(event_var);
-  }
-
-  std::sort(variables_.begin(), variables_.end());
-  auto it = std::unique(variables_.begin(), variables_.end());
-  variables_.resize(std::distance(variables_.begin(), it));
-
-  // remove Ones and Filled
-  auto end = std::remove_if(variables_.begin(), variables_.end(),
-    [](const AnalysisTree::Variable &var) { return var.GetFieldName() == "Ones" || var.GetFieldName() == "Filled"; });
-  variables_.erase(end, variables_.end());
-
-  for (auto& channel : global_config_->ChannelConfig()) {
-
-  }
-
-  }
 
 /**
 * Set correction steps in a CorrectionManager for a given Q-vector
diff --git a/src/correct/CorrectionTask.h b/src/correct/CorrectionTask.h
index e4d5fad110233b8e63c7e41def270520d34d1416..087ad0b148aa575967ac94ebce4796035e3b4909 100644
--- a/src/correct/CorrectionTask.h
+++ b/src/correct/CorrectionTask.h
@@ -29,25 +29,23 @@ class CorrectionTask : public AnalysisTree::FillTask {
  public:
 
   CorrectionTask() = delete;
-  explicit CorrectionTask(GlobalConfig* global_config) : global_config_(global_config) {
-    FillListOfVariables();
-  }
+  explicit CorrectionTask(GlobalConfig* global_config) : global_config_(global_config) {}
 
   void AddQAHistogram(const std::string& qvec_name, const std::vector<AxisD>& axis){
-    qa_histos.emplace_back(qvec_name, axis );
+    qa_histos_.emplace_back(qvec_name, axis );
   }
+
   void Init(std::map<std::string, void*>&) override;
   void Exec() override;
   void Finish() override;
 
   void SetPointerToVarManager(AnalysisTree::VarManager* ptr) { var_manager_ = ptr; }
-  const std::vector<AnalysisTree::Variable>& GetListOfVariables() const {return variables_;}
 
+  GlobalConfig* GetConfig() { return global_config_; }
  protected:
 
   void FillTracksQvectors();
   void SetCorrectionSteps(const Qn::QvectorConfig& qvec);
-  void FillListOfVariables();
   void InitVariables();
   void AddQAHisto();
 
@@ -59,8 +57,7 @@ class CorrectionTask : public AnalysisTree::FillTask {
 
   GlobalConfig* global_config_{nullptr};
   AnalysisTree::VarManager* var_manager_{nullptr};
-  std::vector<AnalysisTree::Variable> variables_{};  ///<
-  std::vector< std::tuple<std::string, std::vector<AxisD>> > qa_histos;
+  std::vector<std::tuple<std::string, std::vector<AxisD>>> qa_histos_;
   std::map<int, int> is_filled_{};
 
 };
diff --git a/src/tasks/Correct.cpp b/src/tasks/Correct.cpp
index 6807fe6b40058f1d59a01c79c1cb023f8ee14f24..b1f256e1f849134185c75877ca685add831cc6f0 100644
--- a/src/tasks/Correct.cpp
+++ b/src/tasks/Correct.cpp
@@ -22,37 +22,41 @@ int main(int argc, char** argv)
 
   // main configuration object
   auto* global_config = new Qn::GlobalConfig();
-  global_config->AddEventVar({"b", "SimEventHeader", "b"});
-  global_config->AddCorrectionAxis( {"b", {0., 5.}} );
+  global_config->AddEventVar({"SimEventHeader", "b"});
+  global_config->AddCorrectionAxis( {"SimEventHeader_b", {0., 5.}} );
 
   Qn::QvectorChannelsConfig psd1("psd1", {"PsdModules", "phi"}, {"PsdModules", "signal"}, {18, 19, 24, 25});
   Qn::QvectorChannelsConfig psd2("psd2", {"PsdModules", "phi"}, {"PsdModules", "signal"}, {11, 12, 13, 14, 17, 20, 23, 26, 29, 30, 31, 32});
   Qn::QvectorChannelsConfig psd3("psd3", {"PsdModules", "phi"}, {"PsdModules", "signal"}, {0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 15, 16, 21, 22, 27, 28, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43});
 
+  psd1.AddQA1DHistogram({{"PsdModules", "phi"}, 100, -4., 4.});
+  psd1.AddQA1DHistogram({{"PsdModules", "signal"}, 100, 0., 10.});
+
   global_config->AddChannelQvector(psd1);
   global_config->AddChannelQvector(psd2);
   global_config->AddChannelQvector(psd3);
 
   const float beam_y = AnalysisTree::GetObjectFromFileList<DataHeader>(filelists[0], "DataHeader")->GetBeamRapidity();
-  Qn::AxisD axPt("pT", {0.0f, 0.2f, 0.4f, 0.6f, 0.8f, 1.0f, 1.5, 3.0});
-  Qn::AxisD axY("rapidity", 9, -0.6f + beam_y, 1.2f + beam_y);
+  Qn::AxisConfig axPt({"SimParticles", "pT"}, {0.0f, 0.2f, 0.4f, 0.6f, 0.8f, 1.0f, 1.5, 3.0});
+  Qn::AxisConfig axY({"SimParticles", "rapidity"}, 9, -0.6f + beam_y, 1.2f + beam_y);
 
   Qn::QvectorConfig psi("psi", {"SimEventHeader", "psi_RP"}, {"Ones"});
   psi.SetCorrectionSteps(false, false, false);
   global_config->SetPsiQvector(psi);
 
-  Qn::QvectorTracksConfig sim_tracks("sim_tracks", {"SimTracks", "phi"}, {"Ones"}, {axPt, axY});
+  Qn::QvectorTracksConfig sim_tracks("sim_tracks", {"SimParticles", "phi"}, {"Ones"}, {axPt, axY});
   sim_tracks.SetCorrectionSteps(false, false, false);
 
+  sim_tracks.AddQA1DHistogram({{"SimParticles", "pT"}, 15,0,3});
+  sim_tracks.AddQA1DHistogram(axY);
+
   std::vector<std::pair<int, std::string>> vpid = { {-211, "pion_neg"},
                                                     {211, "pion"},
-                                                    {2212, "proton"}
-  };
-
+                                                    {2212, "proton"} };
   for(const auto& ipid : vpid) {
     Qn::QvectorTracksConfig pid_tracks(sim_tracks);
     pid_tracks.SetName("mc_" + ipid.second );
-    pid_tracks.AddCut({{"SimTracks", "pid"}}, [ipid](double pid) { return pid == ipid.first; });
+    pid_tracks.AddCut({{"SimParticles", "pid"}, [ipid](double pid) { return pid == ipid.first; }, "pid"} );
     global_config->AddTrackQvector(pid_tracks);
   }
 
@@ -61,7 +65,7 @@ int main(int argc, char** argv)
 
   man.AddBranchCut( GetCbmEventCuts("RecEventHeader"));
   man.AddBranchCut( GetCbmTrackCuts("VtxTracks"));
-  man.AddBranchCut( GetCbmMcTracksCuts("SimTracks"));
+  man.AddBranchCut( GetCbmMcTracksCuts("SimParticles"));
 
   auto* task = new Qn::CorrectionTask(global_config);
   man.AddTask(task);