New tracker conditions tables for TOT and HV trips

CosmicReco/src/CosmicShowerFilter_module.cc

@@ -145,7 +145,7 @@ namespace mu2e {
                 int gap = 0;
                 for (size_t k=straws[i][j-1]+2;k<straws[i][j];k+=2){
                   StrawId sid(i/6,i%6,k);
-                  if (!trackerStatus.noSignal(sid) && !trackerStatus.suppress(sid)) {
+                  if (!trackerStatus.noSignal(sid,event.event()) && !trackerStatus.suppress(sid)) {
                     gap += 1;
                   }
                 }
@@ -164,7 +164,7 @@ namespace mu2e {
                   int gap = 0;
                   for (size_t k=straws[i][j-1]+1;k<straws[i][j];k++){
                     StrawId sid(i/6,i%6,k);
-                    if (!trackerStatus.noSignal(sid) && !trackerStatus.suppress(sid)) {
+                    if (!trackerStatus.noSignal(sid,event.event()) && !trackerStatus.suppress(sid)) {
                       gap += 1;
                     }
                   }

DbTables/inc/TrkHVTripStatus.hh

@@ -0,0 +1,86 @@
+#ifndef DbTables_TrkHVTripStatus_hh
+#define DbTables_TrkHVTripStatus_hh
+
+#include "Offline/DataProducts/inc/StrawId.hh"
+#include "Offline/DataProducts/inc/StrawIdMask.hh"
+#include "Offline/DataProducts/inc/StrawStatus.hh"
+#include "Offline/DbTables/inc/DbTable.hh"
+#include "cetlib_except/exception.h"
+#include <iomanip>
+#include <map>
+#include <regex>
+#include <sstream>
+#include <string>
+
+namespace mu2e {
+
+class TrkHVTripStatus : public DbTable {
+ public:
+
+   class Row {
+     public:
+       Row(int index, StrawId sid, uint32_t startevent, uint32_t endevent) :
+         _index(index), _sid(sid), _startevent(startevent), _endevent(endevent) {}
+       int index() const { return _index; }
+       StrawId const& id() const { return _sid; }
+       uint32_t startevent() const { return _startevent; }
+       uint32_t endevent() const { return _endevent; }
+
+     private:
+       int _index;
+       StrawId _sid;
+       uint32_t _startevent;
+       uint32_t _endevent;
+   };
+
+
+
+  typedef std::shared_ptr<TrkHVTripStatus> ptr_t;
+  typedef std::shared_ptr<const TrkHVTripStatus> cptr_t;
+
+  constexpr static const char* cxname = "TrkHVTripStatus";
+
+  TrkHVTripStatus() :
+      DbTable(cxname, "trk.hvtripstatus",
+              "index,strawid,startevent,endevent") {}
+  const Row& rowAt(const std::size_t index) const { return _rows.at(index); }
+  std::vector<Row> const& rows() const { return _rows; }
+  std::size_t nrow() const override { return _rows.size(); };
+  // this is a variable-size table, so don't overrido nrowFix()
+  size_t size() const override { return baseSize() + nrow() * sizeof(Row); };
+  const std::string orderBy() const { return std::string("index"); }
+
+  void addRow(const std::vector<std::string>& columns) override {
+    int index = std::stoi(columns[0]);
+    auto sid = StrawId(columns[1]);
+    uint32_t startevent = std::stoul(columns[2]);
+    uint32_t endevent = std::stoul(columns[3]);
+    // enforce a strict sequential order
+    if (index != int(_rows.size())) {
+      throw cet::exception("TRKHVTRIPSTATUS_BAD_INDEX")
+          << "TrkHVTripStatus::addRow found index out of order: " << index
+          << " != " << _rows.size() << "\n";
+    }
+    _rows.emplace_back(index, sid, startevent, endevent);
+  }
+
+  void rowToCsv(std::ostringstream& sstream, std::size_t irow) const override {
+    Row const& r = _rows.at(irow);
+    sstream << r.index() << ",";
+    sstream << r.id().plane() << "_" << r.id().panel() << "_" << r.id().straw()
+            << ",";
+    sstream << r.startevent() << ",";
+    sstream << r.endevent();
+  }
+
+  virtual void clear() override {
+    baseClear();
+    _rows.clear();
+  }
+
+ private:
+  std::vector<Row> _rows;
+};
+
+}  // namespace mu2e
+#endif

DbTables/inc/TrkTOTCalib.hh

@@ -0,0 +1,128 @@
+#ifndef DbTables_TrkTOTCalib_hh
+#define DbTables_TrkTOTCalib_hh
+
+#include "Offline/DbTables/inc/DbTable.hh"
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+
+namespace mu2e {
+
+  class TrkTOTCalibParams : public DbTable {
+    public:
+      typedef std::shared_ptr<TrkTOTCalibParams> ptr_t;
+      typedef std::shared_ptr<const TrkTOTCalibParams> cptr_t;
+
+      class Row {
+        public:
+          Row(int totTBins, float totTBinWidth, int totEBins, float totEBinWidth)
+            : _totTBins(totTBins), _totTBinWidth(totTBinWidth),
+            _totEBins(totEBins), _totEBinWidth(totEBinWidth) {}
+          int   totTBins()    const { return _totTBins; }
+          float totTBinWidth() const { return _totTBinWidth; }
+          int   totEBins()    const { return _totEBins; }
+          float totEBinWidth() const { return _totEBinWidth; }
+        private:
+          int   _totTBins;
+          float _totTBinWidth;
+          int   _totEBins;
+          float _totEBinWidth;
+      };
+
+      constexpr static const char* cxname = "TrkTOTCalibParams";
+
+      TrkTOTCalibParams() :
+        DbTable(cxname, "trk.totcalibparams",
+            "tottbins,tottbinwidth,totebins,totebinwidth") {}
+      const Row& rowAt(const std::size_t index) const { return _rows.at(index); }
+      std::vector<Row> const& rows() const { return _rows; }
+      std::size_t nrow() const override { return _rows.size(); };
+      virtual std::size_t nrowFix() const override { return 1; }
+      size_t size() const override { return baseSize() + nrow() * sizeof(Row); };
+      const std::string orderBy() const { return std::string("tottbins"); }
+
+      void addRow(const std::vector<std::string>& columns) override {
+        if (_rows.size() != 0)
+          throw cet::exception("TRKTOTCALIBPARAMS_BAD_INDEX")
+            << "TrkTOTCalibParams::addRow adding more than one row\n";
+        _rows.emplace_back(std::stoi(columns[0]), std::stof(columns[1]),
+            std::stoi(columns[2]), std::stof(columns[3]));
+      }
+
+      void rowToCsv(std::ostringstream& sstream, std::size_t irow) const override {
+        Row const& r = _rows.at(irow);
+        sstream << std::fixed << std::setprecision(1);
+        sstream << r.totTBins() << ",";
+        sstream << r.totTBinWidth() << ",";
+        sstream << r.totEBins() << ",";
+        sstream << r.totEBinWidth();
+      }
+
+      virtual void clear() override {
+        baseClear();
+        _rows.clear();
+      }
+
+    private:
+      std::vector<Row> _rows;
+  };
+
+  class TrkTOTCalib : public DbTable {
+    public:
+      typedef std::shared_ptr<TrkTOTCalib> ptr_t;
+      typedef std::shared_ptr<const TrkTOTCalib> cptr_t;
+
+      class Row {
+        public:
+          Row(int index, float driftTime, float driftError)
+            : _index(index), _driftTime(driftTime), _driftError(driftError) {}
+          int   index()      const { return _index; }
+          float driftTime()  const { return _driftTime; }
+          float driftError() const { return _driftError; }
+        private:
+          int   _index;
+          float _driftTime;
+          float _driftError;
+      };
+
+      constexpr static const char* cxname = "TrkTOTCalib";
+
+      TrkTOTCalib() :
+        DbTable(cxname, "trk.totcalib",
+            "index,drifttime,drifterror") {}
+      const Row& rowAt(const std::size_t index) const { return _rows.at(index); }
+      std::vector<Row> const& rows() const { return _rows; }
+      std::size_t nrow() const override { return _rows.size(); };
+      size_t size() const override { return baseSize() + nrow() * sizeof(Row); };
+      const std::string orderBy() const { return std::string("index"); }
+
+      void addRow(const std::vector<std::string>& columns) override {
+        int index = std::stoi(columns[0]);
+        // enforce a strict sequential order
+        if (index != int(_rows.size())) {
+          throw cet::exception("TRKTOTCALIB_BAD_INDEX")
+            << "TrkTOTCalib::addRow found index out of order: " << index
+            << " != " << _rows.size() << "\n";
+        }
+        _rows.emplace_back(index,std::stof(columns[1]), std::stof(columns[2]));
+      }
+
+      void rowToCsv(std::ostringstream& sstream, std::size_t irow) const override {
+        Row const& r = _rows.at(irow);
+        sstream << std::fixed << std::setprecision(1);
+        sstream << r.driftTime() << ",";
+        sstream << r.driftError();
+      }
+
+      virtual void clear() override {
+        baseClear();
+        _rows.clear();
+      }
+
+    private:
+      std::vector<Row> _rows;
+  };
+
+};  // namespace mu2e
+#endif

DbTables/src/DbTableFactory.cc

@@ -32,6 +32,8 @@
 #include "Offline/DbTables/inc/TrkElementStatus.hh"
 #include "Offline/DbTables/inc/TrkPanelMap.hh"
 #include "Offline/DbTables/inc/TrkPreampStraw.hh"
+#include "Offline/DbTables/inc/TrkTOTCalib.hh"
+#include "Offline/DbTables/inc/TrkHVTripStatus.hh"
 #include "Offline/DbTables/inc/TstCalib1.hh"
 #include "Offline/DbTables/inc/TstCalib2.hh"
 #include "Offline/DbTables/inc/TstCalib3.hh"
@@ -80,6 +82,12 @@ mu2e::DbTable::ptr_t mu2e::DbTableFactory::newTable(std::string const& name) {
     return std::shared_ptr<mu2e::DbTable>(new mu2e::TrkStrawStatusLong());
   } else if (name == "TrkStrawStatusShort") {
     return std::shared_ptr<mu2e::DbTable>(new mu2e::TrkStrawStatusShort());
+  } else if (name == "TrkHVTripStatus") {
+    return std::shared_ptr<mu2e::DbTable>(new mu2e::TrkHVTripStatus());
+  } else if (name == "TrkTOTCalib") {
+    return std::shared_ptr<mu2e::DbTable>(new mu2e::TrkTOTCalib());
+  } else if (name == "TrkTOTCalibParams") {
+    return std::shared_ptr<mu2e::DbTable>(new mu2e::TrkTOTCalibParams());
   } else if (name == "AnaTrkQualDb") {
     return std::shared_ptr<mu2e::DbTable>(new mu2e::AnaTrkQualDb());
   } else if (name == "SimEfficiencies") {

Filters/src/StrawGasStepFilter_module.cc

@@ -50,7 +50,7 @@ namespace mu2e{
     auto steps = event.getValidHandle<StrawGasStepCollection>(_stepsTag);
     auto const& stepcol = *steps;
     for (auto const& step : stepcol){
-      if (!trackerStatus->noSignal(step.strawId()))
+      if (!trackerStatus->noSignal(step.strawId(),event.event()))
         count += 1;
     }
     return count >= _minSteps;

TrackerConditions/fcl/testTrackerAlignment.fcl

@@ -3,6 +3,7 @@ process_name : TestTrkAlign
 
 source : {
   module_type : EmptyEvent
+  firstRun : 1400
 }
 services : @local::Services.Core
 
@@ -21,8 +22,10 @@ physics : {
 # turn on alignment
 services.ProditionsService.alignedTracker.useDb: true
 services.ProditionsService.alignedTracker.verbose: 2
+services.DbService.purpose : "Sim_best"
+services.DbService.version : "v1_4"
 # select nominal (perfect) alignment or a misaligned file
-services.DbService.textFile : ["Offline/TrackerConditions/data/MisalignTracker.txt"]
+services.DbService.textFile : ["align.txt"]
 # services.DbService.verbose: 2
 
 services.TFileService.fileName: "testAlign.root"

TrackerConditions/inc/StrawResponse.hh

@@ -34,7 +34,7 @@ namespace mu2e {
           StrawElectronics::cptr_t strawElectronics,
           StrawPhysics::cptr_t strawPhysics,
           int eBins, double eBinWidth,
-          std::vector<double> edep, std::vector<double> halfvpscale,
+          std::vector<double> edep, std::vector<double> halfpvscale,
           double central, std::vector<double> centres,
           std::vector<double> resslope, bool truncateLongitudinal,
           bool rmsLongErrors, int totTBins, double totTBinWidth,
@@ -59,7 +59,7 @@ namespace mu2e {
         _strawElectronics(strawElectronics),
         _strawPhysics(strawPhysics),
         _eBins(eBins), _eBinWidth(eBinWidth),
-        _edep(edep), _halfvpscale(halfvpscale), _central(central), _centres(centres),
+        _edep(edep), _halfpvscale(halfpvscale), _central(central), _centres(centres),
         _resslope(resslope), _truncateLongitudinal(truncateLongitudinal),
         _rmsLongErrors(rmsLongErrors), _totTBins(totTBins), _totTBinWidth(totTBinWidth),
         _totEBins(totEBins), _totEBinWidth(totEBinWidth),
@@ -101,12 +101,21 @@ namespace mu2e {
 
       // this is used to update values from the database
       void setOffsets( std::array<double, StrawId::_nupanels> timeOffsetPanel,
-          std::array<double, StrawId::_nustraws> timeOffsetStrawHV,
-          std::array<double, StrawId::_nustraws> timeOffsetStrawCal ) {
+          std::array<double, StrawId::_nustraws> const& timeOffsetStrawHV,
+          std::array<double, StrawId::_nustraws> const& timeOffsetStrawCal ) {
         _timeOffsetPanel = timeOffsetPanel;
         _timeOffsetStrawHV = timeOffsetStrawHV;
         _timeOffsetStrawCal = timeOffsetStrawCal;
       }
+      void setTOTCalib(size_t tottbins, double tottbinwidth, size_t totebins, double totebinwidth,
+          std::vector<double> totdtime, std::vector<double> totderror){
+        _totTBins = tottbins;
+        _totTBinWidth = tottbinwidth;
+        _totEBins = totebins;
+        _totEBinWidth = totebinwidth;
+        _totdtime = std::move(totdtime);
+        _totderror = std::move(totderror);
+      }
 
       DriftInfo driftInfo(StrawId strawId, double dtime, double phi) const;
 
@@ -170,7 +179,7 @@ namespace mu2e {
       int _eBins;
       double _eBinWidth;
       std::vector<double> _edep; // energy deposit boundaries
-      std::vector<double> _halfvpscale; // scaling of effective 1/2 propagation velocity by edep
+      std::vector<double> _halfpvscale; // scaling of effective 1/2 propagation velocity by edep
       double _central; // max wire distance for central wire region
       std::vector<double> _centres; // wire center resolution by edep
       std::vector<double> _resslope; // resolution slope vs position by edep

TrackerConditions/inc/StrawResponseCache.hh

@@ -17,6 +17,10 @@ namespace mu2e {
         _strawDrift_p = std::make_unique<ProditionsHandle<StrawDrift> >();
         _strawElectronics_p = std::make_unique<ProditionsHandle<StrawElectronics> >();
         _strawPhysics_p = std::make_unique<ProditionsHandle<StrawPhysics> >();
+        if (_useDb) {
+          _ttc_p = std::make_unique<DbHandle<TrkTOTCalib>>();
+          _ttcp_p = std::make_unique<DbHandle<TrkTOTCalibParams>>();
+        }
       }
       set_t makeSet(art::EventID const& eid) {
         auto sd = _strawDrift_p->get(eid);
@@ -25,6 +29,14 @@ namespace mu2e {
         auto ss = sd.getCids();
         ss.merge(set_t(se.getCids()));
         ss.merge(set_t(sp.getCids()));
+        if (_useDb){
+          // get the tables up to date
+          _ttc_p->get(eid);
+          _ttcp_p->get(eid);
+          // save which data goes into this instance of the service
+          ss.insert(_ttc_p->cid());
+          ss.insert(_ttcp_p->cid());
+        }
         return ss;
       }
       DbIoV makeIov(art::EventID const& eid) {
@@ -34,13 +46,23 @@ namespace mu2e {
         auto iov = _strawDrift_p->iov();
         iov.overlap(_strawElectronics_p->iov());
         iov.overlap(_strawPhysics_p->iov());
+        if(_useDb) {
+          _ttc_p->get(eid);
+          _ttcp_p->get(eid);
+          iov.overlap(_ttc_p->iov());
+          iov.overlap(_ttcp_p->iov());
+        }
         return iov;
       }
       ProditionsEntity::ptr makeEntity(art::EventID const& eid) {
         auto sd = _strawDrift_p->getPtr(eid);
         auto se = _strawElectronics_p->getPtr(eid);
         auto sp = _strawPhysics_p->getPtr(eid);
-        return _maker.fromFcl(sd,se,sp);
+        if (_useDb){
+          return _maker.fromDb(sd,se,sp,_ttc_p->getPtr(eid),_ttcp_p->getPtr(eid));
+        }else{
+          return _maker.fromFcl(sd,se,sp);
+        }
       }
 
     private:
@@ -52,6 +74,8 @@ namespace mu2e {
       std::unique_ptr<ProditionsHandle<StrawDrift> > _strawDrift_p;
       std::unique_ptr<ProditionsHandle<StrawElectronics> > _strawElectronics_p;
       std::unique_ptr<ProditionsHandle<StrawPhysics> > _strawPhysics_p;
+      std::unique_ptr<DbHandle<TrkTOTCalib>> _ttc_p;
+      std::unique_ptr<DbHandle<TrkTOTCalibParams>> _ttcp_p;
   };
 }