Author: [log in to unmask]
Date: Wed Dec 2 18:35:34 2015
New Revision: 4002
Log:
changes to V0 filter
Modified:
java/trunk/recon/src/main/java/org/hps/recon/filtering/V0CandidateFilter.java
java/trunk/tracking/src/main/java/org/hps/recon/tracking/TrackData.java
java/trunk/tracking/src/main/java/org/hps/recon/tracking/TrackUtils.java
Modified: java/trunk/recon/src/main/java/org/hps/recon/filtering/V0CandidateFilter.java
=============================================================================
--- java/trunk/recon/src/main/java/org/hps/recon/filtering/V0CandidateFilter.java (original)
+++ java/trunk/recon/src/main/java/org/hps/recon/filtering/V0CandidateFilter.java Wed Dec 2 18:35:34 2015
@@ -4,15 +4,22 @@
import java.util.List;
import org.hps.recon.ecal.cluster.ClusterUtilities;
import org.hps.recon.particle.ReconParticleDriver;
+import org.hps.recon.tracking.TrackData;
+import org.hps.recon.tracking.TrackType;
import org.hps.record.epics.EpicsData;
+import org.hps.record.scalers.ScalerData;
import org.lcsim.event.EventHeader;
import org.lcsim.event.ReconstructedParticle;
/**
* Class to strip off trident candidates. Currently defined as: e+ e- events
- * with tracks. If the tight constraint is enabled, tracks must be matched to
- * clusters and the Ecal cluster times must be within _timingCut [2.5ns] of each
- * other.
+ * with tracks; track and vertex chi2 must be better than values defined by
+ * cuts, and track times must be within trackDtCut of each other. If the tight
+ * constraint is enabled, tracks must be matched to clusters, the Ecal cluster
+ * times must be within _timingCut [2.5ns] of each other, and there must be
+ * exactly one V0 passing all cuts.
+ *
+ * Only GBL vertices are considered.
*
* @author Norman A Graf
*
@@ -20,8 +27,11 @@
*/
public class V0CandidateFilter extends EventReconFilter {
- private String _V0CandidateCollectionName = "TargetConstrainedV0Candidates";
+ private String _V0CandidateCollectionName = "UnconstrainedV0Candidates";
private double _clusterTimingCut = 2.5;
+ private double v0Chi2Cut = 10.0;
+ private double trackChi2Cut = 20.0;
+ private double trackDtCut = 5.0;
private boolean _tight = false;
private boolean _keepEpicsDataEvents = false;
@@ -30,9 +40,15 @@
protected void process(EventHeader event) {
incrementEventProcessed();
if (_keepEpicsDataEvents) {
- // don't drop any events with EPICS data:
- final EpicsData data = EpicsData.read(event);
- if (data != null) {
+ // don't drop any events with EPICS or scaler data:
+ final EpicsData epicsData = EpicsData.read(event);
+ if (epicsData != null) {
+ incrementEventPassed();
+ return;
+ }
+
+ final ScalerData scalerData = ScalerData.read(event);
+ if (scalerData != null) {
incrementEventPassed();
return;
}
@@ -41,45 +57,76 @@
skipEvent();
}
List<ReconstructedParticle> V0Candidates = event.get(ReconstructedParticle.class, _V0CandidateCollectionName);
- if (V0Candidates.isEmpty()) {
- skipEvent();
- }
+ int nV0 = 0; //number of good V0
+ for (ReconstructedParticle v0 : V0Candidates) {
+ ReconstructedParticle electron = v0.getParticles().get(ReconParticleDriver.ELECTRON);
+ ReconstructedParticle positron = v0.getParticles().get(ReconParticleDriver.POSITRON);
- // tight requires ONLY ONE real vertex fit
- if (_tight) {
- if (V0Candidates.size() != 2) {
- skipEvent();
+ if (!TrackType.isGBL(v0.getType())) { //we only care about GBL vertices
+ continue;
}
- for (ReconstructedParticle rp : V0Candidates) {
-
- ReconstructedParticle electron;
- ReconstructedParticle positron;
-
- List<ReconstructedParticle> fsParticles = rp.getParticles();
- if (fsParticles.size() != 2) {
- skipEvent();
+ if (v0.getStartVertex().getChi2() > v0Chi2Cut) {
+ continue;
+ }
+ if (electron.getTracks().get(0).getChi2() > trackChi2Cut || positron.getTracks().get(0).getChi2() > trackChi2Cut) {
+ continue;
+ }
+ double eleTime = TrackData.getTrackTime(TrackData.getTrackData(event, electron.getTracks().get(0)));
+ double posTime = TrackData.getTrackTime(TrackData.getTrackData(event, positron.getTracks().get(0)));
+ if (Math.abs(eleTime - posTime) > trackDtCut) {
+ continue;
+ }
+ if (_tight) { // tight requires cluster matches and cluster time cut
+ if (electron.getClusters().isEmpty() || positron.getClusters().isEmpty()) {
+ continue;
}
- // require both electrons to be associated with an ECal cluster
- electron = fsParticles.get(ReconParticleDriver.ELECTRON);
- if (electron.getClusters().isEmpty()) {
- skipEvent();
- }
- positron = fsParticles.get(ReconParticleDriver.POSITRON);
- if (positron.getClusters().isEmpty()) {
- skipEvent();
- }
-
// calorimeter cluster timing cut
// first CalorimeterHit in the list is the seed crystal
double t1 = ClusterUtilities.getSeedHitTime(electron.getClusters().get(0));
double t2 = ClusterUtilities.getSeedHitTime(positron.getClusters().get(0));
if (abs(t1 - t2) > _clusterTimingCut) {
- skipEvent();
+ continue;
}
}
+ nV0++;
+ }
+ if (nV0 == 0) {
+ skipEvent();
+ }
+ // tight requires ONLY ONE candidate vertex
+ if (_tight && nV0 != 1) {
+ skipEvent();
}
incrementEventPassed();
+ }
+
+ /**
+ * Maximum vertex chi2 for a V0 to be counted.
+ *
+ * @param v0Chi2Cut default of 10.0.
+ */
+ public void setV0Chi2Cut(double v0Chi2Cut) {
+ this.v0Chi2Cut = v0Chi2Cut;
+ }
+
+ /**
+ * Maximum track chi2 for a V0 to be counted. A V0 is rejected if either of
+ * the final state tracks has a chi2 exceeding the cut.
+ *
+ * @param trackChi2Cut default of 20.0.
+ */
+ public void setTrackChi2Cut(double trackChi2Cut) {
+ this.trackChi2Cut = trackChi2Cut;
+ }
+
+ /**
+ * Maximum track time different for a V0 to be counted.
+ *
+ * @param trackDtCut units of ns, default of 5.0
+ */
+ public void setTrackDtCut(double trackDtCut) {
+ this.trackDtCut = trackDtCut;
}
/**
Modified: java/trunk/tracking/src/main/java/org/hps/recon/tracking/TrackData.java
=============================================================================
--- java/trunk/tracking/src/main/java/org/hps/recon/tracking/TrackData.java (original)
+++ java/trunk/tracking/src/main/java/org/hps/recon/tracking/TrackData.java Wed Dec 2 18:35:34 2015
@@ -1,6 +1,13 @@
package org.hps.recon.tracking;
+import java.util.List;
+import org.apache.commons.math3.util.Pair;
+import org.lcsim.event.EventHeader;
import org.lcsim.event.GenericObject;
+import org.lcsim.event.LCRelation;
+import org.lcsim.event.RelationalTable;
+import org.lcsim.event.Track;
+import org.lcsim.event.base.BaseRelationalTable;
/**
* Generic object used to persist track data not available through a Track
@@ -155,4 +162,24 @@
public boolean isFixedSize() {
return true;
}
+
+ private static Pair<EventHeader, RelationalTable> trackDataToTrackCache = null;
+
+ public static RelationalTable getTrackDataToTrackTable(EventHeader event) {
+ if (trackDataToTrackCache == null || trackDataToTrackCache.getFirst() != event) {
+ RelationalTable trackDataToTrack = new BaseRelationalTable(RelationalTable.Mode.MANY_TO_MANY, RelationalTable.Weighting.UNWEIGHTED);
+ List<LCRelation> hitrelations = event.get(LCRelation.class, TRACK_DATA_RELATION_COLLECTION);
+ for (LCRelation relation : hitrelations) {
+ if (relation != null && relation.getFrom() != null && relation.getTo() != null) {
+ trackDataToTrack.add(relation.getFrom(), relation.getTo());
+ }
+ }
+ trackDataToTrackCache = new Pair<EventHeader, RelationalTable>(event, trackDataToTrack);
+ }
+ return trackDataToTrackCache.getSecond();
+ }
+
+ public static GenericObject getTrackData(EventHeader event, Track track) {
+ return (GenericObject) getTrackDataToTrackTable(event).from(track);
+ }
}
Modified: java/trunk/tracking/src/main/java/org/hps/recon/tracking/TrackUtils.java
=============================================================================
--- java/trunk/tracking/src/main/java/org/hps/recon/tracking/TrackUtils.java (original)
+++ java/trunk/tracking/src/main/java/org/hps/recon/tracking/TrackUtils.java Wed Dec 2 18:35:34 2015
@@ -1,19 +1,21 @@
package org.hps.recon.tracking;
+import hep.physics.matrix.SymmetricMatrix;
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Matrix;
+import hep.physics.vec.Hep3Vector;
+import hep.physics.vec.SpacePoint;
+import hep.physics.vec.VecOp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
-import hep.physics.matrix.SymmetricMatrix;
-import hep.physics.vec.BasicHep3Vector;
-import hep.physics.vec.Hep3Matrix;
-import hep.physics.vec.Hep3Vector;
-import hep.physics.vec.SpacePoint;
-import hep.physics.vec.VecOp;
-
+import org.apache.commons.math3.util.Pair;
+import org.hps.recon.tracking.EventQuality.Quality;
+import org.hps.recon.tracking.gbl.HelicalTrackStripGbl;
+import static org.lcsim.constants.Constants.fieldConversion;
import org.lcsim.detector.ITransform3D;
import org.lcsim.detector.solids.Box;
import org.lcsim.detector.solids.Point3D;
@@ -48,10 +50,6 @@
import org.lcsim.util.swim.Helix;
import org.lcsim.util.swim.Line;
import org.lcsim.util.swim.Trajectory;
-import org.hps.recon.tracking.EventQuality.Quality;
-import org.hps.recon.tracking.gbl.HelicalTrackStripGbl;
-
-import static org.lcsim.constants.Constants.fieldConversion;
/**
* Assorted helper functions for the track and helix objects in lcsim. Re-use as
@@ -984,24 +982,36 @@
return new HelicalTrackHit(pos, hitcov, dedx, time, type, rhits, detname, layer, beflag);
}
+ private static Pair<EventHeader, RelationalTable> hitToStripsCache = null;
+
public static RelationalTable getHitToStripsTable(EventHeader event) {
- RelationalTable hitToStrips = new BaseRelationalTable(RelationalTable.Mode.MANY_TO_MANY, RelationalTable.Weighting.UNWEIGHTED);
- List<LCRelation> hitrelations = event.get(LCRelation.class, "HelicalTrackHitRelations");
- for (LCRelation relation : hitrelations)
- if (relation != null && relation.getFrom() != null && relation.getTo() != null)
- hitToStrips.add(relation.getFrom(), relation.getTo());
-
- return hitToStrips;
- }
+ if (hitToStripsCache == null || hitToStripsCache.getFirst() != event) {
+ RelationalTable hitToStrips = new BaseRelationalTable(RelationalTable.Mode.MANY_TO_MANY, RelationalTable.Weighting.UNWEIGHTED);
+ List<LCRelation> hitrelations = event.get(LCRelation.class, "HelicalTrackHitRelations");
+ for (LCRelation relation : hitrelations) {
+ if (relation != null && relation.getFrom() != null && relation.getTo() != null) {
+ hitToStrips.add(relation.getFrom(), relation.getTo());
+ }
+ }
+ hitToStripsCache = new Pair<EventHeader, RelationalTable>(event, hitToStrips);
+ }
+ return hitToStripsCache.getSecond();
+ }
+
+ private static Pair<EventHeader, RelationalTable> hitToRotatedCache = null;
public static RelationalTable getHitToRotatedTable(EventHeader event) {
-
- RelationalTable hitToRotated = new BaseRelationalTable(RelationalTable.Mode.ONE_TO_ONE, RelationalTable.Weighting.UNWEIGHTED);
- List<LCRelation> rotaterelations = event.get(LCRelation.class, "RotatedHelicalTrackHitRelations");
- for (LCRelation relation : rotaterelations)
- if (relation != null && relation.getFrom() != null && relation.getTo() != null)
- hitToRotated.add(relation.getFrom(), relation.getTo());
- return hitToRotated;
+ if (hitToRotatedCache == null || hitToRotatedCache.getFirst() != event) {
+ RelationalTable hitToRotated = new BaseRelationalTable(RelationalTable.Mode.ONE_TO_ONE, RelationalTable.Weighting.UNWEIGHTED);
+ List<LCRelation> rotaterelations = event.get(LCRelation.class, "RotatedHelicalTrackHitRelations");
+ for (LCRelation relation : rotaterelations) {
+ if (relation != null && relation.getFrom() != null && relation.getTo() != null) {
+ hitToRotated.add(relation.getFrom(), relation.getTo());
+ }
+ }
+ hitToRotatedCache = new Pair<EventHeader, RelationalTable>(event, hitToRotated);
+ }
+ return hitToRotatedCache.getSecond();
}
public static double getTrackTime(Track track, RelationalTable hitToStrips, RelationalTable hitToRotated) {
|
