update TPC time-series

Author: alcaliva

Detectors/Calibration/include/DetectorsCalibration/IntegratedClusterCalibrator.h

@@ -364,6 +364,10 @@ struct TimeSeriesITSTPC {
   std::vector<float> vertexY_ITSTPC_RMS;                ///< vertex y RMS with ITS-TPC cut (nContributorsITS + nContributorsITSTPC)<0.95
   std::vector<float> vertexZ_ITSTPC_RMS;                ///< vertex z RMS with ITS-TPC cut (nContributorsITS + nContributorsITSTPC)<0.95
 
+  std::vector<float> nITSTPCBasedPVContributors;   ///< number of ITS-TPC-based PV contributors (denominator for TRD matching fraction)
+  std::vector<float> nITSTPCWithTRDPVContributors; ///< number of ITS-TPC-TRD PV contributors (numerator for TRD matching fraction)
+  std::vector<float> fracTRD;                      ///< fraction of ITS-TPC PV contributors with TRD match (NaN if denominator=0)
+
   int quantileValues = 23;                          ///<! number of values in quantiles + truncated mean (hardcoded for the moment)
   std::vector<float> nVertexContributors_Quantiles; ///< number of primary vertices for quantiles 0.1, 0.2, ... 0.9 and truncated mean values 0.05->0.95, 0.1->0.9, 0.2->0.8
 
@@ -497,12 +501,15 @@ struct TimeSeriesITSTPC {
     vertexX_ITSTPC_RMS.resize(nTotalVtx);
     vertexY_ITSTPC_RMS.resize(nTotalVtx);
     vertexZ_ITSTPC_RMS.resize(nTotalVtx);
+    nITSTPCBasedPVContributors.resize(nTotalVtx);
+    nITSTPCWithTRDPVContributors.resize(nTotalVtx);
+    fracTRD.resize(nTotalVtx);
 
     const int nTotalQ = quantileValues * nTotal / mTSTPC.getNBins();
     nVertexContributors_Quantiles.resize(nTotalQ);
   }
 
-  ClassDefNV(TimeSeriesITSTPC, 6);
+  ClassDefNV(TimeSeriesITSTPC, 7);
 };
 
 } // end namespace tpc

Detectors/TPC/workflow/CMakeLists.txt

