From 6b08a6092943b402ed364b727d3483fe58b0cc1d Mon Sep 17 00:00:00 2001 From: WingYeung Ma Date: Thu, 22 Oct 2026 20:08:53 -0700 Subject: [PATCH 1/6] FIX: FITS loader numStripHit truncation and reinitialization --- include/MModuleLoaderMeasurementsFITS.h | 2 +- src/MModuleLoaderMeasurementsFITS.cxx | 30 ++++++++++++++++++++++--- 2 files changed, 28 insertions(+), 4 deletions(-) diff --git a/include/MModuleLoaderMeasurementsFITS.h b/include/MModuleLoaderMeasurementsFITS.h index 22e3b963..00556ca6 100644 --- a/include/MModuleLoaderMeasurementsFITS.h +++ b/include/MModuleLoaderMeasurementsFITS.h @@ -115,7 +115,7 @@ class MModuleLoaderMeasurementsFITS : public MModuleLoaderMeasurements std::vector m_BatchTIME; std::vector m_BatchEVENTID; std::vector m_BatchEVENTTYPE; - std::vector m_BatchNUMSTRIPHIT; + std::vector m_BatchNUMSTRIPHIT; //! Batch data storage for variable-length array columns std::vector> m_BatchHITTYPE; diff --git a/src/MModuleLoaderMeasurementsFITS.cxx b/src/MModuleLoaderMeasurementsFITS.cxx index 284c9fc7..f023b941 100644 --- a/src/MModuleLoaderMeasurementsFITS.cxx +++ b/src/MModuleLoaderMeasurementsFITS.cxx @@ -97,8 +97,32 @@ bool MModuleLoaderMeasurementsFITS::Initialize() { // Initialize the module - // Clean: + // Reset file and batch state so a second Initialize() will start fresh m_FileType = "Unknown"; + if (m_FITSFile != nullptr) { + delete m_FITSFile; + m_FITSFile = nullptr; + } + m_PrimaryHDU = nullptr; + m_ComptonTable = nullptr; + m_CurrentRow = 1; + m_TotalRows = 0; + m_BatchStartRow = 1; + m_CurrentEventInBatch = 0; + m_BatchEventCount = 0; + m_NEventsInFile = 0; + m_NGoodEventsInFile = 0; + m_BatchTIME.clear(); + m_BatchEVENTID.clear(); + m_BatchEVENTTYPE.clear(); + m_BatchNUMSTRIPHIT.clear(); + m_BatchHITTYPE.clear(); + m_BatchDETID.clear(); + m_BatchSTRIPID.clear(); + m_BatchSIDEID.clear(); + m_BatchFASTTIME.clear(); + m_BatchPHA.clear(); + m_BatchTAC.clear(); if (MFile::Exists(m_FileName) == false) { if (g_Verbosity >= c_Error) cout<SetID(static_cast(m_BatchEVENTID[idx])); Event->SetTimeRTS(eventTime); // Mission time in seconds since Jan 1, 2025 // Loop through strip hits and create MStripHit objects - for (uint8_t hitIdx = 0; hitIdx < numStripHit; ++hitIdx) { + for (uint16_t hitIdx = 0; hitIdx < numStripHit; ++hitIdx) { // Extract hit data from arrays uint8_t typeHit = m_BatchHITTYPE[idx][hitIdx]; int detID = m_BatchDETID[idx][hitIdx]; From 84ebdfe590c797ef8087e4bfdabaf87ea79b9d25 Mon Sep 17 00:00:00 2001 From: WingYeung Ma Date: Thu, 29 Oct 2026 12:40:33 -0700 Subject: [PATCH 2/6] FIX: FITS saver veto encoding, L2 hit limits --- src/MModuleSaverMeasurementsFITS.cxx | 56 ++++++++++++++++++++++++---- 1 file changed, 49 insertions(+), 7 deletions(-) diff --git a/src/MModuleSaverMeasurementsFITS.cxx b/src/MModuleSaverMeasurementsFITS.cxx index 38b3d78e..27f896c6 100644 --- a/src/MModuleSaverMeasurementsFITS.cxx +++ b/src/MModuleSaverMeasurementsFITS.cxx @@ -137,6 +137,39 @@ bool MModuleSaverMeasurementsFITS::Initialize() return MModule::Initialize(); } + // check if m_FITSFile is pointing to a FITS object, if yes, finalized the previous file + if (m_FITSFile != nullptr) Finalize(); + + // reset the states + m_PrimaryHDU = nullptr; + m_ScienceTable = nullptr; + m_TotalEventsWritten = 0; + m_TotalEventsSkipped = 0; + m_BatchStartRow = 1; + m_BatchEventCount = 0; + m_FirstEventTime_RTS = 0.0; + m_LastEventTime_RTS = 0.0; + m_HasEvents = false; + m_BatchTIME.clear(); + m_BatchEVENTID.clear(); + m_BatchEVENTTYPE.clear(); + m_BatchEVENTCLASS.clear(); + m_BatchNUMHIT.clear(); + m_BatchVETO.clear(); + m_BatchQUALITY_FLAG.clear(); + m_BatchSTATTEST.clear(); + m_BatchSEQHIT.clear(); + m_BatchRECOILDIR.clear(); + m_BatchRECOILDIR_ERR.clear(); + m_BatchX.clear(); + m_BatchY.clear(); + m_BatchZ.clear(); + m_BatchX_ERR.clear(); + m_BatchY_ERR.clear(); + m_BatchZ_ERR.clear(); + m_BatchENERGY.clear(); + m_BatchENERGY_ERR.clear(); + // Create the FITS file if (CreateFITSFile(m_FileName) == false) { if (g_Verbosity >= c_Error) cout<= c_Info) cout<pHDU(); @@ -322,8 +357,11 @@ bool MModuleSaverMeasurementsFITS::AnalyzeEvent(MReadOutAssembly* Event) return ok; } - // L2 mode: skip bad events (screening) - if (m_OutputDataLevel == 2 && Event->IsBad()) { + unsigned int numHits = Event->GetNHits(); + const unsigned int L2_HIT_LEN = 10; + + // L2 mode: skip bad events and events that have more than 10 HITS + if (m_OutputDataLevel == 2 && (Event->IsBad() || numHits > L2_HIT_LEN)) { m_TotalEventsSkipped++; Event->SetAnalysisProgress(MAssembly::c_EventSaver); return true; @@ -339,7 +377,6 @@ bool MModuleSaverMeasurementsFITS::AnalyzeEvent(MReadOutAssembly* Event) } else { time = Event->GetTimeRTS().GetAsDouble(); } - unsigned int numHits = Event->GetNHits(); // loop through all event, and record the start and end time for TSTART/TSTOP if (!m_HasEvents) { @@ -359,11 +396,16 @@ bool MModuleSaverMeasurementsFITS::AnalyzeEvent(MReadOutAssembly* Event) uint8_t eventClass = 5; // 5 = unknown uint32_t eventID = (uint32_t)Event->GetID(); - uint8_t veto = Event->IsVeto() ? 1 : 0; + // TODO: Determine how to distinguish between hard and soft ACS vetoes. + uint8_t veto = 0; + if (Event->GetShieldVeto() == true) { + veto = 1; + } else if (Event->GetGuardRingVeto() == true) { + veto = 3; + } std::string quality_flag; // L2: fixed-length 10 hit arrays, zero-padded - const unsigned int L2_HIT_LEN = 10; bool isL2 = (m_OutputDataLevel == 2); unsigned int arrayLen = isL2 ? L2_HIT_LEN : numHits; From 6bcd780e519f349f14a9ce88166e561d102efe12 Mon Sep 17 00:00:00 2001 From: WingYeung Ma Date: Thu, 29 Oct 2026 13:27:04 -0700 Subject: [PATCH 3/6] CHG: remove ExpectedToFail --- unittests/UTNModuleLoaderMeasurementsFITS.cxx | 4 ++-- unittests/UTNModuleSaverMeasurementsFITS.cxx | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/unittests/UTNModuleLoaderMeasurementsFITS.cxx b/unittests/UTNModuleLoaderMeasurementsFITS.cxx index 6943019e..8f29922a 100644 --- a/unittests/UTNModuleLoaderMeasurementsFITS.cxx +++ b/unittests/UTNModuleLoaderMeasurementsFITS.cxx @@ -179,7 +179,7 @@ bool UTNModuleLoaderMeasurementsFITS::TestManyStripHits() Passed = EvaluateTrue("Initialize()", "300 strip hits", "Initialize succeeds", Init) && Passed; Passed = EvaluateTrue("AnalyzeEvent()", "event with 300 strip hits", "The event is read", Read1) && Passed; - Passed = ExpectedToFail(Evaluate("AnalyzeEvent()", "event with 300 strip hits", "All 300 strip hits are read", E1.GetNStripHits(), 300u)) && Passed; + Passed = Evaluate("AnalyzeEvent()", "event with 300 strip hits", "All 300 strip hits are read", E1.GetNStripHits(), 300u) && Passed; if (E1.GetNStripHits() == 300) { Passed = Evaluate("AnalyzeEvent()", "event with 300 strip hits, hit 300", "The last hit is in detector 4", E1.GetStripHit(299)->GetDetectorID(), 4u) && Passed; Passed = Evaluate("AnalyzeEvent()", "event with 300 strip hits, hit 300", "The last hit is on strip 43", E1.GetStripHit(299)->GetStripID(), 43u) && Passed; @@ -400,7 +400,7 @@ bool UTNModuleLoaderMeasurementsFITS::TestReinitialize() g_Verbosity = OldVerbosity; Passed = Evaluate("AnalyzeEvent()", "first pass", "Four events are read", Counts[0], 4u) && Passed; - Passed = ExpectedToFail(Evaluate("AnalyzeEvent()", "second pass after Finalize", "Four events are read again after re-initialization", Counts[1], 4u)) && Passed; + Passed = Evaluate("AnalyzeEvent()", "second pass after Finalize", "Four events are read again after re-initialization", Counts[1], 4u) && Passed; return Passed; } diff --git a/unittests/UTNModuleSaverMeasurementsFITS.cxx b/unittests/UTNModuleSaverMeasurementsFITS.cxx index 39cea071..bf88d6dd 100644 --- a/unittests/UTNModuleSaverMeasurementsFITS.cxx +++ b/unittests/UTNModuleSaverMeasurementsFITS.cxx @@ -538,7 +538,7 @@ bool UTNModuleSaverMeasurementsFITS::TestL1b() // VETO: 0 = none, 1 = hard ACD veto, 2 = soft ACD veto, 3 = guard ring veto Passed = Evaluate("AnalyzeEvent()", "L1b", "VETO has one element per event", ColumnShape(Veto), Scalar) && Passed; if (ColumnShape(Veto) == Scalar) { - Passed = ExpectedToFail(EvaluateNear("AnalyzeEvent()", "L1b event 1 with guard ring veto", "VETO is 3 for a guard ring veto", Veto[0][0], 3.0, 1e-12)) && Passed; + Passed = EvaluateNear("AnalyzeEvent()", "L1b event 1 with guard ring veto", "VETO is 3 for a guard ring veto", Veto[0][0], 3.0, 1e-12) && Passed; Passed = EvaluateNear("AnalyzeEvent()", "L1b event 2 without veto", "VETO is 0 without veto", Veto[1][0], 0.0, 1e-12) && Passed; Passed = EvaluateTrue("AnalyzeEvent()", "L1b event 3 with shield veto", "VETO is an ACD veto (1 or 2) for a shield veto", Veto[2][0] == 1.0 || Veto[2][0] == 2.0) && Passed; } @@ -617,7 +617,7 @@ bool UTNModuleSaverMeasurementsFITS::TestL2() } return true; }); - Passed = ExpectedToFail(EvaluateTrue("AnalyzeEvent()", "L2 event with 40 hits", "An event with more than 10 hits is handled without crashing and NUMHIT fits the 10-element arrays", NoCrash)) && Passed; + Passed = EvaluateTrue("AnalyzeEvent()", "L2 event with 40 hits", "An event with more than 10 hits is handled without crashing and NUMHIT fits the 10-element arrays", NoCrash) && Passed; return Passed; } @@ -684,13 +684,13 @@ bool UTNModuleSaverMeasurementsFITS::TestRewrite() Passed = EvaluateTrue("Initialize()", "first run", "Initialize succeeds", Init[0]) && Passed; Passed = EvaluateTrue("Initialize()", "second run, same file", "Initialize succeeds again", Init[1]) && Passed; - Passed = ExpectedToFail(Evaluate("Finalize()", "second run, same file", "The file contains only the one event of the second run", CountRows(FileName), 1L)) && Passed; + Passed = Evaluate("Finalize()", "second run, same file", "The file contains only the one event of the second run", CountRows(FileName), 1L) && Passed; vector> ID; Passed = EvaluateTrue("Finalize()", "second run, same file", "The EVENTID column can be read", ReadNumericColumn(FileName, "EVENTID", ID)) && Passed; unsigned int FirstRowLength = (ID.size() >= 1) ? (unsigned int) ID[0].size() : 0; Passed = Evaluate("Finalize()", "second run, same file", "The first EVENTID row has one element", FirstRowLength, 1u) && Passed; if (ID.size() >= 1 && ID[0].size() == 1) { - Passed = ExpectedToFail(EvaluateNear("Finalize()", "second run, same file", "The first row is the event of the second run", ID[0][0], 101.0, 1e-12)) && Passed; + Passed = EvaluateNear("Finalize()", "second run, same file", "The first row is the event of the second run", ID[0][0], 101.0, 1e-12) && Passed; } return Passed; From 3d01dc5298142f6923b361f40d4c28c7f85327eb Mon Sep 17 00:00:00 2001 From: WingYeung Ma Date: Thu, 29 Oct 2026 15:32:20 -0700 Subject: [PATCH 4/6] FIX: Fix L1a events - RTS time and overwrite files --- src/MFITSWriterL1a.cxx | 50 ++++++++++++++++++++++++++++++++-- unittests/UTNFITSWriterL1a.cxx | 8 +++--- 2 files changed, 51 insertions(+), 7 deletions(-) diff --git a/src/MFITSWriterL1a.cxx b/src/MFITSWriterL1a.cxx index 265d23d7..71c3a508 100644 --- a/src/MFITSWriterL1a.cxx +++ b/src/MFITSWriterL1a.cxx @@ -69,8 +69,7 @@ MFITSWriterL1a::MFITSWriterL1a() MFITSWriterL1a::~MFITSWriterL1a() { - delete m_FITSFile; - m_FITSFile = nullptr; + Close(); } @@ -80,8 +79,13 @@ MFITSWriterL1a::~MFITSWriterL1a() bool MFITSWriterL1a::Create(const MString& FileName) { // Create the FITS file with an empty primary HDU and the GED_L1A extension. + if (m_FITSFile != nullptr) Close(); + if (FileName == "") return false; + try { - m_FITSFile = new FITS(string(FileName), RWmode::Write); + string FitsFileName = string(FileName); + if (FitsFileName[0] != '!') FitsFileName.insert(0, "!"); + m_FITSFile = new FITS(FitsFileName, RWmode::Write); // Primary header (Table 6.2d primary) PHDU& primary = m_FITSFile->pHDU(); @@ -180,6 +184,9 @@ bool MFITSWriterL1a::Create(const MString& FileName) return true; } catch (const FitsException& e) { if (g_Verbosity >= c_Error) cout << "MFITSWriterL1a: Create error: " << e.message() << endl; + delete m_FITSFile; + m_FITSFile = nullptr; + m_Table = nullptr; return false; } } @@ -190,6 +197,19 @@ bool MFITSWriterL1a::Create(const MString& FileName) bool MFITSWriterL1a::Write(MReadOutAssembly* Event) { + if (m_FITSFile == nullptr || m_Table == nullptr || Event == nullptr) { + if (g_Verbosity >= c_Error) { + cout << "MFITSWriterL1a: Write error:" + << (m_FITSFile == nullptr ? " m_FITSFile is null." : "") + << (m_Table == nullptr ? " m_Table is null." : "") + << (Event == nullptr ? " Event is null." : "") << endl; + } + return false; + } + + if (Event->GetTimeRTS() == 0 && Event->GetTimeUTC() != 0) { + Event->SetTimeRTS(Event->ComputeRTSfromUTCTime(Event->GetTimeUTC())); + } double time = Event->GetTimeRTS().GetAsDouble(); if (!m_HasEvents) { @@ -245,6 +265,14 @@ bool MFITSWriterL1a::Write(MReadOutAssembly* Event) bool MFITSWriterL1a::FlushBatch() { + if (m_FITSFile == nullptr || m_Table == nullptr) { + if (g_Verbosity >= c_Error) { + cout << "MFITSWriterL1a: FlushBatch error:" + << (m_FITSFile == nullptr ? " m_FITSFile is null." : "") + << (m_Table == nullptr ? " m_Table is null." : "") << endl; + } + return false; + } if (m_BatchEventCount == 0) return true; try { long firstRow = m_BatchStartRow; @@ -332,6 +360,22 @@ void MFITSWriterL1a::Close() delete m_FITSFile; // CCfits flushes + closes on destruction m_FITSFile = nullptr; m_Table = nullptr; + m_BatchStartRow = 1; + m_BatchEventCount = 0; + m_HasEvents = false; + m_FirstEventTime_RTS = 0; + m_LastEventTime_RTS = 0; + m_BatchTIME.clear(); + m_BatchEVENTID.clear(); + m_BatchEVENTTYPE.clear(); + m_BatchNUMSTRIPHIT.clear(); + m_BatchHITTYPE.clear(); + m_BatchDETID.clear(); + m_BatchSTRIPID.clear(); + m_BatchSIDEID.clear(); + m_BatchFASTTIME.clear(); + m_BatchPHA.clear(); + m_BatchTAC.clear(); } diff --git a/unittests/UTNFITSWriterL1a.cxx b/unittests/UTNFITSWriterL1a.cxx index 94a129e7..aa3cd530 100644 --- a/unittests/UTNFITSWriterL1a.cxx +++ b/unittests/UTNFITSWriterL1a.cxx @@ -506,8 +506,8 @@ bool UTNFITSWriterL1a::TestUTCOnlyEvents() vector R = ReadWithLoader(FileName); if (R.size() == 1) { - Passed = ExpectedToFail(EvaluateTrue("Write()", "UTC time only", "The TIME column is not 0", R[0]->GetTimeRTS().GetAsDouble() != 0.0)) && Passed; - Passed = ExpectedToFail(EvaluateNear("Write()", "UTC time only", "The TIME column is the RTS computed from the UTC time", R[0]->GetTimeRTS().GetAsDouble(), Expected, 1e-6)) && Passed; + Passed = EvaluateTrue("Write()", "UTC time only", "The TIME column is not 0", R[0]->GetTimeRTS().GetAsDouble() != 0.0) && Passed; + Passed = EvaluateNear("Write()", "UTC time only", "The TIME column is the RTS computed from the UTC time", R[0]->GetTimeRTS().GetAsDouble(), Expected, 1e-6) && Passed; } else { Passed = Evaluate("Write()", "UTC time only", "One event can be read back", (unsigned int) R.size(), 1u) && Passed; } @@ -552,7 +552,7 @@ bool UTNFITSWriterL1a::TestOverwrite() Passed = EvaluateTrue("Create()", "existing file", "Creating over an existing file succeeds", Second) && Passed; Passed = Evaluate("Create()", "existing file", "There is exactly one extension", CountExtensions(FileName), 1L) && Passed; vector R = ReadWithLoader(FileName); - Passed = ExpectedToFail(Evaluate("Create()", "existing file", "Only the new event is read back", (unsigned int) R.size(), 1u)) && Passed; + Passed = Evaluate("Create()", "existing file", "Only the new event is read back", (unsigned int) R.size(), 1u) && Passed; if (R.size() >= 1) { Passed = Evaluate("Create()", "existing file", "The event read back is the new event 99", R[0]->GetID(), (unsigned long) 99) && Passed; } @@ -598,7 +598,7 @@ bool UTNFITSWriterL1a::TestErrors() X.Close(); return true; }); - Passed = ExpectedToFail(EvaluateTrue("Write()", "without Create()", "Writing and closing without a file does not crash", NoFile)) && Passed; + Passed = EvaluateTrue("Write()", "without Create()", "Writing and closing without a file does not crash", NoFile) && Passed; return Passed; } From 9212f27fb0581070b60ba19cd683740e4708d950 Mon Sep 17 00:00:00 2001 From: WingYeung Ma Date: Sat, 31 Oct 2026 13:18:57 -0700 Subject: [PATCH 5/6] FIX: Correct 69.184-second offset in FITS loader --- include/MFITSWriterL1a.h | 2 +- include/MModuleLoaderMeasurementsFITS.h | 3 +++ src/MFITSWriterL1a.cxx | 9 ++++++--- src/MModuleLoaderMeasurementsFITS.cxx | 22 +++++++++++++++++++++- 4 files changed, 31 insertions(+), 5 deletions(-) diff --git a/include/MFITSWriterL1a.h b/include/MFITSWriterL1a.h index 0b826d3c..b3d625fd 100644 --- a/include/MFITSWriterL1a.h +++ b/include/MFITSWriterL1a.h @@ -68,7 +68,7 @@ class MFITSWriterL1a bool m_HasEvents; - //! First / last event time seen, RTS (mission seconds since 2025-01-01) + //! First / last FITS time, elapsed seconds from 2025-01-01T00:00:00 UTC double m_FirstEventTime_RTS; double m_LastEventTime_RTS; diff --git a/include/MModuleLoaderMeasurementsFITS.h b/include/MModuleLoaderMeasurementsFITS.h index 00556ca6..8243798e 100644 --- a/include/MModuleLoaderMeasurementsFITS.h +++ b/include/MModuleLoaderMeasurementsFITS.h @@ -99,6 +99,9 @@ class MModuleLoaderMeasurementsFITS : public MModuleLoaderMeasurements //! Total number of rows in the FITS table long m_TotalRows; + //! Offset from the FITS reference epoch to the internal RTS epoch, in seconds + double m_TimeReferenceOffsetRTS = 0.0; + //! Batch size for reading FITS data const long m_BatchSize = 100; diff --git a/src/MFITSWriterL1a.cxx b/src/MFITSWriterL1a.cxx index 71c3a508..c62c1706 100644 --- a/src/MFITSWriterL1a.cxx +++ b/src/MFITSWriterL1a.cxx @@ -30,6 +30,7 @@ #include "MFITSWriterL1a.h" // Standard libs: +#include // MEGAlib libs: #include "MStripHit.h" @@ -211,7 +212,9 @@ bool MFITSWriterL1a::Write(MReadOutAssembly* Event) Event->SetTimeRTS(Event->ComputeRTSfromUTCTime(Event->GetTimeUTC())); } - double time = Event->GetTimeRTS().GetAsDouble(); + const MTime FITSEpochUTC(2025, 1, 1, 0, 0, 0, 0); + const MTime FITSEpochRTS = Event->ComputeRTSfromUTCTime(FITSEpochUTC); + double time = (Event->GetTimeRTS() - FITSEpochRTS).GetAsDouble(); if (!m_HasEvents) { m_FirstEventTime_RTS = time; m_LastEventTime_RTS = time; @@ -325,8 +328,8 @@ void MFITSWriterL1a::Close() m_Table->addKey("TSTOP", m_LastEventTime_RTS, "[s] Observation stop"); // "stopsince" is verbatim from Table 6.2d (doc typo) constexpr time_t MISSION_EPOCH_UNIX = 1735689600; // 2025-01-01T00:00:00 UTC - time_t startUnix = MISSION_EPOCH_UNIX + (time_t)m_FirstEventTime_RTS; - time_t stopUnix = MISSION_EPOCH_UNIX + (time_t)m_LastEventTime_RTS; + time_t startUnix = MISSION_EPOCH_UNIX + static_cast(std::floor(m_FirstEventTime_RTS)); + time_t stopUnix = MISSION_EPOCH_UNIX + static_cast(std::floor(m_LastEventTime_RTS)); char startBuf[32], stopBuf[32]; strftime(startBuf, sizeof(startBuf), "%Y-%m-%dT%H:%M:%S", gmtime(&startUnix)); strftime(stopBuf, sizeof(stopBuf), "%Y-%m-%dT%H:%M:%S", gmtime(&stopUnix)); diff --git a/src/MModuleLoaderMeasurementsFITS.cxx b/src/MModuleLoaderMeasurementsFITS.cxx index f023b941..9c548f3a 100644 --- a/src/MModuleLoaderMeasurementsFITS.cxx +++ b/src/MModuleLoaderMeasurementsFITS.cxx @@ -107,6 +107,7 @@ bool MModuleLoaderMeasurementsFITS::Initialize() m_ComptonTable = nullptr; m_CurrentRow = 1; m_TotalRows = 0; + m_TimeReferenceOffsetRTS = 0.0; m_BatchStartRow = 1; m_CurrentEventInBatch = 0; m_BatchEventCount = 0; @@ -189,6 +190,25 @@ bool MModuleLoaderMeasurementsFITS::OpenFITSFile(MString FileName) return false; } + double ReferenceDay = 0.0; + double ReferenceFraction = 0.0; + string TimeSystem; + + m_ComptonTable->readKey("MJDREFI", ReferenceDay); + m_ComptonTable->readKey("MJDREFF", ReferenceFraction); + m_ComptonTable->readKey("TIMESYS", TimeSystem); + if (TimeSystem != "TT") { + if (g_Verbosity >= c_Error) cout << m_XmlTag << ": Unsupported FITS time system: " << TimeSystem << endl; + return false; + } + + constexpr double MissionReferenceMJD = 60676.0; + constexpr double SecondsPerDay = 86400.0; + + // Difference between the FITS and internal reference epochs + const double ReferenceOffsetDays = (ReferenceDay - MissionReferenceMJD) + ReferenceFraction; + m_TimeReferenceOffsetRTS = ReferenceOffsetDays * SecondsPerDay; + // Validate required columns exist const vector requiredColumns = { "TIME", "EVENTID", "EVENTTYPE", "NUMSTRIPHIT", "HITTYPE", "DETID", @@ -354,7 +374,7 @@ bool MModuleLoaderMeasurementsFITS::AnalyzeEvent(MReadOutAssembly* Event) // Set event-level properties Event->SetID(static_cast(m_BatchEVENTID[idx])); - Event->SetTimeRTS(eventTime); // Mission time in seconds since Jan 1, 2025 + Event->SetTimeRTS(MTime(eventTime) + MTime(m_TimeReferenceOffsetRTS)); // Loop through strip hits and create MStripHit objects for (uint16_t hitIdx = 0; hitIdx < numStripHit; ++hitIdx) { From 41f0fca0d8b9392534b0a6a7fac8e01a38550b8d Mon Sep 17 00:00:00 2001 From: WingYeung Ma Date: Thu, 5 Nov 2026 19:54:03 -0800 Subject: [PATCH 6/6] FIX: Count FITS TIME from 2025-01-01 UTC in L1a, L1b and L2 (#257) --- include/MFITSWriterL1a.h | 4 +- include/MModuleSaverMeasurementsFITS.h | 8 ++-- src/MFITSWriterL1a.cxx | 36 ++++++++-------- src/MModuleLoaderMeasurementsFITS.cxx | 4 +- src/MModuleLoaderMeasurementsL0.cxx | 6 ++- src/MModuleSaverMeasurementsFITS.cxx | 44 ++++++++++---------- unittests/UTNFITSWriterL1a.cxx | 8 ++-- unittests/UTNModuleSaverMeasurementsFITS.cxx | 10 ++--- 8 files changed, 62 insertions(+), 58 deletions(-) diff --git a/include/MFITSWriterL1a.h b/include/MFITSWriterL1a.h index b3d625fd..5c7e940a 100644 --- a/include/MFITSWriterL1a.h +++ b/include/MFITSWriterL1a.h @@ -69,8 +69,8 @@ class MFITSWriterL1a bool m_HasEvents; //! First / last FITS time, elapsed seconds from 2025-01-01T00:00:00 UTC - double m_FirstEventTime_RTS; - double m_LastEventTime_RTS; + double m_FirstEventTime; + double m_LastEventTime; std::vector m_BatchTIME; std::vector m_BatchEVENTID; diff --git a/include/MModuleSaverMeasurementsFITS.h b/include/MModuleSaverMeasurementsFITS.h index 16247ae3..37fc1d24 100644 --- a/include/MModuleSaverMeasurementsFITS.h +++ b/include/MModuleSaverMeasurementsFITS.h @@ -121,11 +121,11 @@ class MModuleSaverMeasurementsFITS : public MModule //! Total number of events skipped (L2 screening) long m_TotalEventsSkipped; - //! First event time seen, RTS (mission seconds since 2025-01-01) - double m_FirstEventTime_RTS; + //! First event time seen, FITS TIME (elapsed seconds from 2025-01-01T00:00:00 UTC) + double m_FirstEventTime; - //! Last event time seen, RTS (mission seconds since 2025-01-01) - double m_LastEventTime_RTS; + //! Last event time seen, FITS TIME (elapsed seconds from 2025-01-01T00:00:00 UTC) + double m_LastEventTime; //! Whether any events have been processed yet bool m_HasEvents; diff --git a/src/MFITSWriterL1a.cxx b/src/MFITSWriterL1a.cxx index c62c1706..1fc15170 100644 --- a/src/MFITSWriterL1a.cxx +++ b/src/MFITSWriterL1a.cxx @@ -60,8 +60,8 @@ MFITSWriterL1a::MFITSWriterL1a() m_BatchStartRow = 1; m_BatchEventCount = 0; m_HasEvents = false; - m_FirstEventTime_RTS = 0; - m_LastEventTime_RTS = 0; + m_FirstEventTime = 0; + m_LastEventTime = 0; } @@ -208,20 +208,20 @@ bool MFITSWriterL1a::Write(MReadOutAssembly* Event) return false; } - if (Event->GetTimeRTS() == 0 && Event->GetTimeUTC() != 0) { - Event->SetTimeRTS(Event->ComputeRTSfromUTCTime(Event->GetTimeUTC())); + // Set Time + MTime TimeUTC = Event->GetTimeUTC(); + if (TimeUTC == 0) { + TimeUTC = Event->ComputeUTCfromRTSTime(Event->GetTimeRTS()); } - const MTime FITSEpochUTC(2025, 1, 1, 0, 0, 0, 0); - const MTime FITSEpochRTS = Event->ComputeRTSfromUTCTime(FITSEpochUTC); - double time = (Event->GetTimeRTS() - FITSEpochRTS).GetAsDouble(); + double secSince2025UTC = (TimeUTC - FITSEpochUTC).GetAsDouble(); if (!m_HasEvents) { - m_FirstEventTime_RTS = time; - m_LastEventTime_RTS = time; + m_FirstEventTime = secSince2025UTC; + m_LastEventTime = secSince2025UTC; m_HasEvents = true; } else { - if (time < m_FirstEventTime_RTS) m_FirstEventTime_RTS = time; - if (time > m_LastEventTime_RTS) m_LastEventTime_RTS = time; + if (secSince2025UTC < m_FirstEventTime) m_FirstEventTime = secSince2025UTC; + if (secSince2025UTC > m_LastEventTime) m_LastEventTime = secSince2025UTC; } unsigned int nStripHits = Event->GetNStripHits(); @@ -243,7 +243,7 @@ bool MFITSWriterL1a::Write(MReadOutAssembly* Event) tac[i] = hit->GetTAC(); } - m_BatchTIME.push_back(time); + m_BatchTIME.push_back(secSince2025UTC); m_BatchEVENTID.push_back((uint32_t)Event->GetID()); m_BatchEVENTTYPE.push_back(0); // TODO m_BatchNUMSTRIPHIT.push_back(nStripHits); @@ -324,12 +324,12 @@ void MFITSWriterL1a::Close() if (m_HasEvents && m_Table != nullptr) { try { - m_Table->addKey("TSTART", m_FirstEventTime_RTS, "[s] Observation start"); - m_Table->addKey("TSTOP", m_LastEventTime_RTS, "[s] Observation stop"); // "stopsince" is verbatim from Table 6.2d (doc typo) + m_Table->addKey("TSTART", m_FirstEventTime, "[s] Observation start"); + m_Table->addKey("TSTOP", m_LastEventTime, "[s] Observation stop"); // "stopsince" is verbatim from Table 6.2d (doc typo) constexpr time_t MISSION_EPOCH_UNIX = 1735689600; // 2025-01-01T00:00:00 UTC - time_t startUnix = MISSION_EPOCH_UNIX + static_cast(std::floor(m_FirstEventTime_RTS)); - time_t stopUnix = MISSION_EPOCH_UNIX + static_cast(std::floor(m_LastEventTime_RTS)); + time_t startUnix = MISSION_EPOCH_UNIX + static_cast(std::floor(m_FirstEventTime)); + time_t stopUnix = MISSION_EPOCH_UNIX + static_cast(std::floor(m_LastEventTime)); char startBuf[32], stopBuf[32]; strftime(startBuf, sizeof(startBuf), "%Y-%m-%dT%H:%M:%S", gmtime(&startUnix)); strftime(stopBuf, sizeof(stopBuf), "%Y-%m-%dT%H:%M:%S", gmtime(&stopUnix)); @@ -366,8 +366,8 @@ void MFITSWriterL1a::Close() m_BatchStartRow = 1; m_BatchEventCount = 0; m_HasEvents = false; - m_FirstEventTime_RTS = 0; - m_LastEventTime_RTS = 0; + m_FirstEventTime = 0; + m_LastEventTime = 0; m_BatchTIME.clear(); m_BatchEVENTID.clear(); m_BatchEVENTTYPE.clear(); diff --git a/src/MModuleLoaderMeasurementsFITS.cxx b/src/MModuleLoaderMeasurementsFITS.cxx index 9c548f3a..402d5034 100644 --- a/src/MModuleLoaderMeasurementsFITS.cxx +++ b/src/MModuleLoaderMeasurementsFITS.cxx @@ -374,7 +374,9 @@ bool MModuleLoaderMeasurementsFITS::AnalyzeEvent(MReadOutAssembly* Event) // Set event-level properties Event->SetID(static_cast(m_BatchEVENTID[idx])); - Event->SetTimeRTS(MTime(eventTime) + MTime(m_TimeReferenceOffsetRTS)); + MTime TimeRTS = MTime(eventTime) + MTime(m_TimeReferenceOffsetRTS); + Event->SetTimeRTS(TimeRTS); + Event->SetTimeUTC(Event->ComputeUTCfromRTSTime(TimeRTS)); // Loop through strip hits and create MStripHit objects for (uint16_t hitIdx = 0; hitIdx < numStripHit; ++hitIdx) { diff --git a/src/MModuleLoaderMeasurementsL0.cxx b/src/MModuleLoaderMeasurementsL0.cxx index 2077146e..033559d4 100644 --- a/src/MModuleLoaderMeasurementsL0.cxx +++ b/src/MModuleLoaderMeasurementsL0.cxx @@ -313,11 +313,13 @@ bool MModuleLoaderMeasurementsL0::ReadNextPacket(MReadOutAssembly* Event) } std::vector hitData(rest.begin() + cursor, rest.begin() + cursor + hlen); - // Build GPS MTime from seconds and subseconds, then convert and set to RTS + // Build GPS MTime from seconds and subseconds, then convert and set to RTS and UTC // Subseconds are 40 MHz DCB ticks → ns = ticks * 25 long int pktNanoseconds = (long int)pktSubseconds * 25; MTime gpsTime((long int)pktSeconds, pktNanoseconds); - Event->SetTimeRTS(Event->ComputeRTSfromGPSTime(gpsTime)); + MTime TimeRTS = Event->ComputeRTSfromGPSTime(gpsTime); + Event->SetTimeRTS(TimeRTS); + Event->SetTimeUTC(Event->ComputeUTCfromRTSTime(TimeRTS)); // Decode the bit-packed HIT_DATA into individual MStripHit objects on the event if (DecodeHitData(hitData, hits, Event) == false) { diff --git a/src/MModuleSaverMeasurementsFITS.cxx b/src/MModuleSaverMeasurementsFITS.cxx index 27f896c6..02f3f92d 100644 --- a/src/MModuleSaverMeasurementsFITS.cxx +++ b/src/MModuleSaverMeasurementsFITS.cxx @@ -28,6 +28,7 @@ // Standard libs: #include +#include #include #include using namespace std; @@ -99,8 +100,8 @@ MModuleSaverMeasurementsFITS::MModuleSaverMeasurementsFITS(MString XmlTag, int O m_BatchStartRow = 1; m_BatchEventCount = 0; m_OutputDataLevel = OutputDataLevel; // 0 = L1a, 1 = L1b, 2 = L2 - m_FirstEventTime_RTS = 0.0; - m_LastEventTime_RTS = 0.0; + m_FirstEventTime = 0.0; + m_LastEventTime = 0.0; m_HasEvents = false; ConfigurePreceedingModules(); @@ -147,8 +148,8 @@ bool MModuleSaverMeasurementsFITS::Initialize() m_TotalEventsSkipped = 0; m_BatchStartRow = 1; m_BatchEventCount = 0; - m_FirstEventTime_RTS = 0.0; - m_LastEventTime_RTS = 0.0; + m_FirstEventTime = 0.0; + m_LastEventTime = 0.0; m_HasEvents = false; m_BatchTIME.clear(); m_BatchEVENTID.clear(); @@ -368,24 +369,21 @@ bool MModuleSaverMeasurementsFITS::AnalyzeEvent(MReadOutAssembly* Event) } // Extract event-level data - double time = 0; - if (Event->GetTimeRTS() == 0 && Event->GetTimeUTC() != 0) { - // If UTC time is defined, calculate RTS - MTime RTS = Event->ComputeRTSfromUTCTime(Event->GetTimeUTC()); - Event->SetTimeRTS(RTS); - time = RTS.GetAsDouble(); - } else { - time = Event->GetTimeRTS().GetAsDouble(); + MTime TimeUTC = Event->GetTimeUTC(); + if (TimeUTC == 0) { + TimeUTC = Event->ComputeUTCfromRTSTime(Event->GetTimeRTS()); } + const MTime FITSEpochUTC(2025, 1, 1, 0, 0, 0, 0); + double secSince2025UTC = (TimeUTC - FITSEpochUTC).GetAsDouble(); // loop through all event, and record the start and end time for TSTART/TSTOP if (!m_HasEvents) { - m_FirstEventTime_RTS = time; - m_LastEventTime_RTS = time; + m_FirstEventTime = secSince2025UTC; + m_LastEventTime = secSince2025UTC; m_HasEvents = true; } else { - if (time < m_FirstEventTime_RTS) m_FirstEventTime_RTS = time; - if (time > m_LastEventTime_RTS) m_LastEventTime_RTS = time; + if (secSince2025UTC < m_FirstEventTime) m_FirstEventTime = secSince2025UTC; + if (secSince2025UTC > m_LastEventTime) m_LastEventTime = secSince2025UTC; } // Event-level metadata defaults @@ -512,7 +510,7 @@ bool MModuleSaverMeasurementsFITS::AnalyzeEvent(MReadOutAssembly* Event) } // Add to batch - m_BatchTIME.push_back(time); + m_BatchTIME.push_back(secSince2025UTC); m_BatchEVENTID.push_back(eventID); m_BatchEVENTCLASS.push_back(eventClass); m_BatchNUMHIT.push_back((uint8_t)numHits); @@ -660,8 +658,8 @@ void MModuleSaverMeasurementsFITS::Finalize() // Mission epoch is 2025-01-01 00:00:00 UTC const time_t MISSION_EPOCH_UNIX = 1735689600; - time_t startUnix = MISSION_EPOCH_UNIX + (time_t)m_FirstEventTime_RTS; - time_t stopUnix = MISSION_EPOCH_UNIX + (time_t)m_LastEventTime_RTS; + time_t startUnix = MISSION_EPOCH_UNIX + static_cast(std::floor(m_FirstEventTime)); + time_t stopUnix = MISSION_EPOCH_UNIX + static_cast(std::floor(m_LastEventTime)); //convert to ISO string char startBuf[32], stopBuf[32]; @@ -675,8 +673,8 @@ void MModuleSaverMeasurementsFITS::Finalize() // Update science table HDU m_ScienceTable->addKey("DATE-OBS", string(startBuf), "Start Date"); m_ScienceTable->addKey("DATE-END", string(stopBuf), "Stop Date"); - m_ScienceTable->addKey("TSTART", m_FirstEventTime_RTS, "[s] Observation start"); - m_ScienceTable->addKey("TSTOP", m_LastEventTime_RTS, "[s] Observation stop"); + m_ScienceTable->addKey("TSTART", m_FirstEventTime, "[s] Observation start"); + m_ScienceTable->addKey("TSTOP", m_LastEventTime, "[s] Observation stop"); // Also update OBS_ID to match the start date (YYYYMMDD format) char obsIdBuf[16]; @@ -686,8 +684,8 @@ void MModuleSaverMeasurementsFITS::Finalize() if (g_Verbosity >= c_Info) { cout<SetTimeRTS(MTime(0)); E4->SetTimeUTC(MTime(1735689600 + 86430)); - double E4Expected = E4->ComputeRTSfromUTCTime(E4->GetTimeUTC()).GetAsDouble(); + double E4Expected = 86430.0; vector Events = { E1, E2, E3, E4 }; MString File = WriteEvents("l1b.fits", 1, Events); for (MReadOutAssembly* E : Events) delete E; @@ -499,7 +499,7 @@ bool UTNModuleSaverMeasurementsFITS::TestL1b() Passed = Evaluate("Finalize()", "L1b", "Four rows are written", CountRows(File), 4L) && Passed; Passed = EvaluateTrue("Finalize()", "L1b", "The L1b-only column VETO exists", HasColumn(File, "VETO")) && Passed; Passed = EvaluateTrue("Finalize()", "L1b", "The L1b-only column QUALITY_FLAG exists", HasColumn(File, "QUALITY_FLAG")) && Passed; - Passed = EvaluateNear("Finalize()", "L1b", "TSTART is the first event time", ReadDoubleKey(File, "TSTART"), 86400.0, 1e-3) && Passed; + Passed = EvaluateNear("Finalize()", "L1b", "TSTART is the first event time, counted from 2025-01-01 UTC ", ReadDoubleKey(File, "TSTART"), 86400.0 - 69.184, 1e-3) && Passed; vector> Time, NumHit, Energy, EnergyErr, X, Veto, Class, SeqHit; Passed = EvaluateTrue("AnalyzeEvent()", "L1b", "The TIME column can be read", ReadNumericColumn(File, "TIME", Time)) && Passed; @@ -516,8 +516,8 @@ bool UTNModuleSaverMeasurementsFITS::TestL1b() const MString PerHit = "2 1 3 1"; Passed = Evaluate("AnalyzeEvent()", "L1b", "TIME has one element per event", ColumnShape(Time), Scalar) && Passed; if (ColumnShape(Time) == Scalar) { - Passed = EvaluateNear("AnalyzeEvent()", "L1b event 1", "TIME is the RTS time", Time[0][0], 86400.0, 1e-6) && Passed; - Passed = EvaluateNear("AnalyzeEvent()", "L1b event 4", "TIME is computed from the UTC time if there is no RTS time", Time[3][0], E4Expected, 1e-6) && Passed; + Passed = EvaluateNear("AnalyzeEvent()", "L1b event 1", "TIME is the RTS time counted from 2025-01-01 UTC", Time[0][0], 86400.0 - 69.184, 1e-6) && Passed; + Passed = EvaluateNear("AnalyzeEvent()", "L1b event 4", "TIME is the UTC time counted from 2025-01-01 UTC", Time[3][0], E4Expected, 1e-6) && Passed; } Passed = Evaluate("AnalyzeEvent()", "L1b", "NUMHIT has one element per event", ColumnShape(NumHit), Scalar) && Passed; if (ColumnShape(NumHit) == Scalar) { @@ -649,7 +649,7 @@ bool UTNModuleSaverMeasurementsFITS::TestBatches() } Passed = EvaluateTrue("AnalyzeEvent()", "230 events", "The event IDs are in order across batches", InOrder) && Passed; } - Passed = EvaluateNear("Finalize()", "230 events", "TSTOP is the last event time", ReadDoubleKey(File, "TSTOP"), 240.0, 1e-6) && Passed; + Passed = EvaluateNear("Finalize()", "230 events", "TSTOP is the last event time", ReadDoubleKey(File, "TSTOP"), 240.0 - 69.184, 1e-6) && Passed; return Passed; }