A framework for track cluster association
3/15/99 - Gary Bower
PREAMBLE
What follows lays out a framework of classes for an OO implementation of
Tracks, Clusters and TrackClusterAssociations. The basic assumption is that
there will be more than one way available to find tracks, build clusters and
associate them together. Further it is assumed that one may want to run
more than one of the finders, builders or associators in the same pass over
the data so the results of two different methods can be compared in detail.
In fact, the track finders, cluster builders and track-cluster associator methods
that are currently in the works or at least concretely envisioned are actually
given preliminary names below. Note that different methods to do a particular
task may use different kinds of inputs. This in embodied in the Java abstract
classes with an abstract method for find, build and associate.
At the end is some simple sample syntax to illustrate the usage of the classes.
The Classes a la Java:
(Caveat: since none of what follows has had the benefit of
a critic by a compiler it probably has many syntactical errors
so if it looks wrong it probably is.)
**********************************************************
TRACKING
public class TrackerHit
public class TrackerHitEnumeration
public class Track
// Track implements LorentzVector with mass initially set to pi mass.
// Track has error matix to measure "fuzziness"
public class TrackEnumeration
public Interface ITrackFinder
void find()
Track[] getTracks()
public class AbstractTrackFinder implements ITrackFinder
abstract void find()
private Track[] m_track;
Track[] getTracks()
public class MCTrackFinder extends AbstractTrackFinder
// This is the FastMC guy
void find( MCParticleEnumeration e )
private Track[] m_track;
Track[] getTracks()
public class RonanTrackFinder extends AbstractTrackFinder
// This is the Ronan/BaBar version
void find( TrackerHitEnumeration e )
private Track[] m_track;
Track[] getTracks()
*******************************************************
CLUSTERING
public class CalHit
public class Cluster
// Cluster implements LorentzVectors so the 4-momentum can be both read and set
// For example, you use an initial cluster builder and assume all clusters are mass 0
// Then you do track-cluster assoc and set the mass of the clusters with tracks to
pi mass
// Cluster also implements some kind of "fuzziness" descriptors comparable to the
// Track error matrix. It could be the first few moments in x-y and the r layer distribution
// of the cal hit energy distribution or both or more.
public class ClusterEnumeration
public Interface IClusterBuilder
void build()
Cluster[] getClusters()
public class AbstractClusterBuilder implements IClusterBuilder
abstract void build()
private Cluster[] m_cluster
public Cluster[] getClusters()
public class MCClusterBuilder extends AbstractClusterBuilder
// This is the FastMC version
private Cluster[] m_cluster
void build( mcParticleEnumeration e )
Cluster[] getClusters()
public class ContiguousClusterBuilder extends AbstractClusterBuilder
// This is the TonyJ version
private Cluster[] m_cluster
void build( calHitEnumeration e )
Cluster[] getClusters()
public class JRBClusterBuilder extends AbstractClusterBuilder
// This is the JRB version
private Cluster[] m_cluster
void build( calHitEnumeration e )
Cluster[] getCluster()
public class NeutralClusterBuilder extends AbstractClusterBuilder
// This guy starts with a previously determined cluster set and
// subtracts out the clusters due to charged tracks
private Cluster[] m_cluster
void build( Track-Cluster Associator tc )
Cluster[] getCluster()
***********************************************************
TRACK-CLUSTER ASSOCIATION
public class TrackClusterDescriptor
Track t
Cluster c
double quality() // overall measure of the association
double cosThNsig() // costheta difference error
double phiNSig() // phi difference error
double pInvNSig() // momentum difference error
public Interface ITrack-Cluster Associator
void associate( TrackEnumeration t, ClusterEnumeration c )
double quality( Track t, Cluster c )
double cosThNsig( Track t, Cluster c )
double phiNSig( Track t, Cluster c )
double pInvNSig( Track t, Cluster c )
Cluster[] assocClus( Track t ) // all clusters associated with t
Track[] assocTrack( Cluster c ) // all tracks associated with c
(question: can array be of length 0? ie how to handle tracks and clusters that have no associations.)
public abstract class AbstractTrackClusterAssociator implements ITrackClusterAssociation
abstract void associate( TrackEnumeration t, ClusterEnumeration c )
private TrackClusterDescriptor[][] m_assoc
double quality( Track t, Cluster c )
double cosThNsig( Track t, Cluster c )
double phiNSig( Track t, Cluster c )
double pInvNSig( Track t, Cluster c )
Cluster[] assocClus( Track t )
Track[] assocTrack( Cluster c )
public class CheaterTrackClusterAssociator extends AbstractTrackClusterAssociation
// This guy use the MC truth to determine the associations but note that t and c
// can be from any trackfinder or clusterbuilder
void associate( TrackEnumeration t, ClusterEnumeration c )
etc
public class RonanTrackClusterAssociator extends AbstractTrackClusterAssociation
// This guy uses the version Mike has written based on track extrapolation
// and again probably t and c can be from any trackfinder or clusterbuilder
void associate( TrackEnumeration t, ClusterEnumeration c )
etc
public class CompleteTrackClusterAssociator extends AbstractTrackClusterAssociation
// This guy makes no cuts, he calculates the qualities and various nsigs for every
// track and cluster pair. The user gets to make the cuts. Again probably
// the result of any method of track finding and cluster building can be used.
void associate( TrackEnumeration t, ClusterEnumeration c )
etc
*************************************************************
USAGE:
typical syntax:
c is a cluster
t is a track
tc is an xxxTrackClusterAssociator
tc.track(c) is an array of tracks associated by tc with cluster c
tc.track(c)[i]is the ith track associated with cluster c by tc
tc.track(c)[i].quality is the quality of the association between c and the ith track associated with it.
tc.track(c)[i].cosThNSig is the error in CosTheta of the t-c association
tc.cluster(t).[j].phiNSig is the error in Phi between t and the jth cluster associated with it.
sample crude psudeo-code for the neutral cluster builder:
cb is a cluster builder, tf is a track finder.
ca[] = cb.getCluster() //ca stands for cluster array
ta[] = tf.getTracks() // ta stands for track array
cnew[] = new Cluster[] // the new neutral cluster array
int j = 0 // the index for cnew
tc = new xxxTrackClusterAssociator //xxx = pick your favorite associator
tc.associate( ta, ca ) // do the association, array inherits from enumeration so args are ok
for i = 1 to ca.#elements // loop over initial cluster set
if tc.track(ca[i]).#elements = 0 // if no track is associated with the ith cluster
cnew[j] = ca[i] // then put it on the list of new clusters as the jth element
j++
-----------------------------------
Gary Bower ([log in to unmask])
Stanford Linear Accelerator Center
Stanford University
650/926-2460
|