@@ -231,7 +231,9 @@ o2_add_executable(merge-integrate-cluster-workflow
 o2_add_executable(time-series-workflow
                   COMPONENT_NAME tpc
                   SOURCES src/tpc-time-series.cxx
-                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
+                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow
+                                        O2::GlobalTrackingWorkflowReaders
+                                        O2::GlobalTrackingWorkflowHelpers)
 
 o2_add_executable(scaler-workflow
                   COMPONENT_NAME tpc

Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx

@@ -40,6 +40,9 @@
 #include <chrono>
 #include "DataFormatsTPC/PIDResponse.h"
 #include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsTRD/TrackTRD.h"
+#include "DataFormatsTRD/Tracklet64.h"
+#include "DataFormatsTRD/CalibratedTracklet.h"
 #include "TROOT.h"
 #include "ReconstructionDataFormats/MatchInfoTOF.h"
 #include "DataFormatsTOF/Cluster.h"
@@ -60,6 +63,13 @@ namespace tpc
 class TPCTimeSeries : public Task
 {
  public:
+  /// D2: per-track TRD tracklet lookup data
+  struct TRDTrackletData {
+    uint8_t trdPattern = 0;
+    uint8_t nTRDTracklets = 0;
+    int trackletIndices[6] = {-1, -1, -1, -1, -1, -1};
+  };
+
   /// \constructor
   TPCTimeSeries(std::shared_ptr<o2::base::GRPGeomRequest> req, const bool disableWriter, const o2::base::Propagator::MatCorrType matType, const bool enableUnbinnedWriter, const bool tpcOnly, std::shared_ptr<o2::globaltracking::DataRequest> dr) : mCCDBRequest(req), mDisableWriter(disableWriter), mMatType(matType), mUnbinnedWriter(enableUnbinnedWriter), mTPCOnly(tpcOnly), mDataRequest(dr) {};
 
@@ -298,6 +308,38 @@ class TPCTimeSeries : public Task
     // find nearest vertex of tracks which have no vertex assigned
     findNearesVertex(tracksTPC, vertices);
 
+    // D2: build TPC track index → TRD tracklet data map (for unbinned output)
+    // For each TPC track that has a TRD match, store the TrackTRD tracklet indices
+    std::unordered_map<unsigned int, TRDTrackletData> tpcToTRDMap;
+    auto trdTracklets = mTPCOnly ? gsl::span<const o2::trd::Tracklet64>() : recoData.getTRDTracklets();
+    auto trdCalibTracklets = mTPCOnly ? gsl::span<const o2::trd::CalibratedTracklet>() : recoData.getTRDCalibratedTracklets();
+    if (mUnbinnedWriter && !mTPCOnly) {
+      // scan ITS-TPC-TRD tracks
+      auto itstpctrdTracks = recoData.getITSTPCTRDTracks<o2::trd::TrackTRD>();
+      for (unsigned int ig = 0; ig < itstpctrdTracks.size(); ++ig) {
+        auto gid = GTrackID(ig, GTrackID::ITSTPCTRD);
+        auto refTPC = recoData.getTPCContributorGID(gid);
+        if (!refTPC.isIndexSet()) {
+          continue;
+        }
+        auto refTRD = recoData.getSingleDetectorRefs(gid)[GTrackID::TRD];
+        if (!refTRD.isIndexSet()) {
+          continue;
+        }
+        const auto& trdTrack = recoData.getTrack<o2::trd::TrackTRD>(refTRD);
+        TRDTrackletData trdData;
+        for (int iLay = 0; iLay < 6; ++iLay) {
+          auto trkltId = trdTrack.getTrackletIndex(iLay);
+          if (trkltId >= 0) {
+            trdData.trdPattern |= (1 << iLay);
+            trdData.nTRDTracklets++;
+            trdData.trackletIndices[iLay] = trkltId;
+          }
+        }
+        tpcToTRDMap[refTPC] = trdData;
+      }
+    }
+
     // getting cluster references for cluster bitmask
     if (mUnbinnedWriter) {
       mTPCTrackClIdx = pc.inputs().get<gsl::span<o2::tpc::TPCClRefElem>>("trackTPCClRefs");
@@ -467,7 +509,7 @@ class TPCTimeSeries : public Task
       auto myThread = [&](int iThread) {
         for (size_t i = iThread; i < loopEnd; i += mNThreads) {
           if (acceptTrack(tracksTPC[i])) {
-            fillDCA(tracksTPC, tracksITSTPC, vertices, i, iThread, indicesITSTPC, tracksITS, idxTPCTrackToTOFCluster, tofClusters);
+            fillDCA(tracksTPC, tracksITSTPC, vertices, i, iThread, indicesITSTPC, tracksITS, idxTPCTrackToTOFCluster, tofClusters, tpcToTRDMap, trdTracklets, trdCalibTracklets);
           }
         }
       };
@@ -484,7 +526,7 @@ class TPCTimeSeries : public Task
       auto myThread = [&](int iThread) {
         for (size_t i = iThread; i < loopEnd; i += mNThreads) {
           if (acceptTrack(tracksTPC[i])) {
-            fillDCA(tracksTPC, tracksITSTPC, vertices, i, iThread, indicesITSTPC, tracksITS, idxTPCTrackToTOFCluster, tofClusters);
+            fillDCA(tracksTPC, tracksITSTPC, vertices, i, iThread, indicesITSTPC, tracksITS, idxTPCTrackToTOFCluster, tofClusters, tpcToTRDMap, trdTracklets, trdCalibTracklets);
           }
         }
       };
@@ -1122,7 +1164,7 @@ class TPCTimeSeries : public Task
     return isGoodTrack;
   }
 
-  void fillDCA(const gsl::span<const TrackTPC> tracksTPC, const gsl::span<const o2::dataformats::TrackTPCITS> tracksITSTPC, const gsl::span<const o2::dataformats::PrimaryVertex> vertices, const int iTrk, const int iThread, const std::unordered_map<unsigned int, std::array<int, 2>>& indicesITSTPC, const gsl::span<const o2::its::TrackITS> tracksITS, const std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int, unsigned short>>& idxTPCTrackToTOFCluster, const gsl::span<const o2::tof::Cluster> tofClusters)
+  void fillDCA(const gsl::span<const TrackTPC> tracksTPC, const gsl::span<const o2::dataformats::TrackTPCITS> tracksITSTPC, const gsl::span<const o2::dataformats::PrimaryVertex> vertices, const int iTrk, const int iThread, const std::unordered_map<unsigned int, std::array<int, 2>>& indicesITSTPC, const gsl::span<const o2::its::TrackITS> tracksITS, const std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int, unsigned short>>& idxTPCTrackToTOFCluster, const gsl::span<const o2::tof::Cluster> tofClusters, const std::unordered_map<unsigned int, TRDTrackletData>& tpcToTRDMap, const gsl::span<const o2::trd::Tracklet64> trdTracklets, const gsl::span<const o2::trd::CalibratedTracklet> trdCalibTracklets)
   {
     const auto& trackFull = tracksTPC[iTrk];
     const bool isGoodTrack = checkTrack(trackFull);
@@ -1168,21 +1210,22 @@ class TPCTimeSeries : public Task
       return;
     }
 
-    const int tglBin = mTglBins * std::abs(trackTmp.getTgl()) / mMaxTgl + mPhiBins;
-    const int phiBin = mPhiBins * trackTmp.getPhi() / o2::constants::math::TwoPI;
+    // Saturate bin indices — edge bins act as overflow (Phase 0.2 fix)
+    const int tglBin = std::clamp(static_cast<int>(mTglBins * std::abs(trackTmp.getTgl()) / mMaxTgl) + mPhiBins,
+                                  mPhiBins, mPhiBins + mTglBins - 1);
+    const int phiBin = std::clamp(static_cast<int>(mPhiBins * trackTmp.getPhi() / o2::constants::math::TwoPI),
+                                  0, mPhiBins - 1);
 
     const int offsQPtBin = mPhiBins + mTglBins;
-    const int qPtBin = offsQPtBin + mQPtBins * (trackTmp.getQ2Pt() + mMaxQPt) / (2 * mMaxQPt);
+    const int qPtBin = std::clamp(offsQPtBin + static_cast<int>(mQPtBins * (trackTmp.getQ2Pt() + mMaxQPt) / (2 * mMaxQPt)),
+                                  offsQPtBin, offsQPtBin + mQPtBins - 1);
     const int localMult = mNTracksWindow[iTrk];
 
     const int offsMult = offsQPtBin + mQPtBins;
-    const int multBin = offsMult + mMultBins * localMult / mMultMax;
+    const int multBin = std::clamp(offsMult + static_cast<int>(mMultBins * localMult / mMultMax),
+                                   offsMult, offsMult + mMultBins - 1);
     const int nBins = getNBins();
 
-    if ((phiBin < 0) || (phiBin > mPhiBins) || (tglBin < mPhiBins) || (tglBin > offsQPtBin) || (qPtBin < offsQPtBin) || (qPtBin > offsMult) || (multBin < offsMult) || (multBin > offsMult + mMultBins)) {
-      return;
-    }
-
     float sigmaY2 = 0;
     float sigmaZ2 = 0;
     const int sector = o2::math_utils::angle2Sector(trackTmp.getPhiPos());
@@ -1343,6 +1386,30 @@ class TPCTimeSeries : public Task
         const float chi2match_ITSTPC = hasITSTPC ? tracksITSTPC[idxITSTPC.front()].getChi2Match() : -1;
         const int nClITS = idxITSCheck ? tracksITS[idxITSTrack].getNClusters() : -1;
         const int chi2ITS = idxITSCheck ? tracksITS[idxITSTrack].getChi2() : -1;
+        // D1: ITS cluster sizes (4-bit per layer, mask bit 28 = kSharedClusters)
+        const uint32_t itsClusterSizes = idxITSCheck ? (static_cast<uint32_t>(tracksITS[idxITSTrack].getClusterSizes()) & 0x0FFFFFFFu) : 0u;
+        const bool itsHasSharedClusters = idxITSCheck ? tracksITS[idxITSTrack].hasSharedClusters() : false;
+        const uint32_t itsPattern = idxITSCheck ? (tracksITS[idxITSTrack].getPattern() & 0x7Fu) : 0u;
+
+        // D2: TRD tracklet data — native objects per layer
+        uint8_t trdPattern = 0;
+        uint8_t nTRDTracklets = 0;
+        std::vector<o2::trd::Tracklet64> trdTrackletVec(6);
+        std::vector<o2::trd::CalibratedTracklet> trdCalibVec(6);
+        auto itTRD = tpcToTRDMap.find(iTrk);
+        if (itTRD != tpcToTRDMap.end()) {
+          const auto& trdData = itTRD->second;
+          trdPattern = trdData.trdPattern;
+          nTRDTracklets = trdData.nTRDTracklets;
+          for (int iLay = 0; iLay < 6; ++iLay) {
+            if (trdData.trackletIndices[iLay] >= 0) {
+              trdTrackletVec[iLay] = trdTracklets[trdData.trackletIndices[iLay]];
+              if (trdData.trackletIndices[iLay] < static_cast<int>(trdCalibTracklets.size())) {
+                trdCalibVec[iLay] = trdCalibTracklets[trdData.trackletIndices[iLay]];
+              }
+            }
+          }
+        }
         int typeSide = 2; // A- and C-Side cluster
         if (trackFull.hasASideClustersOnly()) {
           typeSide = 0;
@@ -1477,6 +1544,14 @@ class TPCTimeSeries : public Task
                             << "mX_ITS=" << mx_ITS
                             << "nClITS=" << nClITS
                             << "chi2ITS=" << chi2ITS
+                            << "itsClusterSizes=" << itsClusterSizes
+                            << "itsHasSharedClusters=" << itsHasSharedClusters
+                            << "itsPattern=" << itsPattern
+                            // D2: TRD tracklet data
+                            << "trdPattern=" << trdPattern
+                            << "nTRDTracklets=" << nTRDTracklets
+                            << "trdTracklets=" << trdTrackletVec
+                            << "trdCalibTracklets=" << trdCalibVec
                             << "chi2match_ITSTPC=" << chi2match_ITSTPC
                             << "PID=" << trkOrig.getPID().getID()
                             // TPC cov at vertex (without vertex constrained)
@@ -1669,6 +1744,7 @@ class TPCTimeSeries : public Task
 
     std::unordered_map<int, int> nContributors_ITS;    // ITS: vertex ID -> n contributors
     std::unordered_map<int, int> nContributors_ITSTPC; // ITS-TPC (and ITS-TPC-TRD, ITS-TPC-TOF, ITS-TPC-TRD-TOF): vertex ID -> n contributors
+    std::unordered_map<int, int> nContributors_TRD;    // ITS-TPC-TRD (and ITS-TPC-TRD-TOF): vertex ID -> n TRD-matched PV contributors
 
     // loop over collisions
     if (!vertices.empty()) {
@@ -1689,6 +1765,10 @@ class TPCTimeSeries : public Task
               if (refITSTPC.isIndexSet()) {
                 indicesITSTPC_vtx[refITSTPC] = vID;
                 ++nContributors_ITSTPC[vID];
+                // count TRD-matched PV contributors
+                if (source == TrkSrc::ITSTPCTRD || source == TrkSrc::ITSTPCTRDTOF) {
+                  ++nContributors_TRD[vID];
+                }
               } else {
                 ++nContributors_ITS[vID];
               }
@@ -1750,6 +1830,17 @@ class TPCTimeSeries : public Task
     mBufferDCA.vertexY_ITSTPC_RMS.front() = avgVtxITSTPC[1].getStdDev();
     mBufferDCA.vertexZ_ITSTPC_RMS.front() = avgVtxITSTPC[2].getStdDev();
 
+    // TRD matching fraction (summed over all vertices in this TF)
+    int sumITSTPCBased = 0;
+    int sumWithTRD = 0;
+    for (int ivtx = 0; ivtx < vertices.size(); ++ivtx) {
+      sumITSTPCBased += nContributors_ITSTPC[ivtx];
+      sumWithTRD += nContributors_TRD[ivtx];
+    }
+    mBufferDCA.nITSTPCBasedPVContributors.front() = sumITSTPCBased;
+    mBufferDCA.nITSTPCWithTRDPVContributors.front() = sumWithTRD;
+    mBufferDCA.fracTRD.front() = (sumITSTPCBased > 0) ? static_cast<float>(sumWithTRD) / sumITSTPCBased : std::nanf("");
+
     // quantiles and truncated mean
     RobustAverage avg(vertices.size(), false);
     for (const auto& vtx : vertices) {
@@ -1839,6 +1930,10 @@ o2::framework::DataProcessorSpec getTPCTimeSeriesSpec(const bool disableWriter,
   if (src[GTrackID::TPC]) {
     dataRequest->requestClusters(GTrackID::getSourcesMask("TPC"), useMC);
   }
+  // D2: request TRD tracklets for tracks with TRD contribution
+  if (srcTracks[GTrackID::ITSTPCTRD] || srcTracks[GTrackID::ITSTPCTRDTOF]) {
+    dataRequest->requestTRDTracklets(useMC);
+  }
 
   bool tpcOnly = srcTracks == GTrackID::getSourcesMask("TPC");
   if (srcTracks.any() && !tpcOnly) {

Detectors/TPC/workflow/src/tpc-time-series.cxx

@@ -14,22 +14,38 @@
 
 #include "TPCWorkflow/TPCTimeSeriesSpec.h"
 #include "TPCWorkflow/TPCTimeSeriesWriterSpec.h"
+#include "DetectorsCommonDataFormats/DetID.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "TPCReaderWorkflow/TPCSectorCompletionPolicy.h"
+#include "DetectorsBase/DPLWorkflowUtils.h"
+#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
+#include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "Framework/ConfigParamSpec.h"
 #include "GPUDebugStreamer.h"
 
 using namespace o2::framework;
+using GID = o2::dataformats::GlobalTrackID;
+using DetID = o2::detectors::DetID;
+
+// ------------------------------------------------------------------
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies)
+{
+  o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
+}
 
 void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 {
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     {"disable-root-output", VariantType::Bool, false, {"disable root-files output writers"}},
+    {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
     {"enable-unbinned-root-output", VariantType::Bool, false, {"writing out unbinned track data"}},
-    {"track-sources", VariantType::String, std::string{o2::dataformats::GlobalTrackID::ALL}, {"comma-separated list of sources to use"}},
+    {"track-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of sources to use"}},
     {"material-type", VariantType::Int, 2, {"Type for the material budget during track propagation: 0=None, 1=Geo, 2=LUT"}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
+  o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
@@ -41,11 +57,28 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   o2::conf::ConfigurableParam::updateFromString(config.options().get<std::string>("configKeyValues"));
   const bool disableWriter = config.options().get<bool>("disable-root-output");
   const bool enableUnbinnedWriter = config.options().get<bool>("enable-unbinned-root-output");
-  auto src = o2::dataformats::GlobalTrackID::getSourcesMask(config.options().get<std::string>("track-sources"));
+  GID::mask_t allowedSources = GID::getSourcesMask("ITS,TPC,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF,FT0");
+  auto srcTrc = allowedSources & GID::getSourcesMask(config.options().get<std::string>("track-sources"));
+  o2::dataformats::GlobalTrackID::mask_t srcCls = GID::getSourcesMask("TPC");
+  if (GID::includesDet(DetID::ITS, srcTrc)) {
+    srcCls |= GID::getSourcesMask("ITS");
+  }
+  if (GID::includesDet(DetID::TRD, srcTrc)) {
+    srcCls |= GID::getSourcesMask("TRD");
+  }
+  if (GID::includesDet(DetID::TOF, srcTrc)) {
+    srcCls |= GID::getSourcesMask("TOF");
+  }
+
   auto materialType = static_cast<o2::base::Propagator::MatCorrType>(config.options().get<int>("material-type"));
-  workflow.emplace_back(o2::tpc::getTPCTimeSeriesSpec(disableWriter, materialType, enableUnbinnedWriter, src));
+
+  o2::globaltracking::InputHelper::addInputSpecs(config, workflow, srcCls, srcTrc, srcTrc, false);
+  o2::globaltracking::InputHelper::addInputSpecsPVertex(config, workflow, false); // P-vertex is always needed
+
+  workflow.emplace_back(o2::tpc::getTPCTimeSeriesSpec(disableWriter, materialType, enableUnbinnedWriter, srcTrc));
   if (!disableWriter) {
     workflow.emplace_back(o2::tpc::getTPCTimeSeriesWriterSpec());
   }
+  o2::raw::HBFUtilsInitializer hbfIni(config, workflow);
   return workflow;
 }

prodtests/full-system-test/calib-workflow.sh

@@ -23,7 +23,7 @@ fi
 if [[ "${CALIB_TPC_SCDCALIB_SENDTRKDATA:-}" == "1" ]]; then ENABLE_TRKDATA_OUTPUT="--send-track-data"; else ENABLE_TRKDATA_OUTPUT=""; fi
 
 # specific calibration workflows
-if [[ $CALIB_TPC_SCDCALIB == 1 ]]; then add_W o2-tpc-scdcalib-interpolation-workflow "--vtx-sources $VERTEX_TRACK_MATCHING_SOURCES --tracking-sources $TRACK_SOURCES ${CALIB_TPC_SCDCALIB_SLOTLENGTH:+"--sec-per-slot $CALIB_TPC_SCDCALIB_SLOTLENGTH"} $ENABLE_TRKDATA_OUTPUT $DISABLE_ROOT_OUTPUT --disable-root-input --pipeline $(get_N tpc-track-interpolation TPC REST)"; fi
+if [[ $CALIB_TPC_SCDCALIB == 1 ]]; then add_W o2-tpc-scdcalib-interpolation-workflow "--vtx-sources $VERTEX_TRACK_MATCHING_SOURCES --tracking-sources $TRACK_SOURCES ${CALIB_TPC_SCDCALIB_SLOTLENGTH:+"--sec-per-slot $CALIB_TPC_SCDCALIB_SLOTLENGTH"} $ENABLE_TRKDATA_OUTPUT $DISABLE_ROOT_OUTPUT $DISABLE_ROOT_INPUT --pipeline $(get_N tpc-track-interpolation TPC REST)"; fi
 if [[ $CALIB_TPC_TIMEGAIN == 1 ]]; then
   : ${SCALEEVENTS_TPC_TIMEGAIN:=40}
   : ${SCALETRACKS_TPC_TIMEGAIN:=1000}
@@ -77,7 +77,7 @@ if [[ $CALIB_ASYNC_EXTRACTTIMESERIES == 1 ]] ; then
   CONFIG_TPCTIMESERIES+=" --min-cluster ${TPCTIMESERIES_MIN_CLUSTER}"
   CONFIG_TPCTIMESERIES+=" --max-tgl ${TPCTIMESERIES_MAX_TGL}"
   CONFIG_TPCTIMESERIES+=" --mult-max ${TPCTIMESERIES_MULT_MAX}"
-  add_W o2-tpc-time-series-workflow "${CONFIG_TPCTIMESERIES}"
+  add_W o2-tpc-time-series-workflow "$DISABLE_ROOT_INPUT ${CONFIG_TPCTIMESERIES}"
 fi
 
 # output-proxy for aggregator