lcsim/src/org/lcsim/contrib/seedtracker/strategybuilder

StrategyBuilder.java 1.8 -> 1.9

diff -u -r1.8 -r1.9
--- StrategyBuilder.java	7 Aug 2008 00:50:00 -0000	1.8
+++ StrategyBuilder.java	12 Aug 2008 23:13:00 -0000	1.9
@@ -55,9 +55,10 @@

     public static final int defaultSeedLayers =3; 
     public static final boolean defaultDivideByTwo=false;
     public static final int defaultMinUnweightedScore = 1;

+    public static final boolean defaultSymmetrize = true;

-    private boolean verbose = false;

+    private boolean verbose = defaultVerbose; 
+    private boolean symmetrize = defaultSymmetrize;

     private int min_layers = defaultMinLayers;  
     private int confirm_layers = defaultConfirmLayers;  
     private int seed_layers = defaultSeedLayers;

@@ -74,9 +75,10 @@

     private List<Set<DumbLayer>> setlist = new ArrayList<Set<DumbLayer>>();
     private String detectorName; 
     private IParticleFilter filter;

-    private List<Set<DumbLayer>> adjacentlist = new ArrayList<Set<DumbLayer>>();

+    private List<List<DumbLayer>> adjacentlist = new ArrayList<List<DumbLayer>>(); 
+    //4:26

     private Random random = new Random();

