9 added + 1 modified, total 10 files
lcsim/resources/org/lcsim/contrib/seedtracker/strategybuilder
diff -N strategyBuilder.sh
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ strategyBuilder.sh 15 Jul 2008 19:00:23 -0000 1.1
@@ -0,0 +1,4 @@
+#!/bin/sh
+export MAVEN_OPTS=-Xmx512M
+mvn exec:java -Dexec.mainClass="org.lcsim.contrib.seedtracker.strategybuilder.RunStrategyBuilder" -Dexec.args="$*"
+
lcsim/src/org/lcsim/contrib/seedtracker
diff -u -r1.1 -r1.2
--- StrategyXMLUtils.java 11 Jul 2008 21:40:10 -0000 1.1
+++ StrategyXMLUtils.java 15 Jul 2008 19:00:23 -0000 1.2
@@ -87,17 +87,35 @@
return ret;
}
- /**
+
+
+
+ /**
* Generates an XML file representing the given strategy list.
* @param strategyList
- * @param file
- * @return
+ * @param file file object where xml will be written
+ * @return a boolean denoting the success of the operation
*/
- public static boolean writeStrategyListToFile(List<SeedStrategy> strategyList, File file) {
+
+ public static boolean writeStrategyListToFile(List<SeedStrategy> strategyList, File file){
+ return writeStrategyListToFile(strategyList, file, null);
+ }
+
+
+ /**
+ * Generates an XML file representing the given strategy list along with a top level comment.
+ * @param strategyList
+ * @param file file object where xml will be written
+ * @param comment top-level comment
+ * @return a boolean denoting the success of the operation
+ */
+ public static boolean writeStrategyListToFile(List<SeedStrategy> strategyList, File file, String comment) {
Element listElement = new Element("StrategyList");
Document doc = new Document(listElement);
-
+ if (comment!=null){
+ listElement.addContent(new Comment(comment));
+ }
for (SeedStrategy strat : strategyList){
Element strategy = new Element("Strategy");
lcsim/src/org/lcsim/contrib/seedtracker/strategybuilder
diff -N IStrategyBuilder.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ IStrategyBuilder.java 15 Jul 2008 19:00:23 -0000 1.1
@@ -0,0 +1,73 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.seedtracker.strategybuilder;
+
+import java.util.List;
+import org.lcsim.contrib.seedtracker.SeedStrategy;
+
+/**
+ *This interface should be implemented by any StrategyBuilder driver callable
+ * from RunStrategyBuilder. Note that StrategyBuilder implements this interface
+ * but is not directly callable because it does not create any hits.
+ *
+ *
+ * @author cozzy
+ */
+public interface IStrategyBuilder {
+
+ /**
+ * Sets the location of the output XML file of strategy lists
+ * @param filename
+ */
+ public void setOutput(String filename);
+
+
+ /**
+ * Sets the minimum number of layers that an MCParticle must go through to be considered
+ * for strategy finidng
+ * @param min
+ */
+ public void setMinLayers(int min);
+
+ /**
+ * Sets the number of confirmation layers desired
+ * @param confirmed
+ */
+ public void setNumConfirmLayers(int confirmed);
+
+ /**
+ * Sets the number of seed layers desired
+ * @param seed
+ */
+ public void setNumSeedLayers(int seed);
+
+ /**
+ * Sets the LayerWeight object of the strategy builder. A layer weight is
+ * used to treat certain layers preferentially.
+ * @param lw
+ */
+ public void setLayerWeight(LayerWeight lw);
+
+ /**
+ * Set the prototype for the generated strategies. The values for cutoffs
+ * and such will be copied from the prototype.
+ * @param strategy
+ */
+ public void setStrategyPrototype(SeedStrategy strategy);
+
+ /**
+ * Set a starting strategy list. New strategies will only be generated for
+ * particles not already found by the starting strategy list.
+ * @param startList
+ */
+ public void setStartingStrategyList(List<SeedStrategy> startList);
+
+ /**
+ * Enables extra output if verbose is true.
+ * @param verbose
+ */
+ public void setVerbose(boolean verbose);
+}
lcsim/src/org/lcsim/contrib/seedtracker/strategybuilder
diff -N DumbLayer.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ DumbLayer.java 15 Jul 2008 19:00:23 -0000 1.1
@@ -0,0 +1,49 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.seedtracker.strategybuilder;
+
+import org.lcsim.geometry.subdetector.BarrelEndcapFlag;
+
+/**Simple layer to uniquely define layers. Like SeedLayer but without
+ * information about layer type.
+ *
+ * @author cozzy
+ */
+public class DumbLayer{
+
+ String detectorName;
+ int layer;
+ BarrelEndcapFlag be;
+
+ public DumbLayer(String det, int lyr, BarrelEndcapFlag be){
+ detectorName = det;
+ layer = lyr;
+ this.be = be;
+ }
+
+
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) return true;
+ if (! (other instanceof DumbLayer)) return false;
+ DumbLayer dl = (DumbLayer) other;
+ return ( this.be.equals(dl.be) &&
+ this.layer == dl.layer &&
+ this.detectorName.equals(dl.detectorName));
+ }
+
+ //dumb hash function...
+ @Override
+ public int hashCode() {
+ return 20*( be.ordinal() + 1) + layer + 500*(detectorName.hashCode() % 1000);
+ }
+
+ @Override
+ public String toString() {
+ return ("DumbLayer: det="+detectorName+" lyr="+layer+" be="+ be.toString());
+ }
+
+ }
lcsim/src/org/lcsim/contrib/seedtracker/strategybuilder
diff -N RunStrategyBuilder.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ RunStrategyBuilder.java 15 Jul 2008 19:00:23 -0000 1.1
@@ -0,0 +1,113 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.seedtracker.strategybuilder;
+
+import java.io.File;
+import org.lcsim.contrib.seedtracker.StrategyXMLUtils;
+import org.lcsim.util.Driver;
+import org.lcsim.util.loop.LCSimLoop;
+
+/**
+ * Class used to run StrategyBuilder from outside of Jas3.
+ *
+ * @author cozzy
+ */
+public class RunStrategyBuilder {
+ public static void main(String[] args) {
+ String builder_class = "org.lcsim.contrib.seedtracker.strategybuilder.DigiStrategyBuilder";
+ String filename="";
+ String outFile = "";
+ int numEvents=-1;
+ String startingStrategies = "";
+ String prototypeFile = "";
+ int prototypeN = -1;
+ boolean verbose = false;
+
+ try{
+ int no_flag_counter = 0;
+ for (int i = 0; i < args.length; i++){
+
+ String arg = args[i];
+
+ if (arg.equals("-h")) {
+ printUsage();
+ System.exit(0);
+ } else if (arg.equals("-o")) {
+ outFile = args[++i];
+ } else if (arg.equals("-e")) {
+ numEvents = Integer.valueOf(args[++i]);
+ } else if (arg.equals("-s")) {
+ startingStrategies = args[++i];
+ } else if (arg.equals("-p")) {
+ prototypeFile = args[++i];
+ prototypeN = Integer.valueOf(args[++i]);
+ } else if (arg.equals("-v")){
+ verbose = true;
+ } else if (arg.equals("-c")){
+ builder_class = args[++i];
+ } else if (arg.startsWith("-")){
+ throw new Exception();
+ } else {
+ if (no_flag_counter > 0) throw new Exception();
+ no_flag_counter++;
+ filename = arg;
+ }
+ }
+ if (no_flag_counter == 0) throw new Exception();
+
+ } catch (Exception e){
+ printUsage();
+ System.exit(1);
+ }
+ Driver driver = new Driver(); // prevent compiler from complaining that driver might not have been initialized.
+
+ try{
+ driver = (Driver) Class.forName(builder_class).newInstance();
+ } catch (Exception e){
+ System.out.println("Can't load class "+builder_class);
+ System.exit(2);
+ }
+
+ ((IStrategyBuilder) driver).setVerbose(verbose);
+
+ if (outFile.length() > 0)
+ ((IStrategyBuilder) driver).setOutput(outFile);
+
+ if (startingStrategies.length() > 0)
+ ((IStrategyBuilder) driver).setStartingStrategyList(StrategyXMLUtils.getStrategyListFromFile(new File(startingStrategies)));
+
+ if (prototypeFile.length() > 0)
+ ((IStrategyBuilder) driver).setStrategyPrototype(StrategyXMLUtils.getStrategyListFromFile(new File(startingStrategies)).get(prototypeN));
+
+ try {
+
+ File file = new File(filename);
+ LCSimLoop loop = new LCSimLoop();
+ loop.setLCIORecordSource(file);
+ loop.add( driver );
+ loop.loop(numEvents, null);
+ loop.dispose();
+ } catch (Exception e){
+ e.printStackTrace();
+ throw new RuntimeException("oopsie");
+ }
+ }
+
+
+ private static void printUsage(){
+
+ System.out.println("Usage: RunStrategyBuilder INPUTRECORD [flags]");
+ System.out.println(" -h \t\t\t\tPrint this message");
+ System.out.println(" -v \t\t\t\tBe verbose");
+ System.out.println(" -o OUTPUTFILE \t\t\tset output XML file to OUTPUTFILE\n\t\t\t\t(default is in TEMP dir)");
+ System.out.println(" -e NUM_EVENTS \t\t\tRun only NUM_EVENTS events instead of all");
+ System.out.println(" -s STARTING_STRATEGY_FILE \t Use starting strategies in the specified file");
+ System.out.println(" -p PROTOTYPE_STRATEGY_FILE N\t Use the Nth strategy in the specified file\n\t\t\t\t as a prototype");
+ System.out.println(" -c STRATEGY_BUILDER_CLASS_NAME\t The fully qualified name of the class\n\t\t\t\tto use for" +
+ "finding strategies. Default is \n\t\t\t\torg.lcsim.contrib.seedtracker.\n\t\t\t\tstrategybuilder.DigiStrategyBuilder");
+ }
+
+}
lcsim/src/org/lcsim/contrib/seedtracker/strategybuilder
diff -N StrategyBuilder.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ StrategyBuilder.java 15 Jul 2008 19:00:23 -0000 1.1
@@ -0,0 +1,351 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.seedtracker.strategybuilder;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.lcsim.contrib.seedtracker.SeedLayer;
+import org.lcsim.contrib.seedtracker.SeedLayer.SeedType;
+import org.lcsim.contrib.seedtracker.SeedStrategy;
+import org.lcsim.contrib.seedtracker.StrategyXMLUtils;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.MCParticle;
+import org.lcsim.fit.helicaltrack.HelicalTrackHit;
+import org.lcsim.util.Driver;
+
+/**
+ * StrategyBuilder generatew
+ *
+ * @author cozzy
+ */
+public class StrategyBuilder extends Driver implements IStrategyBuilder{
+
+ private static final String defaultOutputFile = System.getProperties().getProperty("java.io.tmpdir")+
+ System.getProperties().getProperty("file.separator")+
+ "BuiltStrategies.xml";
+ private boolean verbose = false;
+ private int min_layers = 7;
+ private int confirm_layers = 1;
+ private int seed_layers = 3;
+ private String outputFile = defaultOutputFile;
+ private List<SeedStrategy> startingStrategies = new ArrayList<SeedStrategy>();
+ Set<Set<DumbLayer>> startingSet = new HashSet<Set<DumbLayer>>(); //this will be generated from startingStrategies
+ private SeedStrategy prototype = new SeedStrategy("null", new ArrayList<SeedLayer>());
+ private LayerWeight weighter = new DefaultLayerWeight();
+
+ //this stores the list of all sets of layers
+ private List<Set<DumbLayer>> setlist = new ArrayList<Set<DumbLayer>>();
+ public StrategyBuilder(){
+
+ }
+
+ @Override
+ protected void process(EventHeader event){
+
+ super.process(event);
+
+ if(!event.hasCollection(HelicalTrackHit.class, "HelicalTrackHits"))
+ throw new RuntimeException("Expecting collection called HelicalTrackHits in event. Perhaps you tried to run StrategyBuilder directly?");
+
+ if (verbose) System.out.println("Processing event "+event.getEventNumber());
+
+ //Build MC Map
+ Map<MCParticle, List<HelicalTrackHit>> mcmap = new HashMap<MCParticle, List<HelicalTrackHit>>();
+ List<HelicalTrackHit> allhits = event.get(HelicalTrackHit.class, "HelicalTrackHits");
+ for (HelicalTrackHit h : allhits){
+ for (MCParticle p : h.getMCParticles()) {
+ List<HelicalTrackHit> these_hits;
+
+ if (mcmap.containsKey(p)) {
+ these_hits = mcmap.get(p);
+ } else {
+ these_hits = new ArrayList<HelicalTrackHit>();
+ }
+ these_hits.add(h);
+ mcmap.put(p, these_hits);
+ }
+ }
+
+ //Build and add layer sets
+ for(List<HelicalTrackHit> l : mcmap.values()) {
+ Set<DumbLayer> set = new HashSet<DumbLayer>();
+ for (HelicalTrackHit h : l){
+ set.add(new DumbLayer(h.Detector(), h.Layer(), h.BarrelEndcapFlag()));
+ }
+ //Ensure layer set has minimum number of layers
+ if (set.size() >= min_layers)
+ setlist.add(set);
+ }
+ }
+
+ @Override
+ protected void suspend(){
+
+ if (verbose) System.out.println("Finished processing. Beginning analysis.");
+ Set<DumbLayer> allLayers = new HashSet<DumbLayer>();
+
+ //Get all layers that are used at some point
+ for (Set<DumbLayer> set : setlist)
+ allLayers.addAll(set);
+ if (verbose) System.out.println(allLayers.size()+" total layers.");
+
+ //create startingSet... this will be used so that new strategies aren't extraneously generated
+ for (SeedStrategy strategy : startingStrategies){
+ Set<DumbLayer> subset = new HashSet<DumbLayer>();
+ for (SeedLayer lyr : strategy.getLayers(SeedLayer.SeedType.Seed))
+ subset.add(new DumbLayer(lyr.getDetName(), lyr.getLayer(), lyr.getBarrelEndcapFlag()));
+
+ for (SeedLayer lyr: strategy.getLayers(SeedLayer.SeedType.Confirm))
+ subset.add(new DumbLayer(lyr.getDetName(), lyr.getLayer(), lyr.getBarrelEndcapFlag()));
+ startingSet.add(subset);
+ }
+ if (verbose) System.out.println(startingStrategies.size()+" starting strategies defined.");
+
+ //If any of the starting strategies can find a set, discard it.
+ Iterator<Set<DumbLayer>> iter = setlist.iterator();
+ while (iter.hasNext()){
+ Set<DumbLayer> this_set = iter.next();
+ if (startingCanFind(this_set)){
+ iter.remove();
+ }
+ }
+
+ //Generate the scorer and assign its weighter
+ SubsetScorer scorer = new SubsetScorer(setlist);
+ scorer.setLayerWeight(weighter);
+
+ //Generate all possible subsets of the right size of allLayers
+ List<Set<DumbLayer>> all_subsets = generateAllPossibleSubsets(allLayers, confirm_layers+seed_layers);
+ if (verbose) System.out.println(all_subsets.size() + " possible subsets of size "+(confirm_layers+seed_layers));
+
+ //convert setlist to set
+ Set<Set<DumbLayer>> setset = new HashSet<Set<DumbLayer>>();
+ setset.addAll(setlist);
+
+ //final_sets will store the generated seed + confirm layers
+ Set<Set<DumbLayer>> final_sets = new HashSet<Set<DumbLayer>>();
+
+ //map from a final_set to all other associated layers to generate extension layers
+ Map<Set<DumbLayer>, Set<DumbLayer>> extendmap = new HashMap<Set<DumbLayer>,Set<DumbLayer>>();
+
+ //Figure out a "good" set of four-layer combinations
+ while (true){
+ if (setset.isEmpty()) break; //if this is empty, then we're done. All cases are covered.
+
+ Set<DumbLayer> max = all_subsets.get(0);
+ double maxScore = 0;
+
+ //get the highest scoring strategy
+ for (Set<DumbLayer> trial : all_subsets){
+ double score = scorer.getScore(trial);
+ if (score > maxScore) {
+ maxScore = score;
+ max = trial;
+ }
+ }
+
+ scorer.markUsed(max);
+ final_sets.add(max);
+ extendmap.put(max, new HashSet<DumbLayer>());
+
+ iter = setset.iterator();
+ 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!
+
+
+ //add extension layers to extendmap
+ Set<DumbLayer> nw = new HashSet<DumbLayer>();
+ for (DumbLayer dumb : this_set){
+ if(!max.contains(dumb)) nw.add(dumb);
+ }
+ Set<DumbLayer> old = extendmap.get(max);
+ old.addAll(nw);
+ extendmap.put(max, old);
+
+ //remove this set from consideration
+ iter.remove();
+ }
+ }
+ }
+ if(verbose) System.out.println("Done finding strategies");
+ if(verbose) System.out.println(final_sets.toString());
+
+ //Generate the StrategyList
+ int counter = 0;
+ List<SeedStrategy> strat_list = new ArrayList<SeedStrategy>();
+ strat_list.addAll(startingStrategies);
+
+ 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);
+
+ if (s1>s2) return 1;
+ else if (s1<s2) return -1;
+ else return 0;
+ }
+ });
+
+
+ String name = "AUTOGEN" + counter++;
+ int confirmed = 0;
+
+ List<SeedLayer> lyrlst = new ArrayList<SeedLayer>();
+
+ //get extension layers
+ 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;
+
+ if (confirmed < confirm_layers) {
+ type = SeedType.Confirm;
+ confirmed++;
+ }
+ else type = SeedType.Seed;
+ lyrlst.add(new SeedLayer(lyr.detectorName, lyr.layer, lyr.be, type));
+ }
+ Collections.reverse(lyrlst); // reverse so seed layers on top
+ //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());
+ strat_list.add(stgy);
+ }
+
+
+ String comment = "Strategy list Autogenerated by Strategy Builder on "+new Date()+".";
+ StrategyXMLUtils.writeStrategyListToFile(strat_list, new File(outputFile), comment);
+ if (verbose) System.out.println("Strategies XML file written at "+outputFile);
+ }
+
+ public void setOutput(String filename){
+ outputFile = filename;
+ }
+
+ public void setLayerWeight(LayerWeight lw){
+ weighter = lw;
+ }
+
+ public void setMinLayers(int min){
+ min_layers = min;
+ }
+
+ public void setNumConfirmLayers(int clayers){
+ confirm_layers = clayers;
+ }
+
+ public void setNumSeedLayers(int slayers){
+ seed_layers = slayers;
+ }
+
+ public void setStrategyPrototype(SeedStrategy proto){
+ prototype = proto;
+ }
+
+ public void setStartingStrategyList(List<SeedStrategy> slist){
+ startingStrategies = slist;
+ }
+
+ public void setVerbose(boolean v){
+ verbose = true;
+ }
+
+ private boolean startingCanFind(Set<DumbLayer> set){
+
+ for (Set<DumbLayer> s : startingSet){
+ if (set.containsAll(s))
+ return true;
+ }
+
+ return false;
+ }
+
+
+
+ private static List<Set<DumbLayer>> generateAllPossibleSubsets(Set<DumbLayer> allLayers, int subset_size) {
+
+ Set<Object> set = new HashSet<Object>();
+ set.addAll(allLayers);
+ Set<Set<Object>> subsets = generateAllPossibleSubsets(set, subset_size);
+
+ List<Set<DumbLayer>> ret = new ArrayList<Set<DumbLayer>>();
+
+ for (Set<Object> subset : subsets) {
+ Set<DumbLayer> dl = new HashSet<DumbLayer>();
+ for (Object o : subset){
+ dl.add((DumbLayer) o);
+ }
+ ret.add(dl);
+ }
+
+ return ret;
+ }
+
+ /**
+ * Returns all possible subsets of a given size of the set allObjects
+ * @param allObjects The set to find subsets of
+ * @param subset_size The size desired of subsets.
+ * @return A set of subsets, all of size sub_set size
+ */
+ public static Set<Set<Object>> generateAllPossibleSubsets(Set<Object> allObjects, int subset_size) {
+
+ assert(subset_size > 0 && subset_size <= allObjects.size());
+
+ if (subset_size == 1){
+ Set<Set<Object>> ret = new HashSet<Set<Object>>();
+ for (Object o : allObjects){
+ Set<Object> set = new HashSet<Object>();
+ set.add(o);
+ ret.add(set);
+ }
+ return ret;
+ }
+
+ else {
+ Set<Set<Object>> ret = new HashSet<Set<Object>>();
+ for(Object o : allObjects) {
+ Set<Object> newSet = new HashSet<Object>();
+ newSet.addAll(allObjects);
+ newSet.remove(o);
+ Set<Set<Object>> partial = generateAllPossibleSubsets(newSet, subset_size-1);
+ for (Set s : partial) s.add(o);
+ ret.addAll(partial);
+ }
+
+ return ret;
+ }
+ }
+
+}
lcsim/src/org/lcsim/contrib/seedtracker/strategybuilder
diff -N LayerWeight.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ LayerWeight.java 15 Jul 2008 19:00:23 -0000 1.1
@@ -0,0 +1,55 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.seedtracker.strategybuilder;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ *
+ * @author cozzy
+ */
+public class LayerWeight {
+
+ private double default_weight = 1.0;
+ private Map<DumbLayer, Double> weights;
+
+ public LayerWeight(){
+ weights = new HashMap<DumbLayer,Double>();
+ }
+
+ public LayerWeight(DumbLayer[] layers, double[] wghts){
+ if (layers.length!=wghts.length)
+ throw new RuntimeException("Array lengths don't match");
+
+ weights = new HashMap<DumbLayer,Double>();
+
+ for (int i = 0; i < layers.length; i++)
+ weights.put(layers[i], wghts[i]);
+ }
+
+ public void setDefaultWeight(double d){
+ default_weight = d;
+ }
+
+ public double getWeight(DumbLayer layer) {
+ if (weights.containsKey(layer)){
+ return weights.get(layer).doubleValue();
+ } else return default_weight;
+ }
+
+ public double getWeight(Set<DumbLayer> set) {
+ double ret = 0.0;
+
+ for (DumbLayer lyr : set) {
+ ret+=getWeight(lyr);
+ }
+
+ ret /= (double) set.size();
+ return ret;
+ }
+ }
lcsim/src/org/lcsim/contrib/seedtracker/strategybuilder
diff -N DigiStrategyBuilder.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ DigiStrategyBuilder.java 15 Jul 2008 19:00:23 -0000 1.1
@@ -0,0 +1,59 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.seedtracker.strategybuilder;
+
+import java.util.List;
+import org.lcsim.contrib.seedtracker.SeedStrategy;
+import org.lcsim.contrib.seedtracker.digiexample.*;
+import org.lcsim.util.Driver;
+
+/**
+ *
+ * @author cozzy
+ */
+public class DigiStrategyBuilder extends Driver implements IStrategyBuilder{
+
+
+ StrategyBuilder builder = new StrategyBuilder();
+
+ public DigiStrategyBuilder() {
+ add(new DigiHitMaker());
+ add(builder);
+ }
+
+ public void setOutput(String filename) {
+ builder.setOutput(filename);
+ }
+
+ public void setMinLayers(int min) {
+ builder.setMinLayers(min);
+ }
+
+ public void setNumConfirmLayers(int confirmed) {
+ builder.setNumConfirmLayers(confirmed);
+ }
+
+ public void setNumSeedLayers(int seed) {
+ builder.setNumSeedLayers(seed);
+ }
+
+ public void setLayerWeight(LayerWeight lw) {
+ builder.setLayerWeight(lw);
+ }
+
+ public void setStrategyPrototype(SeedStrategy strategy) {
+ builder.setStrategyPrototype(strategy);
+ }
+
+ public void setStartingStrategyList(List<SeedStrategy> startList) {
+ builder.setStartingStrategyList(startList);
+ }
+
+ public void setVerbose(boolean verbose){
+ builder.setVerbose(verbose);
+ }
+
+}
lcsim/src/org/lcsim/contrib/seedtracker/strategybuilder
diff -N SubsetScorer.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ SubsetScorer.java 15 Jul 2008 19:00:23 -0000 1.1
@@ -0,0 +1,57 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.seedtracker.strategybuilder;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ *
+ * @author cozzy
+ */
+public class SubsetScorer {
+
+ Map<Set<DumbLayer>,Integer> setmap = new HashMap<Set<DumbLayer>,Integer>();
+ LayerWeight weighter = new LayerWeight();
+
+ public SubsetScorer(List<Set<DumbLayer>> setlist) {
+
+ for (Set<DumbLayer> set : setlist) {
+ if(setmap.containsKey(set)){
+ setmap.put(set,setmap.get(set).intValue()+1);
+ } else {
+ setmap.put(set,1);
+ }
+ }
+ }
+
+ public void setLayerWeight(LayerWeight lw) {
+ weighter = lw;
+ }
+
+ public double getScore(Set<DumbLayer> testSet) {
+
+ int ret = 0;
+ for (Set<DumbLayer> s : setmap.keySet()){
+ if (s.containsAll(testSet)) {
+ ret+= setmap.get(s).intValue();
+ }
+ }
+ return ret*weighter.getWeight(testSet);
+ }
+
+ public void markUsed(Set<DumbLayer> testSet) {
+ for (Set<DumbLayer> s : setmap.keySet()){
+ if (s.containsAll(testSet)) {
+ setmap.put(s,0);
+ }
+ }
+ }
+
+
+ }
\ No newline at end of file
lcsim/src/org/lcsim/contrib/seedtracker/strategybuilder
diff -N DefaultLayerWeight.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ DefaultLayerWeight.java 15 Jul 2008 19:00:23 -0000 1.1
@@ -0,0 +1,65 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.seedtracker.strategybuilder;
+
+import org.lcsim.geometry.subdetector.BarrelEndcapFlag;
+
+/**
+ *The layer weighting scheme used by default by StrategyBuilder if no other is
+ * provided.
+ *
+ * @author cozzy
+ */
+public class DefaultLayerWeight extends LayerWeight {
+
+ private static final BarrelEndcapFlag barr = BarrelEndcapFlag.BARREL;
+ private static final BarrelEndcapFlag north = BarrelEndcapFlag.ENDCAP_NORTH;
+ private static final BarrelEndcapFlag south = BarrelEndcapFlag.ENDCAP_SOUTH;
+
+
+ public DefaultLayerWeight(){
+
+
+ super( new DumbLayer[] {
+
+ new DumbLayer("SiTrackerBarrel",5,barr),
+ new DumbLayer("SiTrackerBarrel",4,barr),
+ new DumbLayer("SiTrackerBarrel",3,barr),
+ new DumbLayer("SiTrackerBarrel",2,barr),
+ new DumbLayer("SiTrackerBarrel",1,barr),
+
+ new DumbLayer("SiTrackerEndcap",4,north),
+ new DumbLayer("SiTrackerEndcap",3,north),
+ new DumbLayer("SiTrackerEndcap",2,north),
+ new DumbLayer("SiTrackerEndcap",1,north),
+
+ new DumbLayer("SiTrackerEndcap",4,south),
+ new DumbLayer("SiTrackerEndcap",3,south),
+ new DumbLayer("SiTrackerEndcap",2,south),
+ new DumbLayer("SiTrackerEndcap",1,south)
+
+ },
+
+ new double[]{
+ 5.0,
+ 4.0,
+ 3.0,
+ 2.0,
+ 2.0,
+
+ 5.0,
+ 4.0,
+ 3.0,
+ 2.0,
+
+ 5.0,
+ 4.0,
+ 3.0,
+ 2.0
+
+ });
+ }
+}
CVSspam 0.2.8