From ff236f975f8b530930b9fabea3efa89bbe4983e3 Mon Sep 17 00:00:00 2001 From: Richard Bonventre Date: Mon, 11 May 2026 18:05:36 -0500 Subject: [PATCH 1/2] Added TOT tables --- DbTables/inc/TrkTOTCalib.hh | 128 ++++++++++++++++++++ DbTables/src/DbTableFactory.cc | 5 + TrackerConditions/inc/StrawResponse.hh | 19 ++- TrackerConditions/inc/StrawResponseCache.hh | 26 +++- TrackerConditions/inc/StrawResponseMaker.hh | 7 +- TrackerConditions/src/StrawResponse.cc | 6 +- TrackerConditions/src/StrawResponseMaker.cc | 24 ++++ 7 files changed, 204 insertions(+), 11 deletions(-) create mode 100644 DbTables/inc/TrkTOTCalib.hh diff --git a/DbTables/inc/TrkTOTCalib.hh b/DbTables/inc/TrkTOTCalib.hh new file mode 100644 index 0000000000..c121a141f6 --- /dev/null +++ b/DbTables/inc/TrkTOTCalib.hh @@ -0,0 +1,128 @@ +#ifndef DbTables_TrkTOTCalib_hh +#define DbTables_TrkTOTCalib_hh + +#include "Offline/DbTables/inc/DbTable.hh" +#include +#include +#include +#include + +namespace mu2e { + + class TrkTOTCalibParams : public DbTable { + public: + typedef std::shared_ptr ptr_t; + typedef std::shared_ptr 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 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& 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 _rows; + }; + + class TrkTOTCalib : public DbTable { + public: + typedef std::shared_ptr ptr_t; + typedef std::shared_ptr 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 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& 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 _rows; + }; + +}; // namespace mu2e +#endif diff --git a/DbTables/src/DbTableFactory.cc b/DbTables/src/DbTableFactory.cc index 2e6bd545fe..e2a4385d3e 100644 --- a/DbTables/src/DbTableFactory.cc +++ b/DbTables/src/DbTableFactory.cc @@ -32,6 +32,7 @@ #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/TstCalib1.hh" #include "Offline/DbTables/inc/TstCalib2.hh" #include "Offline/DbTables/inc/TstCalib3.hh" @@ -80,6 +81,10 @@ mu2e::DbTable::ptr_t mu2e::DbTableFactory::newTable(std::string const& name) { return std::shared_ptr(new mu2e::TrkStrawStatusLong()); } else if (name == "TrkStrawStatusShort") { return std::shared_ptr(new mu2e::TrkStrawStatusShort()); + } else if (name == "TrkTOTCalib") { + return std::shared_ptr(new mu2e::TrkTOTCalib()); + } else if (name == "TrkTOTCalibParams") { + return std::shared_ptr(new mu2e::TrkTOTCalibParams()); } else if (name == "AnaTrkQualDb") { return std::shared_ptr(new mu2e::AnaTrkQualDb()); } else if (name == "SimEfficiencies") { diff --git a/TrackerConditions/inc/StrawResponse.hh b/TrackerConditions/inc/StrawResponse.hh index 68addb7e1d..8dd1f73864 100644 --- a/TrackerConditions/inc/StrawResponse.hh +++ b/TrackerConditions/inc/StrawResponse.hh @@ -34,7 +34,7 @@ namespace mu2e { StrawElectronics::cptr_t strawElectronics, StrawPhysics::cptr_t strawPhysics, int eBins, double eBinWidth, - std::vector edep, std::vector halfvpscale, + std::vector edep, std::vector halfpvscale, double central, std::vector centres, std::vector 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 timeOffsetPanel, - std::array timeOffsetStrawHV, - std::array timeOffsetStrawCal ) { + std::array const& timeOffsetStrawHV, + std::array const& timeOffsetStrawCal ) { _timeOffsetPanel = timeOffsetPanel; _timeOffsetStrawHV = timeOffsetStrawHV; _timeOffsetStrawCal = timeOffsetStrawCal; } + void setTOTCalib(size_t tottbins, double tottbinwidth, size_t totebins, double totebinwidth, + std::vector totdtime, std::vector 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 _edep; // energy deposit boundaries - std::vector _halfvpscale; // scaling of effective 1/2 propagation velocity by edep + std::vector _halfpvscale; // scaling of effective 1/2 propagation velocity by edep double _central; // max wire distance for central wire region std::vector _centres; // wire center resolution by edep std::vector _resslope; // resolution slope vs position by edep diff --git a/TrackerConditions/inc/StrawResponseCache.hh b/TrackerConditions/inc/StrawResponseCache.hh index e3fe892b18..52da813f97 100644 --- a/TrackerConditions/inc/StrawResponseCache.hh +++ b/TrackerConditions/inc/StrawResponseCache.hh @@ -17,6 +17,10 @@ namespace mu2e { _strawDrift_p = std::make_unique >(); _strawElectronics_p = std::make_unique >(); _strawPhysics_p = std::make_unique >(); + if (_useDb) { + _ttc_p = std::make_unique>(); + _ttcp_p = std::make_unique>(); + } } 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 > _strawDrift_p; std::unique_ptr > _strawElectronics_p; std::unique_ptr > _strawPhysics_p; + std::unique_ptr> _ttc_p; + std::unique_ptr> _ttcp_p; }; } diff --git a/TrackerConditions/inc/StrawResponseMaker.hh b/TrackerConditions/inc/StrawResponseMaker.hh index 6e41c2cf1d..987a22e049 100644 --- a/TrackerConditions/inc/StrawResponseMaker.hh +++ b/TrackerConditions/inc/StrawResponseMaker.hh @@ -8,7 +8,7 @@ #include "Offline/TrackerConditions/inc/StrawResponse.hh" #include "Offline/TrackerConfig/inc/StrawResponseConfig.hh" - +#include "Offline/DbTables/inc/TrkTOTCalib.hh" namespace mu2e { @@ -18,7 +18,10 @@ namespace mu2e { StrawResponse::ptr_t fromFcl(StrawDrift::cptr_t strawDrift, StrawElectronics::cptr_t strawElectronics, StrawPhysics::cptr_t strawPhysics); - StrawResponse::ptr_t fromDb( /* db tables will go here*/ ); + StrawResponse::ptr_t fromDb(StrawDrift::cptr_t strawDrift, + StrawElectronics::cptr_t strawElectronics, + StrawPhysics::cptr_t strawPhysics, + TrkTOTCalib::cptr_t ttc, TrkTOTCalibParams::cptr_t ttcp); private: diff --git a/TrackerConditions/src/StrawResponse.cc b/TrackerConditions/src/StrawResponse.cc index 917626ef82..b1be69342e 100644 --- a/TrackerConditions/src/StrawResponse.cc +++ b/TrackerConditions/src/StrawResponse.cc @@ -145,7 +145,7 @@ namespace mu2e { double StrawResponse::halfPropV(StrawId strawId, double kedep) const { double mean_prop_v = _strawHalfvp[strawId.uniqueStraw()]; - return PieceLine(_edep,_halfvpscale,kedep)*mean_prop_v; + return PieceLine(_edep,_halfpvscale,kedep)*mean_prop_v; } double StrawResponse::wpRes(double kedep,double wlen) const { @@ -205,9 +205,9 @@ namespace mu2e { os << endl << "StrawResponse parameters: " << std::endl; printVector(os,"edep",_edep); - printVector(os,"ehalfvpscale",_halfvpscale); + printVector(os,"ehalfpvscale",_halfpvscale); os << "central = " << _central << endl; - printArray(os,"halfvp",_strawHalfvp); + printArray(os,"halfpv",_strawHalfvp); printVector(os,"centres",_centres); printVector(os,"resslope",_resslope); printVector(os,"totdtime",_totdtime); diff --git a/TrackerConditions/src/StrawResponseMaker.cc b/TrackerConditions/src/StrawResponseMaker.cc index 14ed3b4ea0..29679f8cce 100644 --- a/TrackerConditions/src/StrawResponseMaker.cc +++ b/TrackerConditions/src/StrawResponseMaker.cc @@ -144,4 +144,28 @@ namespace mu2e { return ptr; } + StrawResponse::ptr_t StrawResponseMaker::fromDb( + StrawDrift::cptr_t strawDrift, + StrawElectronics::cptr_t strawElectronics, + StrawPhysics::cptr_t strawPhysics, + TrkTOTCalib::cptr_t ttc, + TrkTOTCalibParams::cptr_t ttcp) { + // initially fill from fcl to get all the constants + auto ptr = fromFcl(strawDrift, strawElectronics, strawPhysics); + + size_t tottbins = (size_t) ttcp->rowAt(0).totTBins(); + size_t totebins = (size_t) ttcp->rowAt(0).totEBins(); + double tottbinwidth = ttcp->rowAt(0).totTBinWidth(); + double totebinwidth = ttcp->rowAt(0).totEBinWidth(); + std::vector totdtime; + std::vector totderror; + for (size_t i=0;irowAt(i).driftTime()); + totderror.push_back(ttc->rowAt(i).driftError()); + } + + ptr->setTOTCalib(tottbins, tottbinwidth, totebins, totebinwidth, totdtime, totderror); + + return ptr; + } } From 98cf831d2a5c0ea4adc3ad9c60c49b4be94cd79f Mon Sep 17 00:00:00 2001 From: Richard Bonventre Date: Tue, 12 May 2026 12:09:19 -0500 Subject: [PATCH 2/2] Added status table for within run HV trips --- CosmicReco/src/CosmicShowerFilter_module.cc | 4 +- DbTables/inc/TrkHVTripStatus.hh | 86 +++++++++++++++++++ DbTables/src/DbTableFactory.cc | 3 + Filters/src/StrawGasStepFilter_module.cc | 2 +- .../fcl/testTrackerAlignment.fcl | 5 +- TrackerConditions/inc/TrackerStatus.hh | 7 +- TrackerConditions/inc/TrackerStatusCache.hh | 9 +- TrackerConditions/inc/TrackerStatusMaker.hh | 4 +- TrackerConditions/src/TrackerStatus.cc | 37 +++++++- TrackerConditions/src/TrackerStatusMaker.cc | 5 +- TrackerMC/src/StationStepSelector_module.cc | 2 +- .../src/StrawDigisFromStrawGasSteps_module.cc | 2 +- TrkHitReco/inc/StrawHitRecoUtils.hh | 2 +- TrkHitReco/src/StrawHitRecoUtils.cc | 4 +- TrkHitReco/src/StrawHitReco_module.cc | 2 +- 15 files changed, 158 insertions(+), 16 deletions(-) create mode 100644 DbTables/inc/TrkHVTripStatus.hh diff --git a/CosmicReco/src/CosmicShowerFilter_module.cc b/CosmicReco/src/CosmicShowerFilter_module.cc index c7c0fd7652..1cdfa14043 100644 --- a/CosmicReco/src/CosmicShowerFilter_module.cc +++ b/CosmicReco/src/CosmicShowerFilter_module.cc @@ -145,7 +145,7 @@ namespace mu2e { int gap = 0; for (size_t k=straws[i][j-1]+2;k +#include +#include +#include +#include + +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 ptr_t; + typedef std::shared_ptr 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 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& 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 _rows; +}; + +} // namespace mu2e +#endif diff --git a/DbTables/src/DbTableFactory.cc b/DbTables/src/DbTableFactory.cc index e2a4385d3e..fb93d57f8c 100644 --- a/DbTables/src/DbTableFactory.cc +++ b/DbTables/src/DbTableFactory.cc @@ -33,6 +33,7 @@ #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" @@ -81,6 +82,8 @@ mu2e::DbTable::ptr_t mu2e::DbTableFactory::newTable(std::string const& name) { return std::shared_ptr(new mu2e::TrkStrawStatusLong()); } else if (name == "TrkStrawStatusShort") { return std::shared_ptr(new mu2e::TrkStrawStatusShort()); + } else if (name == "TrkHVTripStatus") { + return std::shared_ptr(new mu2e::TrkHVTripStatus()); } else if (name == "TrkTOTCalib") { return std::shared_ptr(new mu2e::TrkTOTCalib()); } else if (name == "TrkTOTCalibParams") { diff --git a/Filters/src/StrawGasStepFilter_module.cc b/Filters/src/StrawGasStepFilter_module.cc index 16772d5173..68fa2e316e 100644 --- a/Filters/src/StrawGasStepFilter_module.cc +++ b/Filters/src/StrawGasStepFilter_module.cc @@ -50,7 +50,7 @@ namespace mu2e{ auto steps = event.getValidHandle(_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; diff --git a/TrackerConditions/fcl/testTrackerAlignment.fcl b/TrackerConditions/fcl/testTrackerAlignment.fcl index 408f4b28c5..b853b12c7b 100644 --- a/TrackerConditions/fcl/testTrackerAlignment.fcl +++ b/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" diff --git a/TrackerConditions/inc/TrackerStatus.hh b/TrackerConditions/inc/TrackerStatus.hh index d24bd7f1d4..6e546ce4be 100644 --- a/TrackerConditions/inc/TrackerStatus.hh +++ b/TrackerConditions/inc/TrackerStatus.hh @@ -32,23 +32,28 @@ namespace mu2e { // add status for an element. This is cumulative void addStatus(StrawId const& sid, StrawIdMask const& mask, StrawStatus const& status); + void addTrip(StrawId const&sid, uint32_t startevent, uint32_t endevent); void print( std::ostream& ) const override; // convenience operators for some common situations - bool noSignal(StrawId const& sid) const; // return 'true' if we expect no signal from this straw + bool hvTripped(StrawId const& sid, uint32_t event) const; + bool noSignal(StrawId const& sid, uint32_t event) const; // return 'true' if we expect no signal from this straw bool noisy(StrawId const& sid) const; // This straw sometimes produces a valid signal, but not always bool suppress(StrawId const& sid) const; // This straw may produce a signal, but it should be suppressed as it is inaccurate bool noMaterial(StrawId const& sid) const; // straw doesn't contribute to scattering or energy loss // Net status of an individual Straw. If the straw is in a plane or panel with status, that will be aggregated StrawStatus strawStatus(StrawId const& sid) const; + StrawStatus strawStatus(StrawId const& sid, uint32_t event) const; // including HV trips // same for panel, plane. Note; these will return only status that applies to the ENTIRE PANEL (or plane) // It will NOT detect (say) a panel where every straw has had the same status individually set (that's not a good configuration) StrawStatus panelStatus(StrawId const& sid) const; + StrawStatus panelStatus(StrawId const& sid, uint32_t event) const; // including HV trips StrawStatus planeStatus(StrawId const& sid) const; private: std::array _fullstatus; estat_t _status; + std::map>> _trips; }; } // namespace mu2e diff --git a/TrackerConditions/inc/TrackerStatusCache.hh b/TrackerConditions/inc/TrackerStatusCache.hh index 777518dc06..55e889db7a 100644 --- a/TrackerConditions/inc/TrackerStatusCache.hh +++ b/TrackerConditions/inc/TrackerStatusCache.hh @@ -4,6 +4,7 @@ #include "Offline/Mu2eInterfaces/inc/ProditionsCache.hh" #include "Offline/DbService/inc/DbHandle.hh" #include "Offline/DbTables/inc/TrkElementStatus.hh" +#include "Offline/DbTables/inc/TrkHVTripStatus.hh" #include "Offline/TrackerConditions/inc/TrackerStatusMaker.hh" @@ -21,6 +22,7 @@ namespace mu2e { _tpas_p = std::make_unique>(); _tssl_p = std::make_unique>(); _tsss_p = std::make_unique>(); + _thvs_p = std::make_unique>(); } } @@ -32,10 +34,12 @@ namespace mu2e { _tpas_p->get(eid); _tssl_p->get(eid); _tsss_p->get(eid); + _thvs_p->get(eid); cids.insert(_tpls_p->cid()); cids.insert(_tpas_p->cid()); cids.insert(_tssl_p->cid()); cids.insert(_tsss_p->cid()); + cids.insert(_thvs_p->cid()); } return cids; } @@ -48,6 +52,7 @@ namespace mu2e { iov.overlap(_tpas_p->iov()); iov.overlap(_tssl_p->iov()); iov.overlap(_tsss_p->iov()); + iov.overlap(_thvs_p->iov()); } return iov; } @@ -57,7 +62,8 @@ namespace mu2e { return _maker.fromDb( _tpls_p->getPtr(eid), _tpas_p->getPtr(eid), _tssl_p->getPtr(eid), - _tsss_p->getPtr(eid) ); + _tsss_p->getPtr(eid), + _thvs_p->getPtr(eid)); } else { return _maker.fromFcl(); } @@ -72,6 +78,7 @@ namespace mu2e { std::unique_ptr> _tpas_p; std::unique_ptr> _tssl_p; std::unique_ptr> _tsss_p; + std::unique_ptr> _thvs_p; }; } diff --git a/TrackerConditions/inc/TrackerStatusMaker.hh b/TrackerConditions/inc/TrackerStatusMaker.hh index 3b1f5aa99a..0cc19e9b42 100644 --- a/TrackerConditions/inc/TrackerStatusMaker.hh +++ b/TrackerConditions/inc/TrackerStatusMaker.hh @@ -9,6 +9,7 @@ #include "Offline/TrackerConditions/inc/TrackerStatus.hh" #include "Offline/TrackerConfig/inc/TrackerStatusConfig.hh" #include "Offline/DbTables/inc/TrkElementStatus.hh" +#include "Offline/DbTables/inc/TrkHVTripStatus.hh" // C++ includes #include @@ -25,7 +26,8 @@ namespace mu2e { TrkPlaneStatus::cptr_t tpls_p, TrkPanelStatus::cptr_t tpas_p, TrkStrawStatusLong::cptr_t tssl_p, - TrkStrawStatusShort::cptr_t tsss_p ); // construct from plane, panel, long-term straw and short-term straw status tables + TrkStrawStatusShort::cptr_t tsss_p, + TrkHVTripStatus::cptr_t thvs_p ); // construct from plane, panel, long-term straw and short-term straw status tables private: // this object needs to be thread safe, config_ should only be initialized once const TrackerStatusConfig config_; diff --git a/TrackerConditions/src/TrackerStatus.cc b/TrackerConditions/src/TrackerStatus.cc index b433c347f2..fbc27d6de6 100644 --- a/TrackerConditions/src/TrackerStatus.cc +++ b/TrackerConditions/src/TrackerStatus.cc @@ -68,6 +68,11 @@ namespace mu2e { } } + void TrackerStatus::addTrip(StrawId const& sid, uint32_t startevent, uint32_t endevent) { + _trips[sid.uniquePanel()].emplace_back(startevent, endevent); + } + + void TrackerStatus::print( ostream& out) const{ for( auto ielem = _status.begin(); ielem != _status.end(); ++ielem) { auto const& mask = ielem->first; @@ -84,6 +89,13 @@ namespace mu2e { return _fullstatus[sid.uniqueStraw()]; } + StrawStatus TrackerStatus::strawStatus(StrawId const& sid, uint32_t event) const { + StrawStatus sstat = strawStatus(sid); + if (hvTripped(sid,event)) + sstat.merge(StrawStatus::noHV); + return sstat; + } + StrawStatus TrackerStatus::panelStatus(StrawId const& sid) const { StrawStatus sstat; for( auto ielem = _status.begin(); ielem != _status.end(); ++ielem) { @@ -100,6 +112,13 @@ namespace mu2e { return sstat; } + StrawStatus TrackerStatus::panelStatus(StrawId const& sid, uint32_t event) const { + StrawStatus sstat = panelStatus(sid); + if (hvTripped(sid,event)) + sstat.merge(StrawStatus::noHV); + return sstat; + } + StrawStatus TrackerStatus::planeStatus(StrawId const& sid) const { StrawStatus sstat; for( auto ielem = _status.begin(); ielem != _status.end(); ++ielem) { @@ -116,8 +135,22 @@ namespace mu2e { return sstat; } + bool TrackerStatus::hvTripped(StrawId const& sid, uint32_t event) const { + auto ifnd = _trips.find(sid.uniquePanel()); + if(ifnd != _trips.end()){ + for ( auto ielem = ifnd->second.begin(); ielem != ifnd->second.end(); ++ielem) { + if (ielem->second < event) + continue; + else if (ielem->first <= event){ + return true; + } + } + } + return false; + } + // no signal expected from this straw - bool TrackerStatus::noSignal(StrawId const& sid) const { + bool TrackerStatus::noSignal(StrawId const& sid, uint32_t event) const { static StrawStatus mask = StrawStatus(StrawStatus::absent) | StrawStatus(StrawStatus::nowire) | StrawStatus(StrawStatus::noHV) | @@ -127,7 +160,7 @@ namespace mu2e { StrawStatus(StrawStatus::noHVPreamp) | StrawStatus(StrawStatus::noCalPreamp) | StrawStatus(StrawStatus::disabled); - StrawStatus status = strawStatus(sid); + StrawStatus status = strawStatus(sid, event); return status.hasAnyProperty(mask); } diff --git a/TrackerConditions/src/TrackerStatusMaker.cc b/TrackerConditions/src/TrackerStatusMaker.cc index 79d4983c31..0a25fcde85 100644 --- a/TrackerConditions/src/TrackerStatusMaker.cc +++ b/TrackerConditions/src/TrackerStatusMaker.cc @@ -38,7 +38,8 @@ namespace mu2e { TrkPlaneStatus::cptr_t tpls_p, TrkPanelStatus::cptr_t tpas_p, TrkStrawStatusLong::cptr_t tssl_p, - TrkStrawStatusShort::cptr_t tsss_p ) { + TrkStrawStatusShort::cptr_t tsss_p, + TrkHVTripStatus::cptr_t thvs_p) { // create return object auto trkstatptr = std::make_shared(); auto const& settings = config_.settings(); @@ -48,12 +49,14 @@ namespace mu2e { cout << "Panel table has " << tpas_p->rows().size() << " rows " << endl; cout << "Long-term Straw table has " << tssl_p->rows().size() << " rows " << endl; cout << "Short-term Straw table has " << tsss_p->rows().size() << " rows " << endl; + cout << "HV trip table has " << thvs_p->rows().size() << " rows " << endl; } for (auto const& row : tpls_p->rows()) trkstatptr->addStatus(row.id(),tpls_p->sidMask(),row.status()); for (auto const& row : tpas_p->rows()) trkstatptr->addStatus(row.id(),tpas_p->sidMask(),row.status()); for (auto const& row : tssl_p->rows()) trkstatptr->addStatus(row.id(),tssl_p->sidMask(),row.status()); for (auto const& row : tsss_p->rows()) trkstatptr->addStatus(row.id(),tsss_p->sidMask(),row.status()); + for (auto const& row : thvs_p->rows()) trkstatptr->addTrip(row.id(), row.startevent(), row.endevent()); if ( settings.verbose() > 1 ) trkstatptr->print(cout); return trkstatptr; diff --git a/TrackerMC/src/StationStepSelector_module.cc b/TrackerMC/src/StationStepSelector_module.cc index f68407d198..24630cb681 100644 --- a/TrackerMC/src/StationStepSelector_module.cc +++ b/TrackerMC/src/StationStepSelector_module.cc @@ -56,7 +56,7 @@ namespace mu2e{ auto steps = event.getValidHandle(_stepsTag); auto const& stepcol = *steps; for (auto const& step: stepcol){ - if (!trackerStatus->noSignal(step.strawId())) + if (!trackerStatus->noSignal(step.strawId(),event.event())) counts[step.strawId().station()]++; } std::vector goodstations; diff --git a/TrackerMC/src/StrawDigisFromStrawGasSteps_module.cc b/TrackerMC/src/StrawDigisFromStrawGasSteps_module.cc index 78c9f85276..5d9990be11 100644 --- a/TrackerMC/src/StrawDigisFromStrawGasSteps_module.cc +++ b/TrackerMC/src/StrawDigisFromStrawGasSteps_module.cc @@ -625,7 +625,7 @@ namespace mu2e { auto const& sgs = steps[isgs]; // lookup straw here, to avoid having to find the tracker for every step StrawId const & sid = sgs.strawId(); - if ( ((!_usestatus) || (!trackerStatus->noSignal(sid))) && sgs.ionizingEdep() > _minstepE){ + if ( ((!_usestatus) || (!trackerStatus->noSignal(sid,event.event()))) && sgs.ionizingEdep() > _minstepE){ Straw const& straw = _tracker->getStraw(sid); auto sgsptr = SGSPtr(sgsch,isgs); // create a clust from this step, and add it to the clust map diff --git a/TrkHitReco/inc/StrawHitRecoUtils.hh b/TrkHitReco/inc/StrawHitRecoUtils.hh index ea47dc6f16..05673744e0 100644 --- a/TrkHitReco/inc/StrawHitRecoUtils.hh +++ b/TrkHitReco/inc/StrawHitRecoUtils.hh @@ -29,7 +29,7 @@ namespace mu2e { void flagCrossTalk(std::unique_ptr const& shCol, std::unique_ptr const& chCol) const; - bool createComboHit(EventWindowMarker const& ewm, size_t isd, std::unique_ptr const& chCol, + bool createComboHit(uint32_t event, EventWindowMarker const& ewm, size_t isd, std::unique_ptr const& chCol, std::unique_ptr const& shCol, const CaloClusterCollection *caloClusters, double pbtOffset, diff --git a/TrkHitReco/src/StrawHitRecoUtils.cc b/TrkHitReco/src/StrawHitRecoUtils.cc index 1661c968fd..6c166a2f9e 100644 --- a/TrkHitReco/src/StrawHitRecoUtils.cc +++ b/TrkHitReco/src/StrawHitRecoUtils.cc @@ -77,7 +77,7 @@ namespace mu2e { return (peak-pedestal); } - bool StrawHitRecoUtils::createComboHit(EventWindowMarker const& ewm, size_t isd, std::unique_ptr const& chCol, + bool StrawHitRecoUtils::createComboHit(uint32_t event, EventWindowMarker const& ewm, size_t isd, std::unique_ptr const& chCol, std::unique_ptr const& shCol, const CaloClusterCollection* caloClusters, double pbtOffset, StrawId const& sid, TrkTypes::TDCValues const& tdc, TrkTypes::TOTValues const& tot, @@ -93,7 +93,7 @@ namespace mu2e { // flag digis that shouldn't be here or we don't want; true for both On and OffSpill StrawHitFlag flag; - if (trackerStatus.noSignal(sid) || trackerStatus.suppress(sid)) { + if (trackerStatus.noSignal(sid,event) || trackerStatus.suppress(sid)) { if(_filter) return false; else diff --git a/TrkHitReco/src/StrawHitReco_module.cc b/TrkHitReco/src/StrawHitReco_module.cc index 1071e86aa4..998579d6cc 100644 --- a/TrkHitReco/src/StrawHitReco_module.cc +++ b/TrkHitReco/src/StrawHitReco_module.cc @@ -210,7 +210,7 @@ namespace mu2e { pmp = _shrUtils.peakMinusPedWF(adcwf,srep,maxiter); if(_diagLevel > 0)_maxiter->Fill( std::distance(adcwf.begin(),maxiter)); } - _shrUtils.createComboHit(ewm, isd, chCol, shCol, caloClusters, pbtOffset, + _shrUtils.createComboHit(event.event(), ewm, isd, chCol, shCol, caloClusters, pbtOffset, digi.strawId(), digi.TDC(), digi.TOT(), pmp, trackerStatus, srep, tt); //flag straw and electronic cross-talk