From 243dec32582ff41ac0ad1b112f4ca3bc7e5057c2 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Thu, 21 May 2026 16:46:40 -0400 Subject: [PATCH 01/12] add unix time to postproc --- .../jlab/analysis/postprocess/Processor.java | 183 ++++++++++++------ 1 file changed, 128 insertions(+), 55 deletions(-) diff --git a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java index f5f4ca1cee..dc68f75997 100644 --- a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java +++ b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java @@ -8,6 +8,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.TreeMap; import org.jlab.jnp.hipo4.data.Bank; import org.jlab.jnp.hipo4.data.Event; @@ -35,10 +36,13 @@ public class Processor { private final String outputPrefix = "tmp_"; + private Bank runConfig = null; + private Bank recEvent = null; private ConstantsManager conman = null; private SchemaFactory schemaFactory = null; private DaqScalersSequence chargeSequence = null; private HelicitySequenceDelayed helicitySequence = null; + private TreeMap eventUnix = null; public Processor(File file, boolean restream, boolean rebuild) { configure(Arrays.asList(file.getAbsolutePath()), restream, rebuild); @@ -58,19 +62,24 @@ public Processor(SchemaFactory schema, HelicitySequenceDelayed h, DaqScalersSequ schemaFactory = schema; helicitySequence = h; chargeSequence = s; + runConfig = new Bank(schemaFactory.getSchema("RUN::config")); + recEvent = new Bank(schemaFactory.getSchema("REC::Event")); } private void configure(List preloadFiles, boolean restream, boolean rebuild) { if (!preloadFiles.isEmpty()) { HipoReader r = new HipoReader(); r.open(preloadFiles.get(0)); + schemaFactory = r.getSchemaFactory(); + r.close(); + runConfig = new Bank(schemaFactory.getSchema("RUN::config")); + recEvent = new Bank(schemaFactory.getSchema("REC::Event")); conman = new ConstantsManager(); conman.init(CCDB_TABLES); - schemaFactory = r.getSchemaFactory(); helicitySequence = Util.getHelicity(preloadFiles, schemaFactory, restream, conman); if (rebuild) chargeSequence = DaqScalersSequence.rebuildSequence(1, conman, preloadFiles); else chargeSequence = DaqScalersSequence.readSequence(preloadFiles); - r.close(); + eventUnix = getEventUnixMap(preloadFiles); } } @@ -92,21 +101,47 @@ private static List findPreloadFiles(String dir, String glob) { return ret; } + /** + * Load the mapping from event number to unix time + * @param files + * @return map + */ + private TreeMap getEventUnixMap(List files) { + Bank unix = new Bank(schemaFactory.getSchema("RUN::unix")); + TreeMap m = new TreeMap<>(); + Event e = new Event(); + for (String f : files) { + HipoReader r = new HipoReader(); + r.setTags(1); + r.open(f); + while (r.hasNext()) { + r.nextEvent(e); + e.read(unix); + int size = unix.getRows(); + for (int i=0; i0) { event.removeBank("HEL::scaler"); - Util.assignScalerHelicity(runConfig.getLong("timestamp",0), ((HipoDataBank)helScaler).getBank(), helicitySequence); + Util.assignScalerHelicity(runcfg.getLong("timestamp",0), ((HipoDataBank)helScaler).getBank(), helicitySequence); event.appendBank(helScaler); } } @@ -114,95 +149,133 @@ private void processEventHelicity(DataEvent event, DataBank runConfig, DataBank /** * Modify REC::Event/HEL::scaler with the delay-corrected helicity * @param event - * @param runConfig - * @param recEvent + * @param runcfg + * @param recevt */ - private void processEventHelicity(Event event, Bank runConfig, Bank recEvent) { - HelicityBit hb = helicitySequence.search(runConfig.getLong("timestamp", 0)); + private void processEventHelicity(Event event, Bank runcfg, Bank recevt) { + HelicityBit hb = helicitySequence.search(runcfg.getLong("timestamp", 0)); HelicityBit hbraw = helicitySequence.getHalfWavePlate() ? HelicityBit.getFlipped(hb) : hb; - recEvent.setByte("helicity",0,hb.value()); - recEvent.setByte("helicityRaw",0,hbraw.value()); + recevt.setByte("helicity",0,hb.value()); + recevt.setByte("helicityRaw",0,hbraw.value()); Bank helScaler = new Bank(schemaFactory.getSchema("HEL::scaler")); event.read(helScaler); if (helScaler.getRows()>0) { event.remove(schemaFactory.getSchema("HEL::scaler")); - Util.assignScalerHelicity(runConfig.getLong("timestamp",0), helScaler, helicitySequence); + Util.assignScalerHelicity(runcfg.getLong("timestamp",0), helScaler, helicitySequence); event.write(helScaler); } } /** * Modify REC::Event for beam charge and livetime - * @param runConfig - * @param recEvent + * @param runcfg + * @param recevt */ - private void processEventScalers(DataBank runConfig, DataBank recEvent) { - DaqScalers ds = chargeSequence.get(runConfig.getLong("timestamp", 0)); + private void processEventScalers(DataBank runcfg, DataBank recevt) { + DaqScalers ds = chargeSequence.get(runcfg.getLong("timestamp", 0)); if (ds != null) { - recEvent.setFloat("beamCharge",0, (float) ds.dsc2.getBeamChargeGated()); - recEvent.setDouble("liveTime",0,ds.dsc2.getLivetime()); + recevt.setFloat("beamCharge",0, (float) ds.dsc2.getBeamChargeGated()); + recevt.setDouble("liveTime",0,ds.dsc2.getLivetime()); } } /** * Modify REC::Event for beam charge and livetime - * @param runConfig - * @param recEvent + * @param runcfg + * @param recevt */ - private void processEventScalers(Bank runConfig, Bank recEvent) { - DaqScalers ds = chargeSequence.get(runConfig.getLong("timestamp", 0)); + private void processEventScalers(Bank runcfg, Bank recevt) { + DaqScalers ds = chargeSequence.get(runcfg.getLong("timestamp", 0)); if (ds != null) { - recEvent.putFloat("beamCharge",0, (float) ds.dsc2.getBeamChargeGated()); - recEvent.putDouble("liveTime",0,ds.dsc2.getLivetime()); + recevt.putFloat("beamCharge",0, (float) ds.dsc2.getBeamChargeGated()); + recevt.putDouble("liveTime",0,ds.dsc2.getLivetime()); + } + } + + /** + * Modify REC::Event for beam charge and livetime + * @param runcfg + * @param runcfg + */ + private void processEventUnix(Event event, Bank runcfg) { + if (runcfg.getRows() > 0) { + Integer unix = eventUnix.get(eventUnix.floorKey(runcfg.getInt("event",0))); + if (unix != null) { + event.remove(runcfg.getSchema()); + runcfg.putInt("unixtime", 0, unix); + event.write(runcfg); + } + } + } + + /** + * Modify REC::Event for beam charge and livetime + * @param runcfg + * @param runcfg + */ + private void processEventUnix(DataEvent event, DataBank runcfg) { + if (runcfg.rows() > 0) { + Integer unix = eventUnix.get(eventUnix.floorKey(runcfg.getInt("event",0))); + if (unix != null) { + event.removeBank(runcfg.getDescriptor().getName()); + runcfg.setInt("unixtime", 0, unix); + event.appendBank(runcfg); + } } } /** * Postprocess one event - * @param e + * @param event */ - public void processEvent(DataEvent e) { - if (!e.hasBank("RUN::config")) return; - if (!e.hasBank("REC::Event")) return; - DataBank runConfig = e.getBank("RUN::config"); - DataBank recEvent = e.getBank("REC::Event"); - if (runConfig.rows()<1 || recEvent.rows()<1) return; - e.removeBank("REC::Event"); - if (helicitySequence != null) processEventHelicity(e, runConfig, recEvent); - if (chargeSequence != null) processEventScalers(runConfig, recEvent); - e.appendBank(recEvent); + public void processEvent(DataEvent event) { + if (event.hasBank("RUN::config")) { + DataBank runcfg = event.getBank("RUN::config"); + if (runcfg.rows() > 0) { + processEventUnix(event, runcfg); + if (event.hasBank("REC::Event")) { + DataBank recevt = event.getBank("REC::Event"); + if (recevt.rows() > 0) { + event.removeBank("REC::Event"); + if (helicitySequence != null) processEventHelicity(event, runcfg, recevt); + if (chargeSequence != null) processEventScalers(runcfg, recevt); + event.appendBank(recevt); + } + } + } + } } /** * Postprocess one event - * @param e + * @param event */ - public void processEvent(Event e) { - if (!e.hasBank(schemaFactory.getSchema("RUN::config"))) return; - if (!e.hasBank(schemaFactory.getSchema("REC::Event"))) return; - Bank runConfig = new Bank(schemaFactory.getSchema("RUN::config")); - Bank recEvent = new Bank(schemaFactory.getSchema("REC::Event")); - e.read(runConfig); - e.read(recEvent); - if (runConfig.getRows()<1 || recEvent.getRows()<1) return; - e.remove(schemaFactory.getSchema("REC::Event")); - if (helicitySequence != null) processEventHelicity(e, runConfig, recEvent); - if (chargeSequence != null) processEventScalers(runConfig, recEvent); - e.write(recEvent); + public void processEvent(Event event) { + event.read(runConfig); + event.read(recEvent); + if (runConfig.getRows() > 0) { + processEventUnix(event, runConfig); + if (recEvent.getRows() > 0) { + event.remove(recEvent.getSchema()); + if (helicitySequence != null) processEventHelicity(event, runConfig, recEvent); + if (chargeSequence != null) processEventScalers(runConfig, recEvent); + event.write(recEvent); + } + } } /** * Create rebuilt files from preload files. - * @param preloadFiles + * @param files * @return map of rebuilt:preload files */ - private Map rebuild(String dir, List preloadFiles) { + private Map rebuild(String dir, List files) { File d = new File(dir); if (!d.canWrite()) { throw new RuntimeException("No write permissions on "+dir); } Map rebuiltFiles = new HashMap<>(); - for (String preloadFile : preloadFiles) { + for (String preloadFile : files) { String rebuiltFile = dir+"/"+outputPrefix+preloadFile.replace(dir+"/",""); Util.rebuildScalers(conman, preloadFile, rebuiltFile); rebuiltFiles.put(rebuiltFile,preloadFile); From 3c3dbff58318c7632566b7953778c73b8df66587 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Thu, 21 May 2026 16:53:00 -0400 Subject: [PATCH 02/12] make it static --- .../main/java/org/jlab/analysis/postprocess/Processor.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java index dc68f75997..25070f93e6 100644 --- a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java +++ b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java @@ -79,7 +79,7 @@ private void configure(List preloadFiles, boolean restream, boolean rebu helicitySequence = Util.getHelicity(preloadFiles, schemaFactory, restream, conman); if (rebuild) chargeSequence = DaqScalersSequence.rebuildSequence(1, conman, preloadFiles); else chargeSequence = DaqScalersSequence.readSequence(preloadFiles); - eventUnix = getEventUnixMap(preloadFiles); + eventUnix = getEventUnixMap(schemaFactory, preloadFiles); } } @@ -103,11 +103,12 @@ private static List findPreloadFiles(String dir, String glob) { /** * Load the mapping from event number to unix time + * @param schema * @param files * @return map */ - private TreeMap getEventUnixMap(List files) { - Bank unix = new Bank(schemaFactory.getSchema("RUN::unix")); + public static TreeMap getEventUnixMap(SchemaFactory schema, List files) { + Bank unix = new Bank(schema.getSchema("RUN::unix")); TreeMap m = new TreeMap<>(); Event e = new Event(); for (String f : files) { From 5a90cd7356937bbff6f8ace3207597fecb5fd8d2 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Thu, 21 May 2026 16:53:12 -0400 Subject: [PATCH 03/12] propagate to old post-processor --- .../jlab/analysis/postprocess/Tag1ToEvent.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Tag1ToEvent.java b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Tag1ToEvent.java index 857a9962f6..42965aec22 100644 --- a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Tag1ToEvent.java +++ b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Tag1ToEvent.java @@ -1,5 +1,6 @@ package org.jlab.analysis.postprocess; +import java.util.TreeMap; import java.util.logging.Logger; import org.jlab.clas.reco.ReconstructionEngine; import org.jlab.detector.calib.utils.ConstantsManager; @@ -100,6 +101,9 @@ public static void main(String[] args) { helSeq.initialize(parser.getInputList()); } + // Initialize the unix-event map: + TreeMap eventUnix = Processor.getEventUnixMap(schema, parser.getInputList()); + // Loop over the input HIPO files: LOGGER.info("\n>>> Starting post-processing ...\n"); for (String filename : parser.getInputList()) { @@ -147,6 +151,17 @@ public static void main(String[] args) { event.write(recEventBank); event.write(helScalerBank); + // Update RUN::config.unixtime: + if (runConfigBank.getRows() > 0) { + int evno = runConfigBank.getByte("event", 0); + Integer unix = eventUnix.get(eventUnix.floorKey(evno)); + if (unix != null) { + event.remove(runConfigBank.getSchema()); + runConfigBank.putInt("unixtime", 0, unix); + event.write(runConfigBank); + } + } + // Write out the original event: writer.addEvent(event, event.getEventTag()); From 6735592a7ce0e0b36a73605a56fa052d7038e590 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Thu, 21 May 2026 19:52:17 -0400 Subject: [PATCH 04/12] finish the old new postprocessor --- .../jlab/analysis/postprocess/Processor.java | 49 ++++++++++++++++++- 1 file changed, 48 insertions(+), 1 deletion(-) diff --git a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java index 25070f93e6..0b9b090b26 100644 --- a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java +++ b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java @@ -23,6 +23,9 @@ import org.jlab.detector.scalers.DaqScalersSequence; import org.jlab.detector.helicity.HelicityBit; import org.jlab.detector.helicity.HelicitySequenceDelayed; +import org.jlab.jnp.hipo4.io.HipoWriterSorted; +import org.jlab.utils.options.OptionParser; +import org.jlab.utils.system.ClasUtilsFile; /** * @@ -56,6 +59,10 @@ public Processor(String dir, String glob, boolean restream, boolean rebuild) { configure(findPreloadFiles(dir,glob), restream, rebuild); } + public Processor(List files, boolean restream, boolean rebuild) { + configure(files, restream, rebuild); + } + public Processor(SchemaFactory schema, HelicitySequenceDelayed h, DaqScalersSequence s) { conman = new ConstantsManager(); conman.init(CCDB_TABLES); @@ -295,8 +302,48 @@ private static void replace(Map files) { } } + /** + * The "postprocess" program. + * @param args + */ public static void main(String args[]) { - Processor p = new Processor(System.getenv("HOME")+"/tmp","r*.hipo",false,false); + + OptionParser o = new OptionParser("postprocess"); + o.addOption("-f","0","reflip: rebuild the HEL::flip bank"); + o.addOption("-c","0","recharge: rebuild the RUN/HEL::scaler banks"); + o.addOption("-o",null,"merged output file path"); + o.setRequiresInputList(true); + o.parse(args); + + boolean restream = !o.getOption("-f").isDefault(); + boolean rebuild = !o.getOption("-c").isDefault(); + + Processor post = new Processor(o.getInputList(), restream, rebuild); + + HipoWriterSorted writer = null; + + if (!o.getOption("-o").isDefault()) { + writer = new HipoWriterSorted(); + SchemaFactory schema = writer.getSchemaFactory(); + schema.initFromDirectory(ClasUtilsFile.getResourceDir("CLAS12DIR", "etc/bankdefs/hipo4")); + writer.setCompressionType(2); + writer.open(o.getOption("-o").stringValue()); + } + + for (String f : o.getInputList()) { + HipoReader reader = new HipoReader(); + reader.setTags(0); + reader.open(f); + Event event = new Event(); + while (reader.hasNext()) { + reader.nextEvent(event); + post.processEvent(event); + if (writer != null) writer.addEvent(event); + } + reader.close(); + } + + if (writer != null) writer.close(); } } From 89902ed925116cb58b8fbd8fecfdd0de2e56c5a3 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Fri, 22 May 2026 18:06:56 -0400 Subject: [PATCH 05/12] add new postprocessor --- bin/postprocess2 | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100755 bin/postprocess2 diff --git a/bin/postprocess2 b/bin/postprocess2 new file mode 100755 index 0000000000..b10c9ff07a --- /dev/null +++ b/bin/postprocess2 @@ -0,0 +1,10 @@ +#!/bin/bash + +. `dirname $0`/../libexec/env.sh + +export MALLOC_ARENA_MAX=1 + +java ${JAVA_OPTS-} -Xmx768m -Xms768m -XX:+UseSerialGC \ + -cp ${COATJAVA_CLASSPATH:-''} \ + org.jlab.analysis.postprocess.Processor \ + $* From 3a53b39c7dd3f477869ea48f32290419a5573339 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Fri, 22 May 2026 18:12:46 -0400 Subject: [PATCH 06/12] remove constructor --- .../java/org/jlab/analysis/postprocess/Processor.java | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java index 0b9b090b26..e154924353 100644 --- a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java +++ b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java @@ -63,16 +63,6 @@ public Processor(List files, boolean restream, boolean rebuild) { configure(files, restream, rebuild); } - public Processor(SchemaFactory schema, HelicitySequenceDelayed h, DaqScalersSequence s) { - conman = new ConstantsManager(); - conman.init(CCDB_TABLES); - schemaFactory = schema; - helicitySequence = h; - chargeSequence = s; - runConfig = new Bank(schemaFactory.getSchema("RUN::config")); - recEvent = new Bank(schemaFactory.getSchema("REC::Event")); - } - private void configure(List preloadFiles, boolean restream, boolean rebuild) { if (!preloadFiles.isEmpty()) { HipoReader r = new HipoReader(); From b38724a9c0b4a018a65d8e497d1254c784440f27 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Fri, 22 May 2026 18:33:17 -0400 Subject: [PATCH 07/12] remove postprocessing engine --- reconstruction/pom.xml | 1 - reconstruction/postproc/pom.xml | 38 ------------ .../jlab/service/postproc/PostprocEngine.java | 58 ------------------- 3 files changed, 97 deletions(-) delete mode 100644 reconstruction/postproc/pom.xml delete mode 100644 reconstruction/postproc/src/main/java/org/jlab/service/postproc/PostprocEngine.java diff --git a/reconstruction/pom.xml b/reconstruction/pom.xml index 25099bd6b9..5b555fcac9 100644 --- a/reconstruction/pom.xml +++ b/reconstruction/pom.xml @@ -36,7 +36,6 @@ urwt alert bg - postproc recoil calib uber diff --git a/reconstruction/postproc/pom.xml b/reconstruction/postproc/pom.xml deleted file mode 100644 index b748059b77..0000000000 --- a/reconstruction/postproc/pom.xml +++ /dev/null @@ -1,38 +0,0 @@ - - - 4.0.0 - - org.jlab.clas12.detector - clas12detector-postproc - 14.0.0-SNAPSHOT - jar - - - org.jlab.clas12 - reconstruction - 14.0.0-SNAPSHOT - - - - - - org.jlab.clas - clas-io - 14.0.0-SNAPSHOT - - - - org.jlab.clas - clas-reco - 14.0.0-SNAPSHOT - - - - org.jlab.clas - clas-analysis - 14.0.0-SNAPSHOT - - - - - diff --git a/reconstruction/postproc/src/main/java/org/jlab/service/postproc/PostprocEngine.java b/reconstruction/postproc/src/main/java/org/jlab/service/postproc/PostprocEngine.java deleted file mode 100644 index 0aa6145e85..0000000000 --- a/reconstruction/postproc/src/main/java/org/jlab/service/postproc/PostprocEngine.java +++ /dev/null @@ -1,58 +0,0 @@ -package org.jlab.service.postproc; - -import java.io.File; -import java.util.logging.Logger; -import org.jlab.analysis.postprocess.Processor; -import org.jlab.clas.reco.ReconstructionEngine; -import org.jlab.io.base.DataEvent; - -/** - * Post-processing as an engine. - * @author baltzell - */ -public class PostprocEngine extends ReconstructionEngine { - - public static final String CONF_PRELOAD_FILE = "preloadFile"; - public static final String CONF_PRELOAD_DIR = "preloadDir"; - public static final String CONF_PRELOAD_GLOB = "preloadGlob"; - public static final String CONF_RESTREAM_HELICITY = "restream"; - public static final String CONF_REBUILD_SCALERS = "rebuild"; - - static final Logger logger = Logger.getLogger(PostprocEngine.class.getName()); - - Processor processor = null; - - public PostprocEngine() { - super("PP", "baltzell", "1.0"); - } - - @Override - public boolean init() { - requireConstants(Processor.CCDB_TABLES); - if (getEngineConfigString(CONF_PRELOAD_FILE) != null) { - if (getEngineConfigString(CONF_PRELOAD_DIR) != null) - logger.warning("PostprocEngine:: Ignoring preloadDir, using preloadFile."); - processor = new Processor(new File(getEngineConfigString(CONF_PRELOAD_FILE)), - Boolean.parseBoolean(getEngineConfigString(CONF_RESTREAM_HELICITY,"false")), - Boolean.parseBoolean(getEngineConfigString(CONF_REBUILD_SCALERS,"false"))); - } - else if (getEngineConfigString(CONF_PRELOAD_DIR) != null) { - processor = new Processor( - getEngineConfigString(CONF_PRELOAD_DIR), - getEngineConfigString(CONF_PRELOAD_GLOB, Processor.DEF_PRELOAD_GLOB), - Boolean.parseBoolean(getEngineConfigString(CONF_RESTREAM_HELICITY,"false")), - Boolean.parseBoolean(getEngineConfigString(CONF_REBUILD_SCALERS,"false"))); - } - return true; - } - - @Override - public void detectorChanged(int run) {} - - @Override - public boolean processDataEventUser(DataEvent event) { - processor.processEvent(event); - return true; - } - -} From 9b6fd5bed9d431d22bfe270c67de3f7743799a35 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Fri, 22 May 2026 18:34:02 -0400 Subject: [PATCH 08/12] cleanup constructors --- .../java/org/jlab/io/clara/Clas12Writer.java | 7 +- .../jlab/analysis/postprocess/Processor.java | 71 ++++++------------- 2 files changed, 25 insertions(+), 53 deletions(-) diff --git a/common-tools/clara-io/src/main/java/org/jlab/io/clara/Clas12Writer.java b/common-tools/clara-io/src/main/java/org/jlab/io/clara/Clas12Writer.java index 02fe28979a..9c915e06ff 100644 --- a/common-tools/clara-io/src/main/java/org/jlab/io/clara/Clas12Writer.java +++ b/common-tools/clara-io/src/main/java/org/jlab/io/clara/Clas12Writer.java @@ -2,6 +2,7 @@ import java.io.File; import java.nio.file.Path; +import java.util.List; import java.util.TreeMap; import java.util.TreeSet; import org.jlab.analysis.postprocess.Processor; @@ -146,9 +147,9 @@ private Event getUnixEvent(Bank config) { */ private void postprocess() { int d = conman.getConstants(getRunNumber(), "/runcontrol/helicity").getIntValue("delay",0,0,0); - HelicitySequenceDelayed h = new HelicitySequenceDelayed(d); - h.addStream(helicities); - Processor p = new Processor(fullSchema, h, scalers); + HelicitySequenceDelayed helicity = new HelicitySequenceDelayed(d); + helicity.addStream(helicities); + Processor p = new Processor(List.of(filename), fullSchema, helicity, scalers); HipoReader r = new HipoReader(); r.open(filename); Event e = new Event(); diff --git a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java index e154924353..ff1cda2cf5 100644 --- a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java +++ b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java @@ -1,10 +1,6 @@ package org.jlab.analysis.postprocess; import java.io.File; -import java.nio.file.FileSystems; -import java.nio.file.PathMatcher; -import java.util.ArrayList; -import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -47,55 +43,30 @@ public class Processor { private HelicitySequenceDelayed helicitySequence = null; private TreeMap eventUnix = null; - public Processor(File file, boolean restream, boolean rebuild) { - configure(Arrays.asList(file.getAbsolutePath()), restream, rebuild); - } - - public Processor(String dir, boolean restream, boolean rebuild) { - configure(findPreloadFiles(dir,DEF_PRELOAD_GLOB), restream, rebuild); - } - - public Processor(String dir, String glob, boolean restream, boolean rebuild) { - configure(findPreloadFiles(dir,glob), restream, rebuild); - } - public Processor(List files, boolean restream, boolean rebuild) { - configure(files, restream, rebuild); - } - - private void configure(List preloadFiles, boolean restream, boolean rebuild) { - if (!preloadFiles.isEmpty()) { - HipoReader r = new HipoReader(); - r.open(preloadFiles.get(0)); - schemaFactory = r.getSchemaFactory(); - r.close(); - runConfig = new Bank(schemaFactory.getSchema("RUN::config")); - recEvent = new Bank(schemaFactory.getSchema("REC::Event")); - conman = new ConstantsManager(); - conman.init(CCDB_TABLES); - helicitySequence = Util.getHelicity(preloadFiles, schemaFactory, restream, conman); - if (rebuild) chargeSequence = DaqScalersSequence.rebuildSequence(1, conman, preloadFiles); - else chargeSequence = DaqScalersSequence.readSequence(preloadFiles); - eventUnix = getEventUnixMap(schemaFactory, preloadFiles); - } + HipoReader r = new HipoReader(); + r.open(files.get(0)); + schemaFactory = r.getSchemaFactory(); + r.close(); + runConfig = new Bank(schemaFactory.getSchema("RUN::config")); + recEvent = new Bank(schemaFactory.getSchema("REC::Event")); + conman = new ConstantsManager(); + conman.init(CCDB_TABLES); + helicitySequence = Util.getHelicity(files, schemaFactory, restream, conman); + if (rebuild) chargeSequence = DaqScalersSequence.rebuildSequence(1, conman, files); + else chargeSequence = DaqScalersSequence.readSequence(files); + eventUnix = getEventUnixMap(schemaFactory, files); } - /** - * Get a list of files to preload, from one directory and a glob. - * @param dir - * @param glob - * @return list of preload files - */ - private static List findPreloadFiles(String dir, String glob) { - List ret = new ArrayList<>(); - if (dir != null) { - PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:"+dir+"/"+glob); - for (File f : (new File(dir)).listFiles()) { - if (matcher.matches(f.toPath())) - ret.add(f.getPath()); - } - } - return ret; + public Processor(List files, SchemaFactory schema, HelicitySequenceDelayed h, DaqScalersSequence s) { + schemaFactory = schema; + helicitySequence = h; + chargeSequence = s; + runConfig = new Bank(schemaFactory.getSchema("RUN::config")); + recEvent = new Bank(schemaFactory.getSchema("REC::Event")); + conman = new ConstantsManager(); + conman.init(CCDB_TABLES); + eventUnix = getEventUnixMap(schemaFactory, files); } /** From 7a5b38a37661110851c78de3786f461b09964d36 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Fri, 22 May 2026 18:35:02 -0400 Subject: [PATCH 09/12] process all events --- .../src/main/java/org/jlab/analysis/postprocess/Processor.java | 1 - 1 file changed, 1 deletion(-) diff --git a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java index ff1cda2cf5..976634c5e7 100644 --- a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java +++ b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java @@ -293,7 +293,6 @@ public static void main(String args[]) { for (String f : o.getInputList()) { HipoReader reader = new HipoReader(); - reader.setTags(0); reader.open(f); Event event = new Event(); while (reader.hasNext()) { From 6ac1dad4949b1dd3495a9bcb0eaf7e46de8a72be Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Fri, 22 May 2026 19:08:06 -0400 Subject: [PATCH 10/12] support nulls --- .../src/main/java/org/jlab/utils/options/OptionValue.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common-tools/clas-utils/src/main/java/org/jlab/utils/options/OptionValue.java b/common-tools/clas-utils/src/main/java/org/jlab/utils/options/OptionValue.java index 5ffcac4963..8eea68f1b3 100644 --- a/common-tools/clas-utils/src/main/java/org/jlab/utils/options/OptionValue.java +++ b/common-tools/clas-utils/src/main/java/org/jlab/utils/options/OptionValue.java @@ -55,6 +55,6 @@ public boolean parse(List arguments){ } public boolean isDefault() { - return this.optionValue.equals(this.optionDefault); + return this.optionValue == null || this.optionValue.equals(this.optionDefault); } } From 198f395ffcbcea7ebd8c5971b839b38ea82171a8 Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Fri, 22 May 2026 19:08:22 -0400 Subject: [PATCH 11/12] cleanup/bugfix --- .../jlab/analysis/postprocess/Processor.java | 63 +++++-------------- 1 file changed, 14 insertions(+), 49 deletions(-) diff --git a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java index 976634c5e7..70bdf6ddba 100644 --- a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java +++ b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Processor.java @@ -1,9 +1,6 @@ package org.jlab.analysis.postprocess; -import java.io.File; -import java.util.HashMap; import java.util.List; -import java.util.Map; import java.util.TreeMap; import org.jlab.jnp.hipo4.data.Bank; @@ -31,9 +28,6 @@ public class Processor { public static final String CCDB_TABLES[] = {"/runcontrol/fcup","/runcontrol/slm", "/runcontrol/helicity","/daq/config/scalers/dsc1","/runcontrol/hwp"}; - public static final String DEF_PRELOAD_GLOB = "*.{hipo,h5}"; - - private final String outputPrefix = "tmp_"; private Bank runConfig = null; private Bank recEvent = null; @@ -76,20 +70,18 @@ public Processor(List files, SchemaFactory schema, HelicitySequenceDelay * @return map */ public static TreeMap getEventUnixMap(SchemaFactory schema, List files) { - Bank unix = new Bank(schema.getSchema("RUN::unix")); TreeMap m = new TreeMap<>(); Event e = new Event(); + Bank b = schema.getBank("RUN::unix");//new Bank(schema.getSchema("RUN::unix")); for (String f : files) { HipoReader r = new HipoReader(); r.setTags(1); r.open(f); while (r.hasNext()) { r.nextEvent(e); - e.read(unix); - int size = unix.getRows(); - for (int i=0; i0) { @@ -168,11 +160,14 @@ private void processEventScalers(Bank runcfg, Bank recevt) { */ private void processEventUnix(Event event, Bank runcfg) { if (runcfg.getRows() > 0) { - Integer unix = eventUnix.get(eventUnix.floorKey(runcfg.getInt("event",0))); - if (unix != null) { - event.remove(runcfg.getSchema()); - runcfg.putInt("unixtime", 0, unix); - event.write(runcfg); + Integer key = eventUnix.floorKey(runcfg.getInt("event",0)); + if (key != null) { + Integer unix = eventUnix.get(key); + if (unix != null) { + event.remove(runcfg.getSchema()); + runcfg.putInt("unixtime", 0, unix); + event.write(runcfg); + } } } } @@ -233,36 +228,6 @@ public void processEvent(Event event) { } } - /** - * Create rebuilt files from preload files. - * @param files - * @return map of rebuilt:preload files - */ - private Map rebuild(String dir, List files) { - File d = new File(dir); - if (!d.canWrite()) { - throw new RuntimeException("No write permissions on "+dir); - } - Map rebuiltFiles = new HashMap<>(); - for (String preloadFile : files) { - String rebuiltFile = dir+"/"+outputPrefix+preloadFile.replace(dir+"/",""); - Util.rebuildScalers(conman, preloadFile, rebuiltFile); - rebuiltFiles.put(rebuiltFile,preloadFile); - } - return rebuiltFiles; - } - - /** - * Replace files with new ones. - * @param files map of new:old filenames - */ - private static void replace(Map files) { - for (String rebuiltFile : files.keySet()) { - new File(files.get(rebuiltFile)).delete(); - new File(rebuiltFile).renameTo(new File(files.get(rebuiltFile))); - } - } - /** * The "postprocess" program. * @param args From ad7484f02663f3eef44a396de4a5ee5ea810024c Mon Sep 17 00:00:00 2001 From: Nathan Baltzell Date: Fri, 22 May 2026 19:08:31 -0400 Subject: [PATCH 12/12] bugfix --- .../jlab/analysis/postprocess/Tag1ToEvent.java | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Tag1ToEvent.java b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Tag1ToEvent.java index 42965aec22..b85efd3a95 100644 --- a/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Tag1ToEvent.java +++ b/common-tools/clas-analysis/src/main/java/org/jlab/analysis/postprocess/Tag1ToEvent.java @@ -153,12 +153,15 @@ public static void main(String[] args) { // Update RUN::config.unixtime: if (runConfigBank.getRows() > 0) { - int evno = runConfigBank.getByte("event", 0); - Integer unix = eventUnix.get(eventUnix.floorKey(evno)); - if (unix != null) { - event.remove(runConfigBank.getSchema()); - runConfigBank.putInt("unixtime", 0, unix); - event.write(runConfigBank); + int evno = runConfigBank.getInt("event", 0); + Integer key = eventUnix.floorKey(evno); + if (key != null) { + Integer unix = eventUnix.get(key); + if (unix != null) { + event.remove(runConfigBank.getSchema()); + runConfigBank.putInt("unixtime", 0, unix); + event.write(runConfigBank); + } } }