diff --git a/Modules/MFT/CMakeLists.txt b/Modules/MFT/CMakeLists.txt
index be797843c3..93f25f69bb 100644
--- a/Modules/MFT/CMakeLists.txt
+++ b/Modules/MFT/CMakeLists.txt
@@ -9,6 +9,7 @@ target_sources(O2QcMFT PRIVATE
                src/QcMFTClusterTask.cxx
                src/QcMFTTrackCheck.cxx
                src/QcMFTTrackTask.cxx
+               src/QcMFTAsyncTask.cxx
                src/QcMFTReadoutCheck.cxx
                src/QcMFTReadoutTask.cxx)
 
@@ -33,6 +34,7 @@ add_root_dictionary(O2QcMFT
                     include/MFT/QcMFTClusterTask.h
                     include/MFT/QcMFTTrackCheck.h
                     include/MFT/QcMFTTrackTask.h 
+                    include/MFT/QcMFTAsyncTask.h
                     include/MFT/QcMFTReadoutCheck.h
                     include/MFT/QcMFTReadoutTask.h
                     include/MFT/QcMFTUtilTables.h
@@ -92,4 +94,6 @@ install(FILES qc-mft-digit.json
               qc-mft-cluster.json
               qc-mft-track.json
               qc-mft-readout.json
+              qc-mft-async.json
+              qc-mft-async_direct.json
         DESTINATION etc)
diff --git a/Modules/MFT/include/MFT/LinkDef.h b/Modules/MFT/include/MFT/LinkDef.h
index cf9ed6acd5..6f78273ac0 100644
--- a/Modules/MFT/include/MFT/LinkDef.h
+++ b/Modules/MFT/include/MFT/LinkDef.h
@@ -8,6 +8,7 @@
 #pragma link C++ class o2::quality_control_modules::mft::QcMFTClusterTask + ;
 #pragma link C++ class o2::quality_control_modules::mft::QcMFTClusterCheck + ;
 #pragma link C++ class o2::quality_control_modules::mft::QcMFTTrackTask + ;
+#pragma link C++ class o2::quality_control_modules::mft::QcMFTAsyncTask + ;
 #pragma link C++ class o2::quality_control_modules::mft::QcMFTTrackCheck + ;
 #pragma link C++ class o2::quality_control_modules::mft::QcMFTReadoutCheck + ;
 #pragma link C++ class o2::quality_control_modules::mft::QcMFTReadoutTask + ;
diff --git a/Modules/MFT/include/MFT/QcMFTAsyncTask.h b/Modules/MFT/include/MFT/QcMFTAsyncTask.h
new file mode 100644
index 0000000000..ff2ed39fe8
--- /dev/null
+++ b/Modules/MFT/include/MFT/QcMFTAsyncTask.h
@@ -0,0 +1,96 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file   QcMFTAsyncTask.h
+/// \author Tomas Herman
+/// \author Guillermo Contreras
+/// \author Diana Maria Krupova
+/// \author Katarina Krizkova Gajdosova
+
+#ifndef QC_MFT_ASYNC_TASK_H
+#define QC_MFT_ASYNC_TASK_H
+
+// ROOT
+#include <TH1.h>
+#include <TH2.h>
+// Quality Control
+#include "QualityControl/TaskInterface.h"
+// O2
+#include "CommonConstants/LHCConstants.h"
+
+using namespace o2::quality_control::core;
+using namespace std;
+
+namespace o2::quality_control_modules::mft
+{
+
+/// \brief MFT Async QC task
+///
+class QcMFTAsyncTask /*final*/ : public TaskInterface // todo add back the "final" when doxygen is fixed
+{
+ public:
+  /// \brief Constructor
+  QcMFTAsyncTask() = default;
+  /// Destructor
+  ~QcMFTAsyncTask() override;
+
+  // Definition of the methods for the template method pattern
+  void initialize(o2::framework::InitContext& ctx) override;
+  void startOfActivity(Activity& activity) override;
+  void startOfCycle() override;
+  void monitorData(o2::framework::ProcessingContext& ctx) override;
+  void endOfCycle() override;
+  void endOfActivity(Activity& activity) override;
+  void reset() override;
+
+  double orbitToSeconds(uint32_t orbit, uint32_t refOrbit)
+  {
+    return (orbit - refOrbit) * o2::constants::lhc::LHCOrbitNS / 1E9;
+  }
+
+ private:
+  std::unique_ptr<TH1F> mTrackNumberOfClusters = nullptr;
+  std::unique_ptr<TH1F> mCATrackNumberOfClusters = nullptr;
+  std::unique_ptr<TH1F> mLTFTrackNumberOfClusters = nullptr;
+  std::unique_ptr<TH1F> mTrackOnvQPt = nullptr;
+  std::unique_ptr<TH1F> mTrackChi2 = nullptr;
+  std::unique_ptr<TH1F> mTrackCharge = nullptr;
+  std::unique_ptr<TH1F> mTrackPhi = nullptr;
+  std::unique_ptr<TH1F> mPositiveTrackPhi = nullptr;
+  std::unique_ptr<TH1F> mNegativeTrackPhi = nullptr;
+  std::unique_ptr<TH1F> mTrackEta = nullptr;
+  std::array<unique_ptr<TH1F>, 7> mTrackEtaNCls = { nullptr };
+  std::array<unique_ptr<TH1F>, 7> mTrackPhiNCls = { nullptr };
+  std::array<unique_ptr<TH2F>, 7> mTrackXYNCls = { nullptr };
+  std::array<unique_ptr<TH2F>, 7> mTrackEtaPhiNCls = { nullptr };
+  std::unique_ptr<TH1F> mCATrackEta = nullptr;
+  std::unique_ptr<TH1F> mLTFTrackEta = nullptr;
+  std::unique_ptr<TH1F> mTrackTanl = nullptr;
+
+  std::unique_ptr<TH1F> mTrackROFNEntries = nullptr;
+  std::unique_ptr<TH1F> mClusterROFNEntries = nullptr;
+  std::unique_ptr<TH1F> mTracksBC = nullptr;
+
+  std::unique_ptr<TH1F> mNOfTracksTime = nullptr;
+  std::unique_ptr<TH1F> mNOfClustersTime = nullptr;
+
+  std::unique_ptr<TH1F> mClusterSensorIndex = nullptr;
+  std::unique_ptr<TH1F> mClusterPatternIndex = nullptr;
+
+  uint32_t mRefOrbit = 0; // Reference orbit used in relative time calculation
+
+  static constexpr array<short, 7> sMinNClustersList = { 4, 5, 6, 7, 8, 9, 10 };
+};
+
+} // namespace o2::quality_control_modules::mft
+
+#endif // QC_MFT_ASYNC_TASK_H
diff --git a/Modules/MFT/qc-mft-async.json b/Modules/MFT/qc-mft-async.json
new file mode 100644
index 0000000000..07ba09d38f
--- /dev/null
+++ b/Modules/MFT/qc-mft-async.json
@@ -0,0 +1,67 @@
+{
+  "qc": {
+    "config": {
+      "database": {
+        "implementation": "CCDB",
+        "host": "ccdb-test.cern.ch:8080",
+        "username": "not_applicable",
+        "password": "not_applicable",
+        "name": "not_applicable"
+      },
+      "Activity": {
+        "number": "42",
+        "type": "2"
+      },
+      "monitoring": {
+        "url": "infologger:///debug?qc"
+      },
+      "consul": {
+        "url": ""
+      },
+      "conditionDB": {
+        "url": "ccdb-test.cern.ch:8080"
+      }
+    },
+    "tasks": {
+      "QcMFTAsync": {
+        "active": "true",
+        "className": "o2::quality_control_modules::mft::QcMFTAsyncTask",
+        "moduleName": "QcMFT",
+        "detectorName": "MFT",
+        "cycleDurationSeconds": "60",
+        "maxNumberCycles": "-1",
+        "dataSource_comment": "The other type of dataSource is \"direct\", see basic-no-sampling.json.",
+        "dataSource": {
+          "type": "dataSamplingPolicy",
+          "name": "mft-async"
+        },
+        "taskParameters": {
+          "ROFLengthInBC": "198",
+          "MaxTrackROFSize": "1000",
+          "MaxClusterROFSize": "5000",
+          "MaxDuration": "60000",
+          "TimeBinSize": "0.1",
+          "RefOrbit": "0"
+        },
+        "location": "remote"
+      }
+    },
+    "checks": {}
+  },
+  "dataSamplingPolicies": [
+    {
+      "id": "mft-async",
+      "active": "true",
+      "machines": [],
+      "query": "tracks:MFT/TRACKS/0;tracksrofs:MFT/MFTTrackROF/0;clusters:MFT/COMPCLUSTERS/0;clustersrofs:MFT/CLUSTERSROF/0",
+      "samplingConditions": [
+        {
+          "condition": "random",
+          "fraction": "0.05",
+          "seed": "1234"
+        }
+      ],
+      "blocking": "false"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Modules/MFT/qc-mft-async_direct.json b/Modules/MFT/qc-mft-async_direct.json
new file mode 100644
index 0000000000..7c9dbbfa3e
--- /dev/null
+++ b/Modules/MFT/qc-mft-async_direct.json
@@ -0,0 +1,52 @@
+{
+  "qc": {
+    "config": {
+      "database": {
+        "implementation": "Dummy",
+        "host": "not_applicable",
+        "username": "not_applicable",
+        "password": "not_applicable",
+        "name": "not_applicable"
+      },
+      "Activity": {
+        "number": "42",
+        "type": "2"
+      },
+      "monitoring": {
+        "url": "infologger:///debug?qc"
+      },
+      "consul": {
+        "url": ""
+      },
+      "conditionDB": {
+        "url": "qcdb.cern.ch:8083"
+      }
+    },
+    "tasks": {
+      "QcMFTAsync": {
+        "active": "true",
+        "className": "o2::quality_control_modules::mft::QcMFTAsyncTask",
+        "moduleName": "QcMFT",
+        "detectorName": "MFT",
+        "cycleDurationSeconds": "60",
+        "maxNumberCycles": "-1",
+        "dataSource_comment": "The other type of dataSource is \"direct\", see basic-no-sampling.json.",
+        "dataSource": {
+          "type": "direct",
+          "query": "tracks:MFT/TRACKS/0;tracksrofs:MFT/MFTTrackROF/0;clusters:MFT/COMPCLUSTERS/0;clustersrofs:MFT/CLUSTERSROF/0"
+        },
+        "taskParameters": {
+          "ROFLengthInBC": "198",
+          "MaxTrackROFSize": "1000",
+          "MaxClusterROFSize": "5000",
+          "MaxDuration": "60000",
+          "TimeBinSize": "0.1",
+          "RefOrbit": "0"
+        },
+        "location": "remote"
+      }
+    },
+    "checks": {}
+  },
+  "dataSamplingPolicies": []
+}
\ No newline at end of file
diff --git a/Modules/MFT/src/QcMFTAsyncTask.cxx b/Modules/MFT/src/QcMFTAsyncTask.cxx
new file mode 100644
index 0000000000..9d3ceca3ee
--- /dev/null
+++ b/Modules/MFT/src/QcMFTAsyncTask.cxx
@@ -0,0 +1,321 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file   QcMFTAsyncTask.cxx
+/// \author Tomas Herman
+/// \author Guillermo Contreras
+/// \author Diana Maria Krupova
+/// \author Katarina Krizkova Gajdosova
+
+// ROOT
+#include <TH1.h>
+#include <TH2.h>
+// O2
+#include <DataFormatsMFT/TrackMFT.h>
+#include <MFTTracking/TrackCA.h>
+#include <Framework/InputRecord.h>
+#include <DataFormatsITSMFT/ROFRecord.h>
+#include <DataFormatsITSMFT/Cluster.h>
+#include <DataFormatsITSMFT/CompCluster.h>
+// Quality Control
+#include "QualityControl/QcInfoLogger.h"
+#include "MFT/QcMFTAsyncTask.h"
+
+namespace o2::quality_control_modules::mft
+{
+
+QcMFTAsyncTask::~QcMFTAsyncTask()
+{
+  /*
+    not needed for unique pointers
+  */
+}
+
+void QcMFTAsyncTask::initialize(o2::framework::InitContext& /*ctx*/)
+{
+  ILOG(Info, Support) << "initialize QcMFTAsyncTask" << ENDM; // QcInfoLogger is used. FairMQ logs will go to there as well.
+
+  // Loading custom parameters
+  auto MaxClusterROFSize = 5000;
+  if (auto param = mCustomParameters.find("MaxClusterROFSize"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - MaxClusterROFSize: " << param->second << ENDM;
+    MaxClusterROFSize = stoi(param->second);
+  }
+
+  auto MaxTrackROFSize = 1000;
+  if (auto param = mCustomParameters.find("MaxTrackROFSize"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - MaxTrackROFSize: " << param->second << ENDM;
+    MaxTrackROFSize = stoi(param->second);
+  }
+
+  auto ROFLengthInBC = 198;
+  if (auto param = mCustomParameters.find("ROFLengthInBC"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - ROFLengthInBC: " << param->second << ENDM;
+    ROFLengthInBC = stoi(param->second);
+  }
+  auto ROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / ROFLengthInBC;
+
+  auto MaxDuration = 60.f;
+  if (auto param = mCustomParameters.find("MaxDuration"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - MaxDuration: " << param->second << ENDM;
+    MaxDuration = stof(param->second);
+  }
+
+  auto TimeBinSize = 0.01f;
+  if (auto param = mCustomParameters.find("TimeBinSize"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - TimeBinSize: " << param->second << ENDM;
+    TimeBinSize = stof(param->second);
+  }
+
+  auto NofTimeBins = static_cast<int>(MaxDuration / TimeBinSize);
+
+  if (auto param = mCustomParameters.find("RefOrbit"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - RefOrbit: " << param->second << ENDM;
+    mRefOrbit = static_cast<uint32_t>(stoi(param->second));
+  }
+
+  // Creating histos
+  mTrackNumberOfClusters = std::make_unique<TH1F>("tracks/mMFTTrackNumberOfClusters",
+                                                  "Number Of Clusters Per Track; # clusters; # entries", 10, 0.5, 10.5);
+  getObjectsManager()->startPublishing(mTrackNumberOfClusters.get());
+
+  mCATrackNumberOfClusters = std::make_unique<TH1F>("tracks/CA/mMFTCATrackNumberOfClusters",
+                                                    "Number Of Clusters Per CA Track; # clusters; # tracks", 10, 0.5, 10.5);
+  getObjectsManager()->startPublishing(mCATrackNumberOfClusters.get());
+
+  mLTFTrackNumberOfClusters = std::make_unique<TH1F>("tracks/LTF/mMFTLTFTrackNumberOfClusters",
+                                                     "Number Of Clusters Per LTF Track; # clusters; # entries", 10, 0.5, 10.5);
+  getObjectsManager()->startPublishing(mLTFTrackNumberOfClusters.get());
+
+  mTrackOnvQPt = std::make_unique<TH1F>("tracks/mMFTTrackOnvQPt", "Track q/p_{T}; q/p_{T} [1/GeV]; # entries", 50, -2, 2);
+  getObjectsManager()->startPublishing(mTrackOnvQPt.get());
+
+  mTrackChi2 = std::make_unique<TH1F>("tracks/mMFTTrackChi2", "Track #chi^{2}; #chi^{2}; # entries", 21, -0.5, 20.5);
+  getObjectsManager()->startPublishing(mTrackChi2.get());
+
+  mTrackCharge = std::make_unique<TH1F>("tracks/mMFTTrackCharge", "Track Charge; q; # entries", 3, -1.5, 1.5);
+  getObjectsManager()->startPublishing(mTrackCharge.get());
+
+  mTrackPhi = std::make_unique<TH1F>("tracks/mMFTTrackPhi", "Track #phi; #phi; # entries", 100, -3.2, 3.2);
+  getObjectsManager()->startPublishing(mTrackPhi.get());
+
+  mPositiveTrackPhi = std::make_unique<TH1F>("tracks/mMFTPositiveTrackPhi", "Positive Track #phi; #phi; # entries", 100, -3.2, 3.2);
+  getObjectsManager()->startPublishing(mPositiveTrackPhi.get());
+
+  mNegativeTrackPhi = std::make_unique<TH1F>("tracks/mMFTNegativeTrackPhi", "Negative Track #phi; #phi; # entries", 100, -3.2, 3.2);
+  getObjectsManager()->startPublishing(mNegativeTrackPhi.get());
+
+  mTrackEta = std::make_unique<TH1F>("tracks/mMFTTrackEta", "Track #eta; #eta; # entries", 50, -4, -2);
+  getObjectsManager()->startPublishing(mTrackEta.get());
+
+  for (auto minNClusters : sMinNClustersList) {
+    auto nHisto = minNClusters - sMinNClustersList[0];
+    mTrackEtaNCls[nHisto] = std::make_unique<TH1F>(Form("tracks/mMFTTrackEta_%d_MinClusters", minNClusters), Form("Track #eta (NCls >= %d); #eta; # entries", minNClusters), 50, -4, -2);
+    getObjectsManager()->startPublishing(mTrackEtaNCls[nHisto].get());
+
+    mTrackPhiNCls[nHisto] = std::make_unique<TH1F>(Form("tracks/mMFTTrackPhi_%d_MinClusters", minNClusters), Form("Track #phi (NCls >= %d); #phi; # entries", minNClusters), 100, -3.2, 3.2);
+    getObjectsManager()->startPublishing(mTrackPhiNCls[nHisto].get());
+
+    mTrackXYNCls[nHisto] = std::make_unique<TH2F>(Form("tracks/mMFTTrackXY_%d_MinClusters", minNClusters), Form("Track Position (NCls >= %d); x; y", minNClusters), 320, -16, 16, 320, -16, 16);
+    mTrackXYNCls[nHisto]->SetOption("COLZ");
+    getObjectsManager()->startPublishing(mTrackXYNCls[nHisto].get());
+
+    mTrackEtaPhiNCls[nHisto] = std::make_unique<TH2F>(Form("tracks/mMFTTrackEtaPhi_%d_MinClusters", minNClusters), Form("Track #eta , #phi (NCls >= %d); #eta; #phi", minNClusters), 50, -4, -2, 100, -3.2, 3.2);
+    mTrackEtaPhiNCls[nHisto]->SetOption("COLZ");
+    getObjectsManager()->startPublishing(mTrackEtaPhiNCls[nHisto].get());
+  }
+
+  mCATrackEta = std::make_unique<TH1F>("tracks/CA/mMFTCATrackEta", "CA Track #eta; #eta; # entries", 50, -4, -2);
+  getObjectsManager()->startPublishing(mCATrackEta.get());
+
+  mLTFTrackEta = std::make_unique<TH1F>("tracks/LTF/mMFTLTFTrackEta", "LTF Track #eta; #eta; # entries", 50, -4, -2);
+  getObjectsManager()->startPublishing(mLTFTrackEta.get());
+
+  mTrackTanl = std::make_unique<TH1F>("tracks/mMFTTrackTanl", "Track tan #lambda; tan #lambda; # entries", 100, -25, 0);
+  getObjectsManager()->startPublishing(mTrackTanl.get());
+
+  mClusterROFNEntries = std::make_unique<TH1F>("clusters/mMFTClustersROFSize", "MFT Cluster ROFs size; ROF Size; # entries", MaxClusterROFSize, 0, MaxClusterROFSize);
+  getObjectsManager()->startPublishing(mClusterROFNEntries.get());
+
+  mTrackROFNEntries = std::make_unique<TH1F>("tracks/mMFTTrackROFSize", "MFT Track ROFs size; ROF Size; # entries", MaxTrackROFSize, 0, MaxTrackROFSize);
+  getObjectsManager()->startPublishing(mTrackROFNEntries.get());
+
+  mTracksBC = std::make_unique<TH1F>("tracks/mMFTTracksBC", "Tracks per BC (sum over orbits); BCid; # entries", ROFsPerOrbit, 0, o2::constants::lhc::LHCMaxBunches);
+  mTracksBC->SetMinimum(0.1);
+  getObjectsManager()->startPublishing(mTracksBC.get());
+
+  mNOfTracksTime = std::make_unique<TH1F>("tracks/mNOfTracksTime", "Number of tracks per time bin; time (s); # entries", NofTimeBins, 0, MaxDuration);
+  mNOfTracksTime->SetMinimum(0.1);
+  getObjectsManager()->startPublishing(mNOfTracksTime.get());
+
+  mNOfClustersTime = std::make_unique<TH1F>("clusters/mNOfClustersTime", "Number of clusters per time bin; time (s); # entries", NofTimeBins, 0, MaxDuration);
+  mNOfClustersTime->SetMinimum(0.1);
+  getObjectsManager()->startPublishing(mNOfClustersTime.get());
+
+  mClusterSensorIndex = std::make_unique<TH1F>("clusters/mMFTClusterSensorIndex", "Chip Cluster Occupancy;Chip ID;#Entries", 936, -0.5, 935.5);
+  getObjectsManager()->startPublishing(mClusterSensorIndex.get());
+
+  mClusterPatternIndex = std::make_unique<TH1F>("clusters/mMFTClusterPatternIndex", "Cluster Pattern ID;Pattern ID;#Entries", 300, -0.5, 299.5);
+  getObjectsManager()->startPublishing(mClusterPatternIndex.get());
+}
+
+void QcMFTAsyncTask::startOfActivity(Activity& /*activity*/)
+{
+  ILOG(Info, Support) << "startOfActivity" << ENDM;
+
+  mTrackNumberOfClusters->Reset();
+  mCATrackNumberOfClusters->Reset();
+  mLTFTrackNumberOfClusters->Reset();
+  mTrackOnvQPt->Reset();
+  mTrackChi2->Reset();
+  mTrackCharge->Reset();
+  mTrackPhi->Reset();
+  mPositiveTrackPhi->Reset();
+  mNegativeTrackPhi->Reset();
+  mTrackEta->Reset();
+  for (auto minNClusters : sMinNClustersList) {
+    auto nHisto = minNClusters - sMinNClustersList[0];
+    mTrackEtaNCls[nHisto]->Reset();
+    mTrackPhiNCls[nHisto]->Reset();
+    mTrackXYNCls[nHisto]->Reset();
+    mTrackEtaPhiNCls[nHisto]->Reset();
+  }
+  mCATrackEta->Reset();
+  mLTFTrackEta->Reset();
+  mTrackTanl->Reset();
+
+  mTrackROFNEntries->Reset();
+  mClusterROFNEntries->Reset();
+
+  mClusterSensorIndex->Reset();
+  mClusterPatternIndex->Reset();
+}
+
+void QcMFTAsyncTask::startOfCycle()
+{
+  ILOG(Info, Support) << "startOfCycle" << ENDM;
+}
+
+void QcMFTAsyncTask::monitorData(o2::framework::ProcessingContext& ctx)
+{
+  // get the tracks
+  const auto tracks = ctx.inputs().get<gsl::span<o2::mft::TrackMFT>>("tracks");
+  const auto tracksrofs = ctx.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("tracksrofs");
+
+  // get clusters
+  const auto clusters = ctx.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("clusters");
+  const auto clustersrofs = ctx.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("clustersrofs");
+
+  // Fill the clusters histograms
+  for (const auto& rof : clustersrofs) {
+    mClusterROFNEntries->Fill(rof.getNEntries());
+    float seconds = orbitToSeconds(rof.getBCData().orbit, mRefOrbit) + rof.getBCData().bc * o2::constants::lhc::LHCBunchSpacingNS * 1e-9;
+    mNOfClustersTime->Fill(seconds, rof.getNEntries());
+  }
+
+  for (auto& oneCluster : clusters) {
+    mClusterSensorIndex->Fill(oneCluster.getSensorID());
+    mClusterPatternIndex->Fill(oneCluster.getPatternID());
+  }
+
+  // fill the tracks histogram
+
+  for (const auto& rof : tracksrofs) {
+    mTrackROFNEntries->Fill(rof.getNEntries());
+    mTracksBC->Fill(rof.getBCData().bc, rof.getNEntries());
+    float seconds = orbitToSeconds(rof.getBCData().orbit, mRefOrbit) + rof.getBCData().bc * o2::constants::lhc::LHCBunchSpacingNS * 1e-9;
+    mNOfTracksTime->Fill(seconds, rof.getNEntries());
+  }
+
+  for (auto& oneTrack : tracks) {
+    mTrackNumberOfClusters->Fill(oneTrack.getNumberOfPoints());
+    mTrackChi2->Fill(oneTrack.getTrackChi2());
+    mTrackCharge->Fill(oneTrack.getCharge());
+    mTrackPhi->Fill(oneTrack.getPhi());
+    mTrackEta->Fill(oneTrack.getEta());
+    mTrackTanl->Fill(oneTrack.getTanl());
+
+    for (auto minNClusters : sMinNClustersList) {
+      if (oneTrack.getNumberOfPoints() >= minNClusters) {
+        mTrackEtaNCls[minNClusters - sMinNClustersList[0]]->Fill(oneTrack.getEta());
+        mTrackPhiNCls[minNClusters - sMinNClustersList[0]]->Fill(oneTrack.getPhi());
+        mTrackXYNCls[minNClusters - sMinNClustersList[0]]->Fill(oneTrack.getX(), oneTrack.getY());
+        mTrackEtaPhiNCls[minNClusters - sMinNClustersList[0]]->Fill(oneTrack.getEta(), oneTrack.getPhi());
+      }
+    }
+
+    if (oneTrack.getCharge() == +1) {
+      mPositiveTrackPhi->Fill(oneTrack.getPhi());
+      mTrackOnvQPt->Fill(1 / oneTrack.getPt());
+    }
+
+    if (oneTrack.getCharge() == -1) {
+      mNegativeTrackPhi->Fill(oneTrack.getPhi());
+      mTrackOnvQPt->Fill(-1 / oneTrack.getPt());
+    }
+
+    if (oneTrack.isCA()) {
+      mCATrackNumberOfClusters->Fill(oneTrack.getNumberOfPoints());
+      mCATrackEta->Fill(oneTrack.getEta());
+    }
+    if (oneTrack.isLTF()) {
+      mLTFTrackNumberOfClusters->Fill(oneTrack.getNumberOfPoints());
+      mLTFTrackEta->Fill(oneTrack.getEta());
+    }
+  }
+}
+
+void QcMFTAsyncTask::endOfCycle()
+{
+  ILOG(Info, Support) << "endOfCycle" << ENDM;
+}
+
+void QcMFTAsyncTask::endOfActivity(Activity& /*activity*/)
+{
+  ILOG(Info, Support) << "endOfActivity" << ENDM;
+}
+
+void QcMFTAsyncTask::reset()
+{
+  // clean all the monitor objects here
+
+  ILOG(Info, Support) << "Resetting the histogram" << ENDM;
+
+  mTrackNumberOfClusters->Reset();
+  mCATrackNumberOfClusters->Reset();
+  mLTFTrackNumberOfClusters->Reset();
+  mTrackOnvQPt->Reset();
+  mTrackChi2->Reset();
+  mTrackCharge->Reset();
+  mTrackPhi->Reset();
+  mPositiveTrackPhi->Reset();
+  mNegativeTrackPhi->Reset();
+  mTrackEta->Reset();
+  for (auto minNClusters : sMinNClustersList) {
+    auto nHisto = minNClusters - sMinNClustersList[0];
+    mTrackEtaNCls[nHisto]->Reset();
+    mTrackPhiNCls[nHisto]->Reset();
+    mTrackXYNCls[nHisto]->Reset();
+    mTrackEtaPhiNCls[nHisto]->Reset();
+  }
+  mCATrackEta->Reset();
+  mLTFTrackEta->Reset();
+  mTrackTanl->Reset();
+
+  mTrackROFNEntries->Reset();
+  mClusterROFNEntries->Reset();
+
+  mClusterSensorIndex->Reset();
+  mClusterPatternIndex->Reset();
+}
+
+} // namespace o2::quality_control_modules::mft