Author: [log in to unmask]
Date: Fri Feb 6 11:47:55 2015
New Revision: 2064
Log:
Removed indexing.
Modified:
java/trunk/users/src/main/java/org/hps/users/baltzell/ECalRunningPedestalDriver.java
java/trunk/users/src/main/java/org/hps/users/baltzell/EcalRawConverter_RunPed.java
Modified: java/trunk/users/src/main/java/org/hps/users/baltzell/ECalRunningPedestalDriver.java
=============================================================================
--- java/trunk/users/src/main/java/org/hps/users/baltzell/ECalRunningPedestalDriver.java (original)
+++ java/trunk/users/src/main/java/org/hps/users/baltzell/ECalRunningPedestalDriver.java Fri Feb 6 11:47:55 2015
@@ -7,7 +7,6 @@
import org.hps.conditions.database.TableConstants;
import org.hps.conditions.ecal.EcalChannel;
-import org.hps.conditions.ecal.EcalChannelConstants;
import org.hps.conditions.ecal.EcalConditions;
import org.hps.recon.ecal.HitExtraData;
import org.lcsim.conditions.ConditionsManager;
@@ -19,9 +18,10 @@
import org.lcsim.util.Driver;
/**
- * Calculate a running pedestal average for every channel from Mode7 FADCs.
+ * Calculate a running pedestal average for every channel from Mode7 FADCs. Uses
+ * pedestals from the database if not available from the data.
*
- * @version $Id: ECalRunningPedestalDriver.java,v 0.0 2015/01/31 00:00:00
+ * @version $Id: ECalRunningPedestalDriver.java,v 1.0 2015/02/06 00:00:00
* @author <[log in to unmask]>
*/
public class ECalRunningPedestalDriver extends Driver {
@@ -49,22 +49,16 @@
private final int nChannels = 442;
// running pedestal averages, one for each channel:
- private List<Double> runningPedestals = new ArrayList<Double>(nChannels);
-
- // FIXME:
+ private Map<EcalChannel, Double> runningPedestals = new HashMap<EcalChannel, Double>(nChannels);
+
// recent event-by-event pedestals and timestamps:
- private List<Integer>[] eventPedestals = (ArrayList<Integer>[]) new ArrayList[nChannels];
- private List<Long>[] eventTimestamps = (ArrayList<Long>[]) new ArrayList[nChannels];
+ private Map<EcalChannel, List<Integer>> eventPedestals = new HashMap<EcalChannel, List<Integer>>();
+ private Map<EcalChannel, List<Long>> eventTimestamps = new HashMap<EcalChannel, List<Long>>();
private boolean debug = false;
private EcalConditions ecalConditions = null;
public ECalRunningPedestalDriver() {
- for (int ii = 0; ii < nChannels; ii++) {
- eventPedestals[ii] = new ArrayList<>();
- eventTimestamps[ii] = new ArrayList<>();
- runningPedestals.add(-1.);
- }
}
@Override
@@ -77,7 +71,10 @@
.getCachedConditions(EcalConditions.class,TableConstants.ECAL_CONDITIONS)
.getCachedData();
for (int ii = 0; ii < nChannels; ii++) {
- runningPedestals.set(ii,getStaticPedestal(ii + 1));
+ EcalChannel chan = findChannel(ii + 1);
+ runningPedestals.put(chan,getStaticPedestal(chan));
+ eventPedestals.put(chan,new ArrayList<Integer>());
+ eventTimestamps.put(chan,new ArrayList<Long>());
}
if (debug) {
System.out.println("Running and static pedestals better match here:");
@@ -109,9 +106,14 @@
}
public void printPedestals() {
- for (int ii = 0; ii < nChannels; ii++) {
- System.out.printf("(%d,%.2f,%.2f) ",ii,runningPedestals.get(ii),
- getStaticPedestal(ii + 1));
+ for (int ii = 1; ii <= nChannels; ii++) {
+ EcalChannel chan = findChannel(ii);
+ if (!runningPedestals.containsKey(chan)) {
+ System.err.println("printPedestals: Missing Channel: " + ii);
+ continue;
+ }
+ System.out.printf("(%d,%.2f,%.2f) ",chan.getChannelId(),runningPedestals.get(chan),
+ getStaticPedestal(chan));
}
System.out.printf("\n");
}
@@ -119,32 +121,22 @@
@Override
protected void process(EventHeader event) {
- if (!event.hasCollection(RawCalorimeterHit.class,rawCollectionName))
- return;
- if (!event.hasCollection(LCRelation.class,extraDataRelationsName))
- return;
-
- Map<RawCalorimeterHit, Double> pedMap = new HashMap<RawCalorimeterHit, Double>();
-
- for (LCRelation rel : event.get(LCRelation.class,extraDataRelationsName)) {
- RawCalorimeterHit hit = (RawCalorimeterHit) rel.getFrom();
- GenericObject extraData = (GenericObject) rel.getTo();
- updatePedestal(event,hit,extraData);
- if (!pedMap.containsKey(hit))
- pedMap.put(hit,getPedestal(hit));
- }
- event.put(runningPedestalsName,pedMap);
+ if (!event.hasCollection(RawCalorimeterHit.class,rawCollectionName)) {
+ if (!event.hasCollection(LCRelation.class,extraDataRelationsName)) {
+ for (LCRelation rel : event.get(LCRelation.class,extraDataRelationsName)) {
+ RawCalorimeterHit hit = (RawCalorimeterHit) rel.getFrom();
+ GenericObject extraData = (GenericObject) rel.getTo();
+ updatePedestal(event,hit,extraData);
+ }
+ }
+ }
+ event.put(runningPedestalsName,runningPedestals);
if (debug) {
printPedestals();
}
}
private void updatePedestal(EventHeader event, RawCalorimeterHit hit, GenericObject mode7data) {
- final int ii = getChannelID(hit) - 1;
- if (ii < 0 || ii >= nChannels) {
- System.err.println(String.format("Event #%d, Invalid id: %d/%d ",
- event.getEventNumber(),ii + 1,+hit.getCellID()));
- }
final long timestamp = event.getTimeStamp();
final int min = ((HitExtraData.Mode7Data) mode7data).getAmplLow();
@@ -154,35 +146,43 @@
if (max <= 0)
return;
+ EcalChannel chan = findChannel(hit);
+ if (chan == null) {
+ System.err.println("hit doesn't correspond to ecalchannel");
+ return;
+ }
+ List<Integer> peds = eventPedestals.get(chan);
+ List<Long> times = eventTimestamps.get(chan);
+
// If new timestamp is older than previous one, restart pedestals.
// This should never happen unless firmware counter cycles back to zero,
// in which case it could be dealt with if max timestamp is known.
- if (eventTimestamps[ii].size() > 0 && eventTimestamps[ii].get(0) > timestamp) {
+ if (times.size() > 0 && times.get(0) > timestamp) {
System.err.println(String.format("Event #%d, Old Timestamp: %d < %d",
- event.getEventNumber(),timestamp,eventTimestamps[ii].get(0)));
- eventPedestals[ii].clear();
- eventTimestamps[ii].clear();
+ event.getEventNumber(),timestamp,times.get(0)));
+ peds.clear();
+ times.clear();
}
// add pedestal to the list:
- eventPedestals[ii].add(min);
- eventTimestamps[ii].add(timestamp);
-
- if (eventPedestals[ii].size() > 1) {
+ peds.add(min);
+ times.add(timestamp);
+
+ if (peds.size() > 1) {
// remove oldest pedestal if surpassed limit on #events:
- if (eventPedestals[ii].size() > limitLookbackEvents
- || (maxLookbackEvents > 0 && eventPedestals[ii].size() > maxLookbackEvents)) {
- eventPedestals[ii].remove(0);
- eventTimestamps[ii].remove(0);
+ if (peds.size() > limitLookbackEvents
+ || (maxLookbackEvents > 0 && peds.size() > maxLookbackEvents)) {
+ peds.remove(0);
+ times.remove(0);
}
// remove old pedestals surpassing limit on lookback time:
if (maxLookbackTime > 0) {
- while (eventTimestamps[ii].size() > 0) {
- if (eventTimestamps[ii].get(0) < timestamp - maxLookbackTime * 1e6) {
- eventTimestamps[ii].remove(0);
- eventPedestals[ii].remove(0);
+ while (times.size() > 1) {
+ if (times.get(0) < timestamp - maxLookbackTime * 1e6) {
+ times.remove(0);
+ peds.remove(0);
} else {
break;
}
@@ -191,44 +191,73 @@
}
// Update running pedestal average:
- if (eventPedestals[ii].size() >= minLookbackEvents) {
- double avg = 0;
- for (int jj = 0; jj < eventPedestals[ii].size(); jj++) {
- avg += eventPedestals[ii].get(jj);
- }
- runningPedestals.set(ii,avg / eventPedestals[ii].size());
+ double ped = 0;
+ if (peds.size() >= minLookbackEvents) {
+ for (int jj = 0; jj < peds.size(); jj++) {
+ ped += peds.get(jj);
+ }
+ ped /= peds.size();
} else {
- runningPedestals.set(ii,getStaticPedestal(ii + 1));
- }
- }
-
- public double getPedestal(int channel_id) {
- return runningPedestals.get(channel_id - 1);
- // final int nped = eventPedestals[channel_id - 1].size();
- // if (nped < minLookbackEvents) return getStaticPedestal(channel_id);
- // else return runningPedestals.get(channel_id - 1);
- }
-
- public double getPedestal(RawCalorimeterHit hit) {
- return getPedestal(getChannelID(hit));
- }
-
- private double getStaticPedestal(int channel_id) {
- EcalChannel cc = ecalConditions.getChannelCollection().findChannel(channel_id);
- return ecalConditions.getChannelConstants(cc).getCalibration().getPedestal();
- }
-
- private double getStaticPedestal(RawCalorimeterHit hit) {
- return getStaticPedestal(getChannelID(hit));
- }
-
- public int getChannelID(RawCalorimeterHit hit) {
- return findChannel(hit.getCellID()).getCalibration().getChannelId();
- }
-
- public EcalChannelConstants findChannel(long cellID) {
- return ecalConditions.getChannelConstants(ecalConditions.getChannelCollection()
- .findGeometric(cellID));
- }
+ ped = getStaticPedestal(chan);
+ }
+ runningPedestals.put(chan,ped);
+
+ }
+
+ public double getStaticPedestal(EcalChannel chan) {
+ return ecalConditions.getChannelConstants(chan).getCalibration().getPedestal();
+ }
+
+ public EcalChannel findChannel(int channel_id) {
+ return ecalConditions.getChannelCollection().findChannel(channel_id);
+ }
+
+ public EcalChannel findChannel(RawCalorimeterHit hit) {
+ return ecalConditions.getChannelCollection().findGeometric(hit.getCellID());
+ }
+
+ /*
+ * public double getPedestal(EcalChannel chan) { if
+ * (runningPedestals.containsKey(chan)) { return runningPedestals.get(chan);
+ * } else {
+ * System.err.println("RunningPedestalDriver:getPedestal: Missing channel"
+ * ); return getStaticPedestal(chan); } } public double getPedestal(int
+ * channel_id) { return getPedestal(findChannel(channel_id)); } public
+ * double getPedestal(RawCalorimeterHit hit) { return
+ * getPedestal(getChannelID(hit)); }
+ *
+ * private double getStaticNoise(int channel_id) { return
+ * getStaticCalibration(channel_id).getNoise(); }
+ *
+ * private double getStaticPedestal(int channel_id) { return
+ * getStaticCalibration(channel_id).getPedestal(); } private double
+ * getStaticPedestal(RawCalorimeterHit hit) { return
+ * getStaticPedestal(getChannelID(hit)); }
+ *
+ * private EcalCalibration getStaticCalibration(EcalChannel chan) { return
+ * ecalConditions.getChannelConstants(chan).getCalibration(); } private
+ * EcalCalibration getStaticCalibration(int channel_id) { return
+ * getStaticCalibration(findChannel(channel_id)); } private EcalCalibration
+ * getStaticCalibration(long cellID) { return
+ * getStaticCalibration(findChannel(cellID)); }
+ *
+ * public int getChannelID(RawCalorimeterHit hit) { return
+ * findChannelConstants(hit.getCellID()).getCalibration().getChannelId(); }
+ *
+ * public EcalChannelConstants findChannelConstants(long cellID) { return
+ * ecalConditions.getChannelConstants(findChannel(cellID)); }
+ *
+ * public EcalChannelConstants findChannelConstants(int channel_id) { return
+ * ecalConditions.getChannelConstants(findChannel(channel_id)); }
+ *
+ * public EcalChannel findChannel(long cellID) { return
+ * ecalConditions.getChannelCollection().findGeometric(cellID); }
+ *
+ * public EcalChannel findChannel(int channel_id) { return
+ * ecalConditions.getChannelCollection().findChannel(channel_id); }
+ *
+ * public EcalChannel findChannel(RawCalorimeterHit hit) { return
+ * findChannel(hit.getCellID()); }
+ */
}
Modified: java/trunk/users/src/main/java/org/hps/users/baltzell/EcalRawConverter_RunPed.java
=============================================================================
--- java/trunk/users/src/main/java/org/hps/users/baltzell/EcalRawConverter_RunPed.java (original)
+++ java/trunk/users/src/main/java/org/hps/users/baltzell/EcalRawConverter_RunPed.java Fri Feb 6 11:47:55 2015
@@ -4,7 +4,7 @@
import java.util.Map;
import org.hps.conditions.database.TableConstants;
-import org.hps.conditions.ecal.EcalCalibration;
+import org.hps.conditions.ecal.EcalChannel;
import org.hps.conditions.ecal.EcalChannelConstants;
import org.hps.conditions.ecal.EcalConditions;
import org.hps.recon.ecal.CalorimeterHitUtilities;
@@ -60,15 +60,24 @@
public double getPedestal(EventHeader event,RawCalorimeterHit hit)
{
if (useRunningPedestal) {
- if (event.hasCollection(Double.class,"EcalRunningPedestals")) {
- Map<RawCalorimeterHit, Double> runningPedMap=
- (Map<RawCalorimeterHit, Double>)
+ if (event.hasItem("EcalRunningPedestals")) {
+ Map<EcalChannel, Double> runningPedMap=
+ (Map<EcalChannel, Double>)
event.get("EcalRunningPedestals");
- if (!runningPedMap.containsKey(hit)){
- System.err.println("Missing Key Dog");
+ EcalChannel chan = ecalConditions.getChannelCollection().
+ findGeometric(hit.getCellID());
+ //System.err.println(" %%%%%%%%%%%%%%%%% "+chan.getChannelId()+" "+runningPedMap.get(chan));
+ if (!runningPedMap.containsKey(chan)){
+ System.err.println("************** Missing Pedestal");
} else {
- return runningPedMap.get(hit);
+ return runningPedMap.get(chan);
}
+ } else {
+ System.err.println("*****************************************************************");
+ System.err.println("** You Requested a Running Pedestal, but it is NOT available. **");
+ System.err.println("** Reverting to the database. Only printing this ONCE. **");
+ System.err.println("*****************************************************************");
+ useRunningPedestal = false;
}
}
return findChannel(hit.getCellID()).getCalibration().getPedestal();
|
