diff -u -r1.9 -r1.10
--- HPSEcalFADCReadoutDriver.java	3 Apr 2012 17:02:35 -0000	1.9
+++ HPSEcalFADCReadoutDriver.java	4 Apr 2012 20:43:37 -0000	1.10
@@ -12,6 +12,7 @@

 import org.lcsim.event.EventHeader;
 import org.lcsim.event.RawCalorimeterHit;
 import org.lcsim.event.RawTrackerHit;

+import org.lcsim.event.base.BaseRawCalorimeterHit;

 import org.lcsim.event.base.BaseRawTrackerHit;
 import org.lcsim.geometry.subdetector.HPSEcal3;
 import org.lcsim.hps.util.ClockSingleton;

@@ -23,7 +24,7 @@

  * Simulates time evolution of preamp output pulse.
  *
  * @author Sho Uemura <[log in to unmask]>

- * @version $Id: HPSEcalFADCReadoutDriver.java,v 1.9 2012/04/03 17:02:35 meeg Exp $

+ * @version $Id: HPSEcalFADCReadoutDriver.java,v 1.10 2012/04/04 20:43:37 meeg Exp $

  */
 public class HPSEcalFADCReadoutDriver extends HPSEcalReadoutDriver<RawCalorimeterHit> {
 

@@ -196,7 +197,8 @@

 
 	@Override
 	protected void processTrigger(EventHeader event) {

-		event.put(ecalReadoutCollectionName, readWindow(), RawTrackerHit.class, 0, ecalReadoutName);

+//		event.put(ecalReadoutCollectionName, readWindow(), RawTrackerHit.class, 0, ecalReadoutName);
+		event.put(ecalReadoutCollectionName, readIntegral(), RawCalorimeterHit.class, 0, ecalReadoutName);

 	}
 
 	protected List<RawTrackerHit> readWindow() {

@@ -221,6 +223,28 @@

 		return hits;
 	}
 

+	protected List<RawCalorimeterHit> readIntegral() { //TODO: integration algorithm is totally bogus
+		System.out.println("Reading FADC data");
+		List<RawCalorimeterHit> hits = new ArrayList<RawCalorimeterHit>();
+
+		Set<Long> cells = ((HPSEcal3) ecal).getNeighborMap().keySet();
+		for (Long cellID : cells) {
+			FADCPipeline pipeline = pipelineMap.get(cellID);
+			int adcSum = 0;
+			if (pipeline == null) {
+				for (int i = 0; i < readoutWindow; i++) {
+					adcSum += converter.AtoD(0.0, cellID);
+				}
+			} else {
+				for (int i = 0; i < readoutWindow; i++) {
+					adcSum += pipeline.getValue(readoutLatency - i);
+				}
+			}
+			hits.add(new BaseRawCalorimeterHit(cellID, adcSum, 0));
+		}
+		return hits;
+	}
+

 	@Override
 	protected void putHits(List<CalorimeterHit> hits) {
 		//fill the readout buffers

diff -u -r1.7 -r1.8
--- HPSTriggerDriver.java	3 Apr 2012 17:02:35 -0000	1.7
+++ HPSTriggerDriver.java	4 Apr 2012 20:43:37 -0000	1.8
@@ -11,6 +11,7 @@

 import org.lcsim.geometry.Detector;
 import org.lcsim.geometry.IDDecoder;
 import org.lcsim.geometry.Subdetector;

+import org.lcsim.hps.evio.TestRunTriggeredReconToEvio;

 import org.lcsim.hps.recon.tracking.apv25.HPSAPV25;
 import org.lcsim.hps.util.ClockSingleton;
 import org.lcsim.util.Driver;

@@ -21,7 +22,7 @@

  * Applies SVT trigger latency and sends trigger signal to SVT
  *
  * @author Sho Uemura <[log in to unmask]>

- * @version $Id: HPSTriggerDriver.java,v 1.7 2012/04/03 17:02:35 meeg Exp $

+ * @version $Id: HPSTriggerDriver.java,v 1.8 2012/04/04 20:43:37 meeg Exp $

  */
 public abstract class HPSTriggerDriver extends Driver {
 

@@ -130,6 +131,12 @@

 					ClockSingleton.getTime() + svtTriggerLatency);
 			ecalTriggerTimestamps.add(ClockSingleton.getTime() + ecalTriggerLatency);
 			System.out.println("Trigger added");

+
+			if (outputStream != null) {
+				outputStream.printf("trigger sent to ET event builder on event %d\n", event.getEventNumber());
+			}
+			TestRunTriggeredReconToEvio.triggerBit = true;
+

 		}
 
 		// Check if there are any pending SVT triggers to process

@@ -156,6 +163,8 @@

 			// Send a trigger signal to the ECal
 			HPSEcalReadoutDriver.triggerBit = true;
 			ecalTriggerTimestamps.remove();

+
+

 		}
 	}
 

