import org.lcsim.contrib.onoprien.util.job.Driver; import org.lcsim.contrib.onoprien.util.job.JobEvent; import org.lcsim.contrib.onoprien.util.job.JobEventListener; import org.lcsim.contrib.onoprien.util.job.JobManager; import org.lcsim.contrib.onoprien.util.swim.BField; import org.lcsim.contrib.onoprien.util.swim.Helix;

static private Comparator<Subdetector> _sdComparator = new Comparator<Subdetector>() { public int compare(Subdetector sd1, Subdetector sd2) { return sd1.getSystemID() - sd2.getSystemID(); } };

+ +// -- Default validator class : ----------------------------------------------- + + static protected class DefaultValidator extends CruxClusterValidator { + + public double getEnergy(CruxCluster cluster) { + throw new UnsupportedOperationException(); + } + + public ConstHep3Vector getPosition(CruxCluster cluster) { + BasicHep3Vector pos = new BasicHep3Vector(); + double weight = 0.; + for (CruxCluster cl : cluster._clusters) { + double w = cl.getEnergy(); + pos.add(cl._position, w); + weight += w; + } + for (CalorimeterHit hit : cluster._hits) { + double w = hit.getCorrectedEnergy(); + pos.add(hit.getPositionVec(), w); + weight += w; + } + if (weight == 0.) return ConstHep3Vector.V000; + return new ConstHep3Vector(pos.scale(1./weight)); + } + + public SymmetricMatrix getPositionError(CruxCluster cluster) { + throw new UnsupportedOperationException(); + } + + public double getITheta(CruxCluster cluster) { + throw new UnsupportedOperationException(); + } + + public double getIPhi(CruxCluster cluster) { + throw new UnsupportedOperationException(); + } + + public double[] getDirectionError(CruxCluster cluster) { + throw new UnsupportedOperationException(); + } + + public double[] getShape(CruxCluster cluster) { + throw new UnsupportedOperationException(); + } + }