+    private BarrelEndcapFlag[] beArray = new BarrelEndcapFlag[]{BarrelEndcapFlag.ENDCAP_NORTH, BarrelEndcapFlag.ENDCAP_SOUTH};

 
     @Override 
     protected void startOfData(){

@@ -90,7 +92,7 @@

     
     //In the process step, we build two maps lists of sets:
     //      The set list is a list of the sets of layers hit by MCParticles hitting over 7 layers

-    //      The adjacence list is a list of a sets that are determined to be adjacent based on MCParticle trajectory

+    //      The adjacence list is a list of a list of hits that are determined to be adjacent based on MCParticle trajectory

     @Override
     protected void process(EventHeader event){

@@ -101,16 +103,20 @@

             System.out.println("Processed "+event.getEventNumber()+" events.");
         }

         filter.setEvent(event);
         
         //Build MC Map from SimTrackerHits
         Map<MCParticle, List<SimTrackerHit>> mcmap = new HashMap<MCParticle, List<SimTrackerHit>>(); 
         List<SimTrackerHit> allhits = new ArrayList<SimTrackerHit>();

         for (List<SimTrackerHit> l : event.get(SimTrackerHit.class)) {

-            //simulate inefficiency per collection here....

+
+           /**
+            * We simulate inefficiency in SimTrackerHit => TrackerHit conversion, 
+            * otherwise the strategies will miss certain classes of hits
+            */
+

             EventHeader.LCMetaData meta = event.getMetaData(l); 
             String readout = meta.getName();
             double efficiency = weighter.getReadoutEfficiency(readout);

@@ -121,8 +127,6 @@

         } 
        
         for (SimTrackerHit h : allhits){

-            
-

             MCParticle p = h.getMCParticle(); 
             List<SimTrackerHit> these_hits; 
             if (mcmap.containsKey(p)) {

@@ -144,11 +148,11 @@

             }
         }

-        //Build and add layer sets, as well as adjacent sets

+        //Build and add layer sets, as well as adjacent lists

         for(List<SimTrackerHit> l : mcmap.values()) {
             Set<DumbLayer> set = new HashSet<DumbLayer>();

-            //sort by time, which allows creation of adjacent sets.

+            //sort by time, which allows creation of adjacent lists.

             Collections.sort(l, new Comparator() {
 
                 public int compare(Object o1, Object o2) {

@@ -158,9 +162,8 @@

                 }
             });

-            //this will store all the working adjacent sets
-            LinkedList<Set<DumbLayer>> tempAdjacentLayersList = new LinkedList<Set<DumbLayer>>(); 
-

+            //this will store all the working adjacent lists
+            LinkedList<List<DumbLayer>> tempAdjacentLayersList = new LinkedList<List<DumbLayer>>();

             
             for (SimTrackerHit h : l) {
                 IDetectorElementContainer cont = DetectorElementStore.getInstance().find(h.getIdentifier());

@@ -171,25 +174,27 @@

                 BarrelEndcapFlag be = ID.getBarrelEndcapFlag(de); 
                 //kludgy divide by two thing
                 if (divideByTwoFlag && be.isEndcap() &&

-                        (detname.indexOf("Tracker") > 0 || detname.indexOf("Tkr") > 0) ) {

+                        (detname.indexOf("Tracker") > -1 || detname.indexOf("Tkr") > -1) ) {

                     lyr/=2;  // sid01 doubles up on layer numbering in the endcap. 
                 }

+                
+                //if symmetrizing, we want to treat North and South layers equivalently. 
+                if (symmetrize && be.isEndcap()) be = BarrelEndcapFlag.ENDCAP;

                 DumbLayer dl = new DumbLayer(detname, lyr, be); 
                 set.add(dl);

-                //create a new adjacent set that starts with this layer if none already exists

+                //create a new adjacent list that starts with this layer if none already exists

                 //(This is necessary because of the doubling of SimTrackerHits in the tracker endcap)
                 if (tempAdjacentLayersList.isEmpty() || !tempAdjacentLayersList.getLast().contains(dl)) {

-                    Set<DumbLayer> adjacentLayers = new HashSet<DumbLayer>();

+                    List<DumbLayer> adjacentLayers = new ArrayList<DumbLayer>();

                     tempAdjacentLayersList.addLast(adjacentLayers);
                 }

-                                //see which adjacent sets already have enough layers, and add those to the list
-                Iterator<Set<DumbLayer>> it = tempAdjacentLayersList.iterator();

+                //see which adjacent lists already have enough layers, and add those to the list
+                Iterator<List<DumbLayer>> it = tempAdjacentLayersList.iterator();

                 while (it.hasNext()) {

-                    Set<DumbLayer> s = it.next(); 
-                    s.add(dl);

+                    List<DumbLayer> s = it.next(); 
+                    if(!s.contains(dl)) s.add(dl); //otherwise we get doubled layers in the forward region of the tracker

                     if (s.size() == confirm_layers + seed_layers) {
                         adjacentlist.add(s); 
                         it.remove();

@@ -280,7 +285,7 @@

             iter = setset.iterator(); 
             
             //Now we let the scoring algorithm ignore anything that we already found.

-            while (iter.hasNext()){

+            while (iter.hasNext()) {

                 Set<DumbLayer> this_set = iter.next(); 
                 
                 if (this_set.containsAll(max)) { //If this set contains all the layers in max, it should be findable!

@@ -309,24 +314,75 @@

         List<SeedStrategy> strat_list = new ArrayList<SeedStrategy>(); 
         strat_list.addAll(startingStrategies);

+        
+        //create Strategies from final_sets... this part is klunky right now.

         for (Set<DumbLayer> s : final_sets) {
 
             List<DumbLayer> dlyrlst = new ArrayList<DumbLayer>(); 
             dlyrlst.addAll(s);

-            //sort the list from smallest to largest weight. Use smallest weight(s) for confirmation layer(s). 
-            Collections.sort(dlyrlst, new Comparator() {
-
-                public int compare(Object o1, Object o2) {
-                    DumbLayer dl1 = (DumbLayer) o1;
-                    DumbLayer dl2 = (DumbLayer) o2; 
-                    double s1 = weighter.getWeight(dl1);
-                    double s2 = weighter.getWeight(dl2);
-                    return Double.compare(s1, s2);

+            /**
+             * Here we figure out which layers to use for seeding and which to use
+             * for confirming. Since it is highly advantageous for the seed layers 
+             * to be adjacent, we will try to enforce that if possible. 
+             */
+            
+            //get adjacence info if set is adjacent. 
+            List<DumbLayer> adjacenceInfo = null; 
+            for (List<DumbLayer> l : adjacentlist) {
+                if (s.containsAll(l) && l.containsAll(s)) {
+                    adjacenceInfo = l; 
+                    break; 
+                }
+            }
+            
+            //if not all layers are adjacent, then perhaps a subset of size seed_layers is... 
+            if (adjacenceInfo == null) {
+                for (Set<DumbLayer> ss : generateAllPossibleSubsets(s, seed_layers)){
+                    for (List<DumbLayer> l : adjacentlist) {
+                        if (ss.containsAll(l) && l.containsAll(ss)) {
+                            adjacenceInfo = l; 
+                            break; 
+                        }
+                    }

-            });

+            }
+                        
+            /**
+             * The following operations manipulate dlyrlst such that the first num_confirm items will be
+             * used for confirmation and the rest will be used for seeding.  
+             * 
+             * This is kind of kludgy and it might be less confusing if it were changed. 
+             */
+            
+            //if these layers aren't adjacent, just use the weights to figure out which layers to confirm with
+            if (adjacenceInfo == null) {
+                //sort the list from smallest to largest weight. Use smallest weight(s) for confirmation layer(s). 
+                Collections.sort(dlyrlst, new Comparator() {
+                
+                    public int compare(Object o1, Object o2) {
+                        DumbLayer dl1 = (DumbLayer) o1;
+                        DumbLayer dl2 = (DumbLayer) o2; 
+                        double s1 = weighter.getWeight(dl1);
+                        double s2 = weighter.getWeight(dl2);
+                        return Double.compare(s1, s2); 
+                    }
+                }); 
+                
+            } 
+            //If all layers are adjacent, we use either the first or last layers to confirm, depending on the layer weights
+            else if (adjacenceInfo.size() == dlyrlst.size()) { 
+                dlyrlst = adjacenceInfo; 
+                if (weighter.getWeight(dlyrlst.get(0)) > weighter.getWeight(dlyrlst.get(dlyrlst.size()-1)))
+                    Collections.reverse(dlyrlst);
+                    
+            //Otherwise, use the adjacent layers as seeds and not the others... 
+            } else {
+                dlyrlst.removeAll(adjacenceInfo);
+                dlyrlst.addAll(adjacenceInfo); 
+            }

-            int confirmed = 0;

+            int confirmed = 0; //add the first num_confirm as confirmed... the rest as seed.

 
             List<SeedLayer> lyrlst = new ArrayList<SeedLayer>();

@@ -334,7 +390,7 @@

             for (DumbLayer lyr : extendmap.get(s)){
                 lyrlst.add(new SeedLayer(lyr.detectorName, lyr.layer, lyr.be, SeedType.Extend)); 
             }

             //get seed/confirmation layers
             for (DumbLayer lyr : dlyrlst){
                 SeedType type;

@@ -352,13 +408,7 @@

             
             //copy over cutoff info from prototype
             SeedStrategy stgy = new SeedStrategy(name,lyrlst);

-            stgy.putBadHitChisq(prototype.getBadHitChisq()); 
-            stgy.putMaxChisq(prototype.getMaxChisq()); 
-            stgy.putMaxDCA(prototype.getMaxDCA()); 
-            stgy.putMaxZ0(prototype.getMaxZ0());
-            stgy.putMinConfirm(prototype.getMinConfirm());
-            stgy.putMinHits(prototype.getMinHits()); 
-            stgy.putMinPT(prototype.getMinPT());

+            stgy.copyCutoffsFromStrategy(prototype);

             strat_list.add(stgy); 
         }

@@ -367,7 +417,31 @@

         meta.targetDetector =  detectorName; 
         meta.comment = comment;

+        //If symmetrizing, make Endcap Layers for both north and south
+        if (symmetrize) {
+            if (verbose) System.out.println("Symmetrizing..."); 
+            List<SeedStrategy> symmetrized = new ArrayList<SeedStrategy>(); 
+            Iterator<SeedStrategy> it = strat_list.iterator(); 
+            while (it.hasNext()) {
+                SeedStrategy next = it.next(); 
+                for (SeedLayer l : next.getLayerList()) {
+                    //Anything with BarrelEndcapFlag ENDCAP should be mirrored for both sides
+                    if (l.getBarrelEndcapFlag()==BarrelEndcapFlag.ENDCAP) {
+                        it.remove(); //remove this strategy... we will replace it with the other two symmetrized ones
+                        //loop through both north and south configurations
+                        for (BarrelEndcapFlag be : beArray) {
+                            SeedStrategy newstrat = makeMirroredLayer(next, be);
+                            symmetrized.add(newstrat); 
+                        }
+                        break; 
+                    }
+                }
+            }
+            strat_list.addAll(symmetrized); 
+        }
+

         StrategyXMLUtils.writeStrategyListToFile(strat_list, new File(outputFile), meta);

+        if (verbose) System.out.println(strat_list.size()+" strategies generated.");

         if (verbose) System.out.println("Strategies XML file written at "+outputFile); 
     }

@@ -422,7 +496,8 @@

     public void setParticleFilter(IParticleFilter pfilter){
         filter = pfilter; 
     }

+
+

     //========privates ============//
     
     private boolean startingCanFind(Set<DumbLayer> set){

@@ -435,6 +510,22 @@

         return false; 
     }

+    private SeedStrategy makeMirroredLayer(SeedStrategy next, BarrelEndcapFlag be) {
+        List<SeedLayer> symmlyrs = new ArrayList<SeedLayer>(); //store the new layers here
+        for (SeedLayer ll : next.getLayerList()) {
+            if (ll.getBarrelEndcapFlag().isBarrel()) {
+                // if it's a barrel layer, we can just add it
+                symmlyrs.add(ll);
+            } else {
+                //otherwise change from ENDCAP to either ENDCAP_NORTH or ENDCAP_SOUTH
+                SeedLayer newlyr = new SeedLayer(ll.getDetName(), ll.getLayer(), be, ll.getType());
+                symmlyrs.add(newlyr);
+            }
+        }
+        SeedStrategy newstrat = new SeedStrategy(next.getName() + be.toString(), symmlyrs); //create new strategy
+        newstrat.copyCutoffsFromStrategy(next); //copy parameters
+        return newstrat;
+    }

 
     private static List<Set<DumbLayer>> generateAllPossibleSubsets(Set<DumbLayer> allLayers, int subset_size) {

Commit in `lcsim` on MAIN
`src/org/lcsim/contrib/seedtracker/SeedStrategy.java`	+15		1.7 -> 1.8
`src/org/lcsim/contrib/seedtracker/strategybuilder/RunStrategyBuilder.java`	+6	-2	1.5 -> 1.6
`/StrategyBuilder.java`	+135	-44	1.8 -> 1.9
`/SubsetScorer.java`	+6	-2	1.3 -> 1.4
`resources/org/lcsim/contrib/seedtracker/strategybuilder/weights/default_weights_sid01.xml`	+100		added 1.1
	+262	-48