diff -N TestRunTriggeredReconToEvio.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ TestRunTriggeredReconToEvio.java	4 Apr 2012 20:43:37 -0000	1.1
@@ -0,0 +1,325 @@

+package org.lcsim.hps.evio;
+
+import static org.lcsim.hps.evio.EventConstants.ECAL_BANK_NUMBER;
+import static org.lcsim.hps.evio.EventConstants.ECAL_BOTTOM_BANK_TAG;
+import static org.lcsim.hps.evio.EventConstants.ECAL_CHANNEL_OFFSET;
+import static org.lcsim.hps.evio.EventConstants.ECAL_PULSE_INTEGRAL_FORMAT;
+import static org.lcsim.hps.evio.EventConstants.ECAL_PULSE_INTEGRAL_BANK_TAG;
+import static org.lcsim.hps.evio.EventConstants.ECAL_TOP_BANK_TAG;
+import static org.lcsim.hps.evio.EventConstants.SVT_BANK_NUMBER;
+import static org.lcsim.hps.evio.EventConstants.SVT_BANK_TAG;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import java.util.Queue;
+import org.jlab.coda.jevio.CompositeData;
+import org.jlab.coda.jevio.DataType;
+import org.jlab.coda.jevio.EventBuilder;
+import org.jlab.coda.jevio.EventWriter;
+import org.jlab.coda.jevio.EvioBank;
+import org.jlab.coda.jevio.EvioException;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.EventHeader.LCMetaData;
+import org.lcsim.event.RawCalorimeterHit;
+import org.lcsim.geometry.IDDecoder;
+import org.lcsim.hps.recon.tracking.HPSSVTData;
+import org.lcsim.util.Driver;
+
+/**
+ * This class takes raw data generated from MC and converts
+ * it to EVIO.  The goal is to make this look like data
+ * which will come off the actual ET ring during the 
+ * test run.
+ * 
+ * @author Jeremy McCormick <[log in to unmask]>
+ */
+public class TestRunTriggeredReconToEvio extends Driver {
+
+	EventWriter writer;
+	String rawCalorimeterHitCollectionName = "EcalReadoutHits";
+	String svtCollectionName = "SVTData";
+	String evioOutputFile = "TestRunData.evio";
+	Queue<QueuedEtEvent> builderQueue = null;
+	private int eventsWritten = 0;
+	public static boolean triggerBit = false;
+
+	public TestRunTriggeredReconToEvio() {
+	}
+
+	public void setEvioOutputFile(String evioOutputFile) {
+		this.evioOutputFile = evioOutputFile;
+	}
+
+	public void setSVTDataCollectionName(String svtCollectionName) {
+		this.svtCollectionName = svtCollectionName;
+	}
+
+	public void setRawCalorimeterHitCollectionName(String rawCalorimeterHitCollectionName) {
+		this.rawCalorimeterHitCollectionName = rawCalorimeterHitCollectionName;
+	}
+
+	protected void startOfData() {
+		try {
+			writer = new EventWriter(evioOutputFile);
+		} catch (EvioException e) {
+			throw new RuntimeException(e);
+		}
+		builderQueue = new LinkedList<QueuedEtEvent>();
+	}
+
+	protected void endOfData() {
+		System.out.println(this.getClass().getSimpleName() + " - wrote " + eventsWritten + " EVIO events in job.");
+		try {
+			writer.close();
+		} catch (EvioException e) {
+			throw new RuntimeException(e);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	protected void process(EventHeader event) {
+		if (triggerBit) {
+			// Make a new EVIO event.
+			EventBuilder builder = new EventBuilder(0, DataType.BANK, event.getEventNumber());
+			builderQueue.add(new QueuedEtEvent(builder));
+			triggerBit = false;
+		}
+
+		List<List<HPSSVTData>> svtDataList = event.get(HPSSVTData.class);
+		if (svtDataList != null && svtDataList.size() > 0 && svtDataList.get(0) != null) {
+			System.out.println("try to write SVT data, event " + event.getEventNumber());
+			EventBuilder builder = null;
+
+			for (QueuedEtEvent queuedEvent : builderQueue) {
+				if (!queuedEvent.readSVT) {
+					builder = queuedEvent.getBuilder();
+					queuedEvent.readSVT = true;
+					break;
+				}
+			}
+			if (builder == null) {
+				throw new RuntimeException("no queued ET events waiting for an SVT bank");
+			}
+			// Write SVTData.
+			writeSVTData(event, builder);
+		}
+		
+		if (event.hasCollection(RawCalorimeterHit.class, rawCalorimeterHitCollectionName)) {
+			System.out.println("try to write ECal data, event " + event.getEventNumber());
+			EventBuilder builder = null;
+			for (QueuedEtEvent queuedEvent : builderQueue) {
+				if (!queuedEvent.readECal) {
+					builder = queuedEvent.getBuilder();
+					queuedEvent.readECal = true;
+					break;
+				}
+			}
+			if (builder == null) {
+				throw new RuntimeException("no queued ET events waiting for ECal banks");
+			}
+			// Write RawCalorimeterHit collection.
+			writeRawCalorimeterHits(event, builder);
+		}
+
+		while (!builderQueue.isEmpty() && builderQueue.peek().banksFilled()) {
+			System.out.println("writing filled ET event, event " + event.getEventNumber());
+			EventBuilder builder = builderQueue.poll().getBuilder();
+			// Write this EVIO event.
+			writeEvioEvent(builder);
+		}
+	}
+
+	private void writeEvioEvent(EventBuilder builder) {
+		builder.setAllHeaderLengths();
+		try {
+			writer.writeEvent(builder.getEvent());
+			++eventsWritten;
+		} catch (EvioException e) {
+			throw new RuntimeException(e);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private void writeRawCalorimeterHits(EventHeader event, EventBuilder builder) {
+		List<RawCalorimeterHit> rawCalorimeterHits = event.get(RawCalorimeterHit.class, rawCalorimeterHitCollectionName);
+		LCMetaData meta = event.getMetaData(rawCalorimeterHits);
+		writeRawCalorimeterHits(meta, rawCalorimeterHits, builder);
+		System.out.println("Writing ECal data, event " + event.getEventNumber());
+	}
+
+	private void writeSVTData(EventHeader event, EventBuilder builder) {
+		List<List<HPSSVTData>> svtDataList = event.get(HPSSVTData.class);
+		if (svtDataList != null) {
+			if (svtDataList.size() > 0) {
+				if (svtDataList.get(0) != null) {
+					this.writeSVTData(svtDataList.get(0), builder);
+					System.out.println("Writing SVT data, event " + event.getEventNumber());
+				}
+			}
+		}
+	}
+
+	private void writeSVTData(List<HPSSVTData> data, EventBuilder builder) {
+		if (data == null) {
+			throw new RuntimeException("The list points to null.");
+		}
+
+		int nsamples = data.size();
+		int evioIntData[] = new int[nsamples * 4];
+
+		int i = 0;
+		for (HPSSVTData sample : data) {
+			int[] sampleData = sample.getData();
+			//System.out.println(Integer.toHexString(sampleData[0]) + ":" + Integer.toHexString(sampleData[1])+ ":" + Integer.toHexString(sampleData[2])+ ":" + Integer.toHexString(sampleData[3]));
+			evioIntData[i] = sampleData[0];
+			evioIntData[i + 1] = sampleData[1];
+			evioIntData[i + 2] = sampleData[2];
+			evioIntData[i + 3] = sampleData[3];
+			i += 4;
+		}
+		EvioBank bank = new EvioBank(SVT_BANK_TAG, DataType.UINT32, SVT_BANK_NUMBER);
+		try {
+			bank.appendIntData(evioIntData);
+		} catch (EvioException e) {
+			throw new RuntimeException(e);
+		}
+		bank.setAllHeaderLengths();
+		try {
+			builder.addChild(builder.getEvent(), bank);
+		} catch (EvioException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private void writeRawCalorimeterHitCollection(List<RawCalorimeterHit> hits, LCMetaData meta, int bankTag, EventBuilder builder) {
+		// Get the ID decoder.
+		IDDecoder dec = meta.getIDDecoder();
+
+		// Make a hit map; allow for multiple hits in a crystal.
+		Map<Long, List<RawCalorimeterHit>> hitMap = new HashMap<Long, List<RawCalorimeterHit>>();
+		for (RawCalorimeterHit hit : hits) {
+			if (hitMap.get(hit.getCellID()) == null) {
+				hitMap.put(hit.getCellID(), new ArrayList<RawCalorimeterHit>());
+			}
+			List<RawCalorimeterHit> channelHits = hitMap.get(hit.getCellID());
+			channelHits.add(hit);
+		}
+
+		// Make map of slot number to hit IDs.
+		Map<Integer, List<Long>> slotMap = new HashMap<Integer, List<Long>>();
+		for (Long id : hitMap.keySet()) {
+			dec.setID(id);
+			int iy = dec.getValue("iy"); // treating as slot number    		
+			int slot = Math.abs(iy);
+			if (slotMap.get(slot) == null) {
+				slotMap.put(slot, new ArrayList<Long>());
+			}
+			List<Long> slots = slotMap.get(slot);
+			slots.add(id);
+		}
+
+		// Make a new bank for this crate.
+		EvioBank crateBank = new EvioBank(bankTag, DataType.BANK, ECAL_BANK_NUMBER);
+
+		// Loop over the slots in the map.
+		for (int slot : slotMap.keySet()) {
+
+			// New bank for this slot.
+			EvioBank slotBank = new EvioBank(ECAL_PULSE_INTEGRAL_BANK_TAG, DataType.COMPOSITE, slot);
+
+			// Create composite data for this slot and its channels.
+			CompositeData.Data data = new CompositeData.Data();
+			data.addUchar((byte) slot); // slot #
+			data.addUint(0); // trigger #
+			data.addUlong(0); // timestamp    		
+			List<Long> hitIDs = slotMap.get(slot);
+			int nhits = hitIDs.size();
+			data.addN(nhits); // number of channels
+			for (Long id : hitIDs) {
+				dec.setID(id);
+				int ix = dec.getValue("ix");
+				int channel = ix + ECAL_CHANNEL_OFFSET;
+				data.addUchar((byte) channel); // channel #
+				List<RawCalorimeterHit> channelHits = hitMap.get(id);
+				data.addN(channelHits.size()); // number of pulses
+				for (RawCalorimeterHit hit : channelHits) {
+					data.addUshort((short) hit.getTimeStamp()); // pulse time
+					data.addUint((int) hit.getAmplitude()); // pulse integral
+				}
+			}
+
+			// Add CompositeData to bank.
+			CompositeData cdata = null;
+			try {
+				cdata = new CompositeData(ECAL_PULSE_INTEGRAL_FORMAT, 1, data, ECAL_PULSE_INTEGRAL_BANK_TAG, slot);
+				slotBank.appendCompositeData(cdata);
+			} catch (EvioException e) {
+				throw new RuntimeException(e);
+			}
+
+			// Add slot bank to crate bank.
+			slotBank.setAllHeaderLengths();
+			try {
+				builder.addChild(crateBank, slotBank);
+			} catch (EvioException e) {
+				throw new RuntimeException(e);
+			}
+		}
+		try {
+			crateBank.setAllHeaderLengths();
+			builder.addChild(builder.getEvent(), crateBank);
+		} catch (EvioException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private void writeRawCalorimeterHits(LCMetaData meta, List<RawCalorimeterHit> rawCalorimeterHits, EventBuilder builder) {
+		System.out.println("Writing " + rawCalorimeterHits.size() + " ECal hits");
+
+		// Make two lists containing the hits from top and bottom sections, which go into separate EVIO data banks.
+		IDDecoder dec = meta.getIDDecoder();
+		List<RawCalorimeterHit> topHits = new ArrayList<RawCalorimeterHit>();
+		List<RawCalorimeterHit> bottomHits = new ArrayList<RawCalorimeterHit>();
+		for (RawCalorimeterHit hit : rawCalorimeterHits) {
+			dec.setID(hit.getCellID());
+			int iy = dec.getValue("iy");
+			// Negative iy should be bottom section.
+			if (iy < 0) {
+				bottomHits.add(hit);
+			} // Positive iy should be top section.
+			else {
+				topHits.add(hit);
+			}
+		}
+
+		// Write the two collections for top and bottom hits to separate EVIO banks.
+		writeRawCalorimeterHitCollection(topHits, meta, ECAL_TOP_BANK_TAG, builder);
+		writeRawCalorimeterHitCollection(bottomHits, meta, ECAL_BOTTOM_BANK_TAG, builder);
+	}
+
+	private class QueuedEtEvent {
+
+		private EventBuilder builder;
+		public boolean readSVT = false;
+		public boolean readECal = false;
+
+		public QueuedEtEvent(EventBuilder builder) {
+			this.builder = builder;
+		}
+
+		public EventBuilder getBuilder() {
+			return builder;
+		}
+
+		public boolean banksFilled() {
+			return (readSVT && readECal);
+		}
+	}
+}

\ No newline at end of file