+package org.lcsim.contrib.onoprien.crux.itc; + +import java.awt.Color; +import java.util.*; + +import hep.graphics.heprep.HepRepFactory; +import hep.graphics.heprep.HepRepInstance; +import hep.graphics.heprep.HepRepPoint; +import hep.graphics.heprep.HepRepType; +import hep.graphics.heprep.HepRepTypeTree; +import hep.graphics.heprep.HepRepInstanceTree; +import org.lcsim.event.CalorimeterHit; +import org.lcsim.event.EventHeader; +import org.lcsim.event.EventHeader.LCMetaData; +import org.lcsim.util.heprep.ColorMap; +import org.lcsim.util.heprep.HepRepCollectionConverter; +import org.lcsim.util.heprep.LCSimHepRepConverter; +import org.lcsim.util.heprep.RainbowColorMap; + +/** + * + * @author tonyj + * @version $Id: ClusterNodeHeprepConverter.java,v 1.1 2009/04/06 19:49:24 onoprien Exp $ + */ +class ClusterNodeHeprepConverter implements HepRepCollectionConverter { + + private Color[] colors; + + ClusterNodeHeprepConverter() { + ColorMap cm = new RainbowColorMap(); + colors = new Color[20]; + for (int i = 0; i < colors.length; i++) { + colors[i] = cm.getColor(((double) i) / colors.length, 1); + } + // Shuffle the elements in the array + Collections.shuffle(Arrays.asList(colors)); + } + + public boolean canHandle(Class k) { + return ClusterNode.class.isAssignableFrom(k); + } + + public void convert(EventHeader event, List collection, HepRepFactory factory, HepRepTypeTree typeTree, HepRepInstanceTree instanceTree) { + + LCMetaData meta = event.getMetaData(collection); + String name = meta.getName(); + int flags = meta.getFlags(); + + HepRepType typeX = factory.createHepRepType(typeTree, name); + typeX.addAttValue("layer", LCSimHepRepConverter.HITS_LAYER); + typeX.addAttValue("drawAs", "Point"); + typeX.addAttValue("color", Color.RED); + typeX.addAttValue("fill", true); + typeX.addAttValue("fillColor", Color.RED); + typeX.addAttValue("MarkName", "Box"); + typeX.addAttDef("hits", "Number of hits", "physics", ""); + + int i = 0; + + for (ClusterNode node : (List<ClusterNode>) collection) { + + Color clusterColor = colors[i]; + i = (i + 1) % colors.length; + double[] pos;// = rosary.getTrajectory().getPosition().v(); + HepRepInstance instanceC = factory.createHepRepInstance(instanceTree, typeX); + //HepRepPoint cp = factory.createHepRepPoint(instanceC, pos[0], pos[1], pos[2]); + + instanceC.addAttValue("drawAs", "Ellipsoid"); + + instanceC.addAttValue("Radius", 1); + instanceC.addAttValue("Radius2", 1); + instanceC.addAttValue("Radius3", 1); + + instanceC.addAttValue("hits", node.getHits().size()); + + instanceC.addAttValue("MarkName", "Star"); + instanceC.addAttValue("color", clusterColor); + instanceC.addAttValue("MarkSize", 10); + + List<CalorimeterHit> hits = node.getHits(); + for (CalorimeterHit hit : hits) { + // FixMe: What if hit doesn't have position? + double hitpos[] = null; + try { + hitpos = hit.getPosition(); + } catch (Exception x) { + } + + if (hitpos != null) { + pos = hit.getPosition(); + HepRepInstance instanceX = factory.createHepRepInstance(instanceC, typeX); + instanceX.addAttValue("energy", hit.getRawEnergy()); + instanceX.addAttValue("MarkSize", 5); + instanceX.addAttValue("color", (node.getType() == Node.Type.DOT) ? Color.RED : Color.BLUE); + instanceX.addAttValue("showparentattributes", true); + instanceX.addAttValue("pickparent", true); + HepRepPoint pp = factory.createHepRepPoint(instanceX, pos[0], pos[1], pos[2]); + } + } + + } + + } + +}

lcsim-contrib/src/main/java/org/lcsim/contrib/onoprien/crux/itc

Rosary.java 1.1 -> 1.2

diff -u -r1.1 -r1.2
--- Rosary.java	29 Mar 2009 23:44:19 -0000	1.1
+++ Rosary.java	6 Apr 2009 19:49:24 -0000	1.2
@@ -3,25 +3,28 @@

 import java.util.*;
 
 import hep.physics.vec.Hep3Vector;

-import org.lcsim.contrib.onoprien.util.swim.Trajectory;

-import org.lcsim.contrib.onoprien.crux.infrastructure.CruxCluster;
-import org.lcsim.contrib.onoprien.crux.infrastructure.CruxParticle;
-import org.lcsim.contrib.onoprien.crux.infrastructure.ITrack;

+import org.lcsim.contrib.onoprien.util.swim.Trajectory;

 
 import static org.lcsim.contrib.onoprien.crux.itc.Node.Type.*;
 
 /**
  * Class that represents a rosary cluster.
  * <p>

- * <tt>Rosary</tt> is a list of {@link Node}, indexed from head to tail. The reconstructed
- * particle is assumed to propagate from head to tail of a <tt>Rosary</tt>. 
- *

+ * <tt>Rosary</tt> is a list of {@link Node}, indexed from tail to head.
+ * <p>
+ * When the <tt>Rosary</tt> is being threaded, new nodes are added to the head. The
+ * hypothetic reconstructed particle propagation direction is assumed to be from
+ * tail to head if the threading direction is <tt>FORWARD</tt> (as returned by
+ * {@link #getThreadingDirection()}), and from head to tail if the threading direction
+ * is <tt>BACK</tt>. In a finished <tt>Rosary</tt> (threading direction is <tt>THREADED</tt>,
+ * the reconstructed particle is assumed to propagate from tail to head.

  *
  * @author D. Onoprienko

- * @version $Id: Rosary.java,v 1.1 2009/03/29 23:44:19 onoprien Exp $

+ * @version $Id: Rosary.java,v 1.2 2009/04/06 19:49:24 onoprien Exp $

*/

-public class Rosary extends CruxCluster {

+public class Rosary {
+//public class Rosary extends CruxCluster {

   
   public enum ThreadDirection {FORWARD, BACK, THREADED}

@@ -63,32 +66,45 @@

 
 // -- Getters :  ---------------------------------------------------------------

-  /** Returns the node at the specified position in this <tt>Rosary</tt>. */

+  /**
+   * Returns the node at the specified position in this <tt>Rosary</tt>.
+   * The <tt>Rosary</tt> is indexed from head to tail.
+   */

   public Node getNode(int index) {
     return _nodes.get(index);
   }

-  /** 
-   * Returns the first node in this <tt>Rosary</tt>.
-   * Returns <tt>null</tt> if this <tt>Rosary</tt> does not have any nodes.

+  /**
+   * Returns a list of nodes in this <tt>Rosary</tt> that belong to one of the specified types.
+   * The ordering is the same as in the Rosary (from tail to head).
+   * If no types are specified, all types of nodes are included.

*/

-  public Node getHeadNode() {
-    return (_nodes.isEmpty()) ? null : _nodes.get(0);

+  public List<Node> getNodes(Node.Type... types) {
+    if (types.length == 0) {
+      return Collections.unmodifiableList(_nodes);
+    } else {
+      EnumSet<Node.Type> set = EnumSet.copyOf(Arrays.asList(types));
+      ArrayList<Node> out = new ArrayList<Node>(_nodes.size());
+      for (Node node : _nodes) {
+        if (set.contains(node.getType())) {
+          out.add(node);
+        }
+      }
+      return out;
+    }

/**

-   * Returns the first node in this <tt>Rosary</tt> that belongs to one of the specified types.
-   * Returns <tt>null</tt> if this <tt>Rosary</tt> does not have nodes of these types.

+   * Returns the node closest to the tail of this <tt>Rosary</tt> that belongs to one of the specified types.
+   * Returns <tt>null</tt> if this <tt>Rosary</tt> does not have nodes of these types. If no types are
+   * specified, returns the node at the tail of this <tt>Rosary</tt>, regardless of its type.

*/

-  public Node getHeadNode(Node.Type type, Node.Type... types) {
-    ListIterator<Node> it = _nodes.listIterator();

+  public Node getTailNode(Node.Type... types) {

     if (types.length == 0) {

-      while (it.hasNext()) {
-        Node node = it.next();
-        if (node.getType() == type) return node;
-      }

+      return (_nodes.isEmpty()) ? null : _nodes.get(0);

     } else {

-      EnumSet<Node.Type> set = EnumSet.of(type, types);

+      ListIterator<Node> it = _nodes.listIterator();
+      EnumSet<Node.Type> set = EnumSet.copyOf(Arrays.asList(types));

       while (it.hasNext()) {
         Node node = it.next();
         if (set.contains(node.getType())) return node;

@@ -98,10 +114,11 @@

   }
 
   /**

-   * Returns fist <tt>numberOfNodes</tt> Nodes of one of the specified types, starting from the head of
-   * the Rosary. The ordering is the same as in the Rosary. If no types are specified, all types of nodes are included.

+   * Returns the first <tt>numberOfNodes</tt> nodes of one of the specified types, starting from
+   * the tail of this <tt>Rosary</tt>. The ordering is the same as in the <tt>Rosary</tt> (from tail to head).
+   * If no types are specified, all types of nodes are included.

*/

-  public ArrayList<Node> getHeadNodes(int numberOfNodes, Node.Type... types) {

+  public ArrayList<Node> getTailNodes(int numberOfNodes, Node.Type... types) {

     ArrayList<Node> out = new ArrayList<Node>(numberOfNodes);
     ListIterator<Node> it = _nodes.listIterator();
     if (types.length == 0) {

@@ -109,7 +126,7 @@

         out.add(it.next());
       }
     } else {

-      EnumSet<Node.Type> set = EnumSet.of(types[0], types);

+      EnumSet<Node.Type> set = EnumSet.copyOf(Arrays.asList(types));

       while (it.hasNext() && out.size() < numberOfNodes) {
         Node node = it.next();
         if (set.contains(node.getType())) out.add(node);

@@ -118,27 +135,18 @@

     return out;
   }

-  /** 
-   * Returns the last node in this <tt>Rosary</tt>.
-   * Returns <tt>null</tt> if this <tt>Rosary</tt> does not have any nodes.
-   */
-  public Node getTailNode() {
-    return (_nodes.isEmpty()) ? null : _nodes.get(_nodes.size()-1);
-  }
-  
-  /** 
-   * Returns the last node of one of the specified types in this <tt>Rosary</tt>.
-   * Returns <tt>null</tt> if this <tt>Rosary</tt> does not have nodes of the given types.

+  /**
+   * Returns the node closest to the head of this <tt>Rosary</tt> that belongs to one of the specified types.
+   * Returns <tt>null</tt> if this <tt>Rosary</tt> does not have nodes of these types. If no types are
+   * specified, returns the node at the head of this <tt>Rosary</tt> (last added, unless the
+   * threading direction has just been reversed), regardless of its type.

*/

-  public Node getTailNode(Node.Type type, Node.Type... types) {
-    ListIterator<Node> it = _nodes.listIterator(_nodes.size());

+  public Node getHeadNode(Node.Type... types) {

     if (types.length == 0) {

-      while (it.hasPrevious()) {
-        Node node = it.previous();
-        if (node.getType() == type) return node;
-      }

+      return (_nodes.isEmpty()) ? null : _nodes.get(_nodes.size()-1);

     } else {

-      EnumSet<Node.Type> set = EnumSet.of(type, types);

+      EnumSet<Node.Type> set = EnumSet.copyOf(Arrays.asList(types));
+      ListIterator<Node> it = _nodes.listIterator(_nodes.size());

       while (it.hasPrevious()) {
         Node node = it.previous();
         if (set.contains(node.getType())) return node;

@@ -148,19 +156,20 @@

   }
 
   /**

-   * Returns fist <tt>numberOfNodes</tt> Nodes of one of the specified types, starting from the tail of
-   * the Rosary. The ordering is the same as in the Rosary. If no types are specified, all types of nodes are included.

+   * Returns the first <tt>numberOfNodes</tt> nodes of one of the specified types, starting from
+   * the head of this <tt>Rosary</tt>. The ordering is the same as in the <tt>Rosary</tt> (from tail to head).
+   * If no types are specified, all types of nodes are included.

*/

-  public ArrayList<Node> getTailNodes(int numberOfNodes, Node.Type... types) {

+  public ArrayList<Node> getHeadNodes(int numberOfNodes, Node.Type... types) {

     ArrayList<Node> out = new ArrayList<Node>(numberOfNodes);
     ListIterator<Node> it = _nodes.listIterator(_nodes.size());
     if (types.length == 0) {

-      while (it.hasPrevious()) {

+      while (it.hasPrevious() && out.size() < numberOfNodes) {

         out.add(it.previous());
       }
     } else {

-      EnumSet<Node.Type> set = EnumSet.of(types[0], types);
-      while (it.hasPrevious()) {

+      EnumSet<Node.Type> set = EnumSet.copyOf(Arrays.asList(types));
+      while (it.hasPrevious() && out.size() < numberOfNodes) {

         Node node = it.previous();
         if (set.contains(node.getType())) out.add(node);
       }

@@ -196,28 +205,23 @@

     return iTail - iHead ;
   }

-  /** Returns the total number of nodes in this <tt>Rosary</tt>. */
-  public int getNodeCount() {
-    return _nodes.size();
-  }
-  
-  /** Returns the number of nodes that belong to one of the specified types in this <tt>Rosary</tt>. */
-  public int getNodeCount(Node.Type type, Node.Type... types) {
-    int out = 0;
-    ListIterator<Node> it = _nodes.listIterator();

+  /**
+   * Returns the number of nodes in this <tt>Rosary</tt> that belong to one of the specified types.
+   * If no types are specified, all nodes are counted.
+   */
+  public int getNodeCount(Node.Type... types) {

     if (types.length == 0) {

-      while (it.hasNext()) {
-        Node node = it.next();
-        if (node.getType() == type) out++ ;
-      }

+      return _nodes.size();

     } else {

-      EnumSet<Node.Type> set = EnumSet.of(type, types);

+      EnumSet<Node.Type> set = EnumSet.copyOf(Arrays.asList(types));
+      int out = 0;
+      ListIterator<Node> it = _nodes.listIterator();

       while (it.hasNext()) {
         Node node = it.next();
         if (set.contains(node.getType())) out++ ;
       }

+      return out;

-    return out;

   }
   
   /** Returns the number of {@link Crack} objects at the tail of this <tt>Rosary</tt>. */

@@ -235,7 +239,7 @@

   
 // -- Modifiers :  -------------------------------------------------------------

-  /** Sets threading direction property. */

+  /** Sets threading direction flag. */

   public void setThreadingDirection(ThreadDirection direction) {
     _threadDir = direction;
   }

@@ -246,14 +250,16 @@

   }
   
   /**

-   * Reverses propagation direction associated with this <tt>Rosary</tt>.

+   * Reverses hypothetic reconstructed particle propagation direction associated with
+   * this <tt>Rosary</tt>. The head of the rosary becomes its tail. The threading direction
+   * flag is not changed.

    */
   public void reverseDirection() {
     Collections.reverse(_nodes);
     _trajectory = null;
   }

-  /** Adds the node to the tail of this <tt>Rosary</tt>. */

+  /** Adds the node to the head of this <tt>Rosary</tt>. */

   public void addNode(Node node) {
     _nodes.add(node);
     node.getRosaries().add(this);

- for (Dot dot : layerData.dots) { - CruxCluster cluster = new CruxCluster(); - dots.add(cluster); - cluster.addHits(dot.getHits()); - } - for (Bead bead : layerData.beads) { - CruxCluster cluster = new CruxCluster(); - beads.add(cluster); - cluster.addHits(bead.getHits()); - }

- // TODO Change from fixed size to reflect true cluster dimensions. - instanceC.addAttValue("Radius", 5); - instanceC.addAttValue("Radius2", 5); - instanceC.addAttValue("Radius3", 20); - //TODO Change to use cluster direction instead of connecting origin to centroid. - double theta = point.theta(); - double phi = point.phi(); - instanceC.addAttValue("Phi", phi); - instanceC.addAttValue("Theta", theta);

+ + instanceC.addAttValue("Radius", 1); + instanceC.addAttValue("Radius2", 1); + instanceC.addAttValue("Radius3", 1); + + instanceC.addAttValue("dots", rosary.getNodeCount(Node.Type.DOT)); + instanceC.addAttValue("beads", rosary.getNodeCount(Node.Type.BEAD));

if (hitpos != null) { pos = hit.getPosition(); HepRepInstance instanceX = factory.createHepRepInstance(instanceC, typeX); instanceX.addAttValue("energy", hit.getRawEnergy()); instanceX.addAttValue("MarkSize", 5);

instanceX.addAttValue("showparentattributes", true); instanceX.addAttValue("pickparent", true); HepRepPoint pp = factory.createHepRepPoint(instanceX, pos[0], pos[1], pos[2]); } } }

+package org.lcsim.contrib.onoprien.crux.diagnostics; + +import java.util.*; + +import hep.physics.vec.Hep3Vector; +import org.lcsim.event.EventHeader; + +import org.lcsim.contrib.onoprien.util.constants.Units; +import org.lcsim.contrib.onoprien.util.job.Driver; +import org.lcsim.contrib.onoprien.util.job.JobEvent; +import org.lcsim.contrib.onoprien.util.job.JobEventListener; +import org.lcsim.contrib.onoprien.util.job.JobManager; +import org.lcsim.contrib.onoprien.util.swim.Trajectory; + +import org.lcsim.contrib.onoprien.crux.SiD02Geometry; +import org.lcsim.contrib.onoprien.crux.analysis.CheatTrackFinderDriver; +import org.lcsim.contrib.onoprien.crux.analysis.DefinitionCrux; +import org.lcsim.contrib.onoprien.crux.analysis.RecType; +import org.lcsim.contrib.onoprien.crux.geom.CalGeometry; +import org.lcsim.contrib.onoprien.crux.geom.CalLayer; +import org.lcsim.contrib.onoprien.crux.infrastructure.ITrack; +import org.lcsim.contrib.onoprien.crux.mctruth.MCTruthDriverCrux; +import org.lcsim.contrib.onoprien.crux.recon.CalorimeterDriver; + +/** + * + * + * @author D. Onoprienko + * @version $Id: PropagationTest.java,v 1.1 2009/04/06 19:49:24 onoprien Exp $ + */ +public class PropagationTest extends Driver implements JobEventListener { + +// -- Private parts : --------------------------------------------------------- + + CalGeometry _geom; + +// -- Constructors and initialization : --------------------------------------- + + public PropagationTest() { + + _geom = new SiD02Geometry(); + JobManager.defaultInstance().addListener(this, _geom); + + MCTruthDriverCrux mcTruthDriver = new MCTruthDriverCrux(); + mcTruthDriver.set("CALORIMETER_HITS", "CruxCalorimeterHits"); + add(mcTruthDriver); + + // Tracker hits processing --> "VSTrackerClusters" : + + add(new org.lcsim.contrib.onoprien.vsegment.ExampleDriverSiD02()); + + // Calorimeter hits processing --> "CruxCalorimeterHits" : + + CalorimeterDriver calDriver = new CalorimeterDriver(); + calDriver.set("INPUT_HITS", "EcalBarrDigiHits","EcalEndcapDigiHits","HcalBarrDigiHits","HcalEndcapDigiHits"); + calDriver.set("OUTPUT_HITS", "CruxCalorimeterHits"); + calDriver.set("GEOMETRY", _geom); + add(calDriver); + + // Track finder (cheater) --> "Tracks" : + + CheatTrackFinderDriver trackFinder = new CheatTrackFinderDriver(); + trackFinder.set("HIT_COLLECTIONS", "VSTrackerClusters"); + trackFinder.set("TRACK_LIST", "Tracks"); + + DefinitionCrux def = new DefinitionCrux("std"); + //def.setCut(RecType.TRACK, "CHARGED", true); + def.setCut(RecType.TRACK, "PT", .2*Units.GeV); + //def.setCut(RecType.TRACK, "MIN_TRACK_HIT_LAYERS", 3); + trackFinder.set("DEFINITION", def); + + add(trackFinder); + } + + public void detectorChanged(JobEvent jEvent) { + } + +// -- Event processing : ------------------------------------------------------ + + public void process(EventHeader event) { + + super.process(event); + + int iTrack = 0; + + List<ITrack> tracks = event.get(ITrack.class, "Tracks"); + for (ITrack track : tracks) { + ArrayList<Hep3Vector> points = new ArrayList<Hep3Vector>(); + String name = iTrack++ + track.getMCParticle().getType().getName(); + log("Track "+ name); + Trajectory traj = track.getTrajectory(ITrack.Point.START); + CalLayer layer = _geom.propagateFromTracker(traj); + while (layer != null) { + log(" New layer "+ layer); + points.add(traj.getPosition()); + layer = _geom.propagateToNextLayer(layer, traj); + } + event.put(name, points, Hep3Vector.class, 0); + } + + } + +}

+package org.lcsim.contrib.onoprien.crux.diagnostics; + +import java.util.*; + +import hep.aida.*; +import hep.physics.vec.Hep3Vector; +import org.lcsim.event.CalorimeterHit; +import org.lcsim.geometry.IDDecoder; +import org.lcsim.util.aida.AIDA; + +import org.lcsim.contrib.onoprien.util.job.JobManager; + +import org.lcsim.contrib.onoprien.crux.geom.CalLayer; +import org.lcsim.contrib.onoprien.crux.itc.Bead; +import org.lcsim.contrib.onoprien.crux.itc.Dot; +import org.lcsim.contrib.onoprien.crux.itc.LayerData; +import org.lcsim.contrib.onoprien.crux.itc.LayerDataBase; + +/** + * + * + * @author D. Onoprienko + * @version $Id: RosarySlicer.java,v 1.1 2009/04/06 19:49:24 onoprien Exp $ + */ +public class RosarySlicer { + +// -- Private parts : --------------------------------------------------------- + + private HashMap<CalLayer, Slice> _map; + +// -- Constructors and initialization : --------------------------------------- + +// -- Fill vector lists : ----------------------------------------------------- + + public void fillDotsBeads(LayerDataBase db) { + JobManager.defaultInstance().getAIDA().clearAll(); + _map = new HashMap<CalLayer, Slice>(); + for (LayerData data : db) { + Slice slice = new Slice(data.cruxLayer); + _map.put(data.cruxLayer, slice); + for (Dot dot : data.dots) { + for (CalorimeterHit hit : dot.getHits()) { + slice.dots.add(hit.getPositionVec()); + } + } + for (Bead bead : data.beads) { + for (CalorimeterHit hit : bead.getHits()) { + slice.beads.add(hit.getPositionVec()); + } + } + slice.decoder = data.decoder; + } + } + + public void fillTrajectory(Hep3Vector pos, CalLayer layer, boolean findCell) { + Slice slice = _map.get(layer); + slice.tPoints.add(pos); + if (findCell) { + long cellID = slice.decoder.findCellContainingXYZ(pos); + slice.decoder.setID(cellID); + slice.tCells.add(slice.decoder.getPositionVector()); + } + } + + +// -- Dumping data into AIDA : ------------------------------------------------ + + public void saveToAida() { + + AIDA aida = JobManager.defaultInstance().getAIDA(); + IAnalysisFactory af = aida.analysisFactory(); + ITree tree = aida.tree(); + IDataPointSetFactory dpsf = af.createDataPointSetFactory(tree); + + for (Slice slice : _map.values()) { + + boolean isBarrel = slice.decoder.getBarrelEndcapFlag().isBarrel(); + + IDataPointSet dps = dpsf.create(slice.layer.toString()+" Dots", 2); + for (Hep3Vector pos : slice.dots) { + double x = (isBarrel) ? Math.atan2(Math.hypot(pos.x(), pos.y()), pos.z()) : pos.x() ; + double y = (isBarrel) ? Math.atan2(pos.y(), pos.x()) : pos.y() ; + IDataPoint point = dps.addPoint(); + point.coordinate(0).setValue(x); + point.coordinate(1).setValue(y); + } + + dps = dpsf.create(slice.layer.toString()+" Beads", 2); + for (Hep3Vector pos : slice.beads) { + double x = (isBarrel) ? Math.atan2(Math.hypot(pos.x(), pos.y()), pos.z()) : pos.x() ; + double y = (isBarrel) ? Math.atan2(pos.y(), pos.x()) : pos.y() ; + IDataPoint point = dps.addPoint(); + point.coordinate(0).setValue(x); + point.coordinate(1).setValue(y); + } + + dps = dpsf.create(slice.layer.toString()+" Trajectory", 2); + for (Hep3Vector pos : slice.tPoints) { + double x = (isBarrel) ? Math.atan2(Math.hypot(pos.x(), pos.y()), pos.z()) : pos.x() ; + double y = (isBarrel) ? Math.atan2(pos.y(), pos.x()) : pos.y() ; + IDataPoint point = dps.addPoint(); + point.coordinate(0).setValue(x); + point.coordinate(1).setValue(y); + } + + dps = dpsf.create(slice.layer.toString()+" TrajCells", 2); + for (Hep3Vector pos : slice.tCells) { + double x = (isBarrel) ? Math.atan2(Math.hypot(pos.x(), pos.y()), pos.z()) : pos.x() ; + double y = (isBarrel) ? Math.atan2(pos.y(), pos.x()) : pos.y() ; + IDataPoint point = dps.addPoint(); + point.coordinate(0).setValue(x); + point.coordinate(1).setValue(y); + } + + } + + _map = null; + } + +// -- Per layer data : -------------------------------------------------------- + + private class Slice { + + Slice(CalLayer layer) {this.layer = layer;} + + CalLayer layer; + IDDecoder decoder; + + ArrayList<Hep3Vector> hits = new ArrayList<Hep3Vector>(); + ArrayList<Hep3Vector> dots = new ArrayList<Hep3Vector>(); + ArrayList<Hep3Vector> beads = new ArrayList<Hep3Vector>(); + ArrayList<Hep3Vector> tPoints = new ArrayList<Hep3Vector>(); + ArrayList<Hep3Vector> tCells = new ArrayList<Hep3Vector>(); + } +}

Commit in `lcsim-contrib/src/main/java/org/lcsim/contrib/onoprien/crux` on MAIN
`analysis/CheatTrackFinderDriver.java`	+2	-3	1.1 -> 1.2
`converters/TrackToITrackConverter.java`	+2	-2	1.1 -> 1.2
`infrastructure/CruxCluster.java`	+58	-6	1.3 -> 1.4
`/CruxClusterValidator.java`	+4	-3	1.1.1.1 -> 1.2
`/CruxParticle.java`	+2	-2	1.3 -> 1.4
`itc/ClusterNodeHeprepConverter.java`	+105		added 1.1
`/ClusterNode.java`	+2	-4	1.1 -> 1.2
`/Node.java`	+7	-1	1.1 -> 1.2
`/Rosary.java`	+77	-71	1.1 -> 1.2
`/RosaryClusterer.java`	+36	-22	1.3 -> 1.4
`/RosaryHeprepConverter.java`	+20	-22	1.1 -> 1.2
`diagnostics/PropagationTest.java`	+103		added 1.1
`/RosarySlicer.java`	+135		added 1.1
	+553	-136