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 a094b939cd..cead1b0607 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
@@ -8,6 +8,7 @@
 import org.jlab.analysis.postprocess.Processor;
 import org.jlab.clara.std.services.EventWriterException;
 import org.jlab.detector.calib.utils.ConstantsManager;
+import org.jlab.detector.calib.utils.OccupancyTable;
 import org.jlab.detector.decode.CLASDecoder4;
 import org.jlab.detector.helicity.HelicitySequence;
 import org.jlab.detector.helicity.HelicitySequenceDelayed;
@@ -35,6 +36,9 @@ public class Clas12Writer extends HipoToHipoWriter {
 
     static final String[] TAG1BANKS = {"RUN::scaler","HEL::scaler","RAW::scaler","RAW::epics","HEL::flip","COAT::config"};
 
+    long occupancyEvents;
+    OccupancyTable[] occupancyTables;
+    Bank[] occupancyBanks;
     Bank[] tag1banks;
     Bank runConfig;
     Bank helicityAdc;
@@ -46,6 +50,7 @@ public class Clas12Writer extends HipoToHipoWriter {
     boolean postprocess;
 
     private void init(JSONObject opts) {
+        occupancyEvents = 0;
         fullSchema = new SchemaFactory();
         fullSchema.initFromDirectory(FileUtils.getEnvironmentPath("CLAS12DIR","etc/bankdefs/hipo4"));
         runConfig = new Bank(fullSchema.getSchema("RUN::config"));
@@ -61,6 +66,10 @@ private void init(JSONObject opts) {
         tag1banks = new Bank[TAG1BANKS.length];
         for (int i=0; i<tag1banks.length; ++i)
             tag1banks[i] = new Bank(fullSchema.getSchema(TAG1BANKS[i]));
+        occupancyBanks = new Bank[1];
+        occupancyBanks[0] = new Bank(fullSchema.getSchema("DC::occ"));
+        occupancyTables = new OccupancyTable[1];
+        occupancyTables[0] = new OccupancyTable.DC();
     }
 
     @Override
@@ -76,6 +85,22 @@ protected HipoWriterSorted createWriter(Path file, JSONObject opts) throws Event
         }
     }
 
+    private void processOccupancy(Event event) {
+        for (int i=0; i<occupancyBanks.length; i++) {
+            event.read(occupancyBanks[i]);
+            event.remove(occupancyBanks[i].getSchema());
+            occupancyTables[i].fill(occupancyBanks[i], true);
+        }
+        if (occupancyEvents++ % 1000 == 0) {
+            for (int i=0; i<occupancyBanks.length; i++) {
+                occupancyTables[i].create(occupancyEvents, occupancyBanks[i]);
+                event.write(occupancyBanks[i]);
+                occupancyTables[i].reset();
+            }
+            occupancyEvents = 0;
+        }
+    }
+
     @Override
     protected void writeEvent(Object event) throws EventWriterException {
         scalers.add((Event)event);
@@ -86,6 +111,7 @@ protected void writeEvent(Object event) throws EventWriterException {
             int evno = runConfig.getInt("event",0);
             if (unix > 0 && evno > 0) eventUnix.put(evno, unix);
         }
+        processOccupancy((Event)event);
         helicities.add(HelicityState.createFromFadcBank(helicityAdc, runConfig, conman));
         Event t = CLASDecoder4.createTaggedEvent((Event)event, runConfig, tag1banks);
         if (!t.isEmpty()) writer.addEvent(t, 1);
diff --git a/common-tools/clas-detector/src/main/java/org/jlab/detector/calib/utils/OccupancyTable.java b/common-tools/clas-detector/src/main/java/org/jlab/detector/calib/utils/OccupancyTable.java
new file mode 100644
index 0000000000..bbd5e6339d
--- /dev/null
+++ b/common-tools/clas-detector/src/main/java/org/jlab/detector/calib/utils/OccupancyTable.java
@@ -0,0 +1,176 @@
+package org.jlab.detector.calib.utils;
+
+import java.util.Map;
+import org.jlab.io.base.DataBank;
+import org.jlab.io.base.DataEvent;
+import org.jlab.jnp.hipo4.data.Bank;
+import org.jlab.utils.groups.IndexedTable;
+import org.jlab.utils.groups.IndexedTable.IndexedEntry;
+
+public abstract class OccupancyTable {
+
+    public static class DC extends OccupancyTable {
+        public DC() { super(); }
+        /*public void fill(DataEvent e) {
+            DataBank b = e.getBank("DC::tot");
+            if (b == null) b = e.getBank("DC::tdc");
+            if (b == null) return;
+            final int rows = b.rows();
+            for (int i=0; i<rows; i++)
+                fill(b.getByte(0, i), b.getByte(1,i), b.getByte(2,i));
+        }*/
+    }
+
+    protected String[] valueNames = {"occ/F"};
+    protected String[] indexNames = {"sector","layer","component"};
+    protected IndexedTable table;
+
+    public OccupancyTable(String... index) {
+        indexNames = index;
+        reset();
+    }
+
+    public OccupancyTable() {
+        reset();
+    }
+
+    /**
+     * Reset occupancy table.
+     */
+    public final void reset() {
+        table = new IndexedTable(indexNames.length, valueNames);
+    }
+
+    /**
+     * Fill occupancy table with a weight.
+     * @param weight
+     * @param index 
+     */
+    public final void fill(float weight, int... index) {
+        final long hash = IndexedTable.DEFAULT_GENERATOR.hashCode(index);
+        if (!table.hasEntryByHash(hash)) {
+            table.addEntry(index);
+            table.setIntValueByHash(0, 0, hash);
+        }
+        table.setDoubleValueByHash(table.getDoubleValueByHash(0, hash) + weight, 0, hash);
+    }
+
+    /**
+     * Fill occupancy table.
+     * @param index 
+     */
+    public final void fill(int... index) {
+        fill(1.0f, index);
+    }
+
+    /**
+     * 
+     * @param bank 
+     * @param weighted 
+     */
+    public void fill(DataBank bank, boolean weighted) {
+        final int rows = bank.rows();
+        int[] indices = new int[indexNames.length];
+        for (int i=0; i<rows; i++) {
+            for (int j=0; j<indexNames.length; j++) {
+                if (j==2) indices[j] = bank.getShort(j,i);
+                else indices[j] = bank.getByte(j,i);
+            }
+            if (weighted) fill(bank.getFloat(indexNames.length,i), indices);
+            else fill(indices);
+        }
+    }
+
+    /**
+     * 
+     * @param event
+     * @param bank
+     * @param weighted 
+     */
+    public void fill(DataEvent event, String bank, boolean weighted) {
+        DataBank b = event.getBank(bank);
+        if (b != null) fill(b, weighted);
+    }
+
+    /**
+     * 
+     * @param bank 
+     * @param weighted 
+     */
+    public final void fill(Bank bank, boolean weighted) {
+        int rows = bank.getRows();
+        int[] indices = new int[indexNames.length];
+        for (int i=0; i<rows; i++) {
+            for (int j=0; j<indexNames.length; j++) {
+                if (j==2) indices[j] = bank.getShort(j,i);
+                else indices[j] = bank.getByte(j,i);
+            }
+            if (weighted) fill(bank.getFloat(indexNames.length,i), indices);
+            else fill(indices);
+        }
+    }
+    
+    /**
+     * Get number of rows for the occupancy bank.
+     * @return rows 
+     */
+    public final int getRows() {
+        return table.getRowCount();
+    }
+
+    /**
+     * Create an occupancy bank of the given name.
+     * @param event
+     * @param bank
+     * @return 
+     */
+    public final DataBank create(DataEvent event, String bank) {
+        DataBank b = event.createBank(bank, getRows());
+        int i = 0;
+        Map<Long,IndexedEntry> m = table.getList().getMap();
+        for (long hash : m.keySet()) {
+            int[] indices = IndexedTable.DEFAULT_GENERATOR.getIndices(hash, indexNames.length);
+            for (int j=0; j<indexNames.length; j++) {
+                if (j == 2) b.setShort(j, i, (short)indices[j]);
+                else b.setByte(j, i, (byte)indices[j]);
+            }
+            b.setFloat(indexNames.length, i, m.get(hash).getValue(0).intValue());
+            i++;
+        }
+        return b;
+    }
+
+    /**
+     * Modify the user-provided occupancy bank. 
+     * @param events
+     * @param b
+     */
+    public final void create(long events, Bank b) {
+        b.setRows(getRows());
+        int row = 0;
+        for (long hash : ((Map<Long,IndexedEntry>)table.getList().getMap()).keySet()) {
+            int[] idx = IndexedTable.DEFAULT_GENERATOR.getIndices(hash, indexNames.length);
+            for (int j=0; j<indexNames.length; j++){
+                if (j == 2) b.putShort(j, row, (short)idx[j]);
+                else b.putByte(j, row, (byte)idx[j]);
+            }
+            b.putFloat(indexNames.length, row, (float)table.getDoubleValueByHash(0, hash)/events);
+            row++;
+        }
+    }
+
+    /**
+     * Get the occupancy table.
+     * @param events
+     * @return 
+     */
+    public final IndexedTable create(long events) {
+        IndexedTable t = new IndexedTable(indexNames.length, valueNames);
+        for (long hash : ((Map<Long,IndexedEntry>)table.getList().getMap()).keySet()) {
+            t.addEntry(IndexedTable.DEFAULT_GENERATOR.getIndices(hash, indexNames.length));
+            t.setDoubleValueByHash((table.getDoubleValueByHash(0, hash))/events, 0, hash);
+        }
+        return t;
+    }
+
+}
\ No newline at end of file
diff --git a/common-tools/clas-reco/src/main/java/org/jlab/clas/reco/OccupancyEngine.java b/common-tools/clas-reco/src/main/java/org/jlab/clas/reco/OccupancyEngine.java
new file mode 100644
index 0000000000..1dab369dc1
--- /dev/null
+++ b/common-tools/clas-reco/src/main/java/org/jlab/clas/reco/OccupancyEngine.java
@@ -0,0 +1,35 @@
+package org.jlab.clas.reco;
+
+import org.jlab.detector.calib.utils.OccupancyTable;
+import org.jlab.io.base.DataEvent;
+
+/**
+ *
+ * @author baltzell
+ */
+public class OccupancyEngine extends ReconstructionEngine {
+
+    OccupancyTable[] tables = {new OccupancyTable.DC()};
+    String[] banks = {"DC::occ"};
+    
+    public OccupancyEngine() {
+        super("Occupancy", "baltzell", "0.1");
+    }
+
+    @Override
+    public boolean processDataEventUser(DataEvent event) {
+        for (int i=0; i<tables.length; i++) {
+            tables[i].fill(event, banks[i], false);
+            event.appendBank(tables[i].create(event, banks[i]));
+            tables[i].reset();
+        }
+        return true;
+    }
+
+    @Override
+    public boolean init() { return true; }
+
+    @Override
+    public void detectorChanged(int runNumber) {}
+
+}
\ No newline at end of file
diff --git a/common-tools/clas-utils/src/main/java/org/jlab/utils/groups/IndexedList.java b/common-tools/clas-utils/src/main/java/org/jlab/utils/groups/IndexedList.java
index 21b9aca355..384e2cb259 100644
--- a/common-tools/clas-utils/src/main/java/org/jlab/utils/groups/IndexedList.java
+++ b/common-tools/clas-utils/src/main/java/org/jlab/utils/groups/IndexedList.java
@@ -334,6 +334,19 @@ public int getIndex(long hashcode, int order) {
         public int[] getIndices(long hashcode, int... indices) {
             int[] ret = new int[indices.length];
             for (int i=0; i<ret.length; i++)
+                ret[i] = getIndex(hashcode, indices[i]);
+            return ret;
+        }
+
+        /**
+         * Retrieves an array of the indices.
+         * @param hashcode
+         * @param nindices
+         * @return 
+         */
+        public int[] getIndices(long hashcode, int nindices) {
+            int[] ret = new int[nindices];
+            for (int i=0; i<nindices; i++)
                 ret[i] = getIndex(hashcode, i);
             return ret;
         }
diff --git a/common-tools/clas-utils/src/main/java/org/jlab/utils/groups/IndexedTable.java b/common-tools/clas-utils/src/main/java/org/jlab/utils/groups/IndexedTable.java
index 28dcdf629d..a82bd23715 100644
--- a/common-tools/clas-utils/src/main/java/org/jlab/utils/groups/IndexedTable.java
+++ b/common-tools/clas-utils/src/main/java/org/jlab/utils/groups/IndexedTable.java
@@ -167,6 +167,10 @@ public void setIntValueByHash(Integer value, int column, long hash) {
         this.entries.getItemByHash(hash).setValue(column, value);
     }
 
+    public void setDoubleValueByHash(Double value, int column, long hash) {
+        this.entries.getItemByHash(hash).setValue(column, value);
+    }
+
     public int getIntValueByHash(int index, long hash) {
         return entries.getItemByHash(hash).getValue(index).intValue();
     }
diff --git a/etc/bankdefs/hipo4/occupancy.json b/etc/bankdefs/hipo4/occupancy.json
new file mode 100644
index 0000000000..c89164248d
--- /dev/null
+++ b/etc/bankdefs/hipo4/occupancy.json
@@ -0,0 +1,14 @@
+[
+    {
+        "name": "DC::occ",
+        "group": 20600,
+        "item": 20,
+        "info": "Event Header Bank",
+        "entries": [
+            { "name":"sector"    , "type":"B", "info":"sector"},
+            { "name":"layer"     , "type":"B", "info":"layer"},
+            { "name":"component" , "type":"S", "info":"component"},
+            { "name":"hits"      , "type":"F", "info":"number of hits"}
+        ]
+    }
+]