View Javadoc

1   package org.lcsim.event.base;
2   
3   import java.util.HashMap;
4   import java.util.Map;
5   import java.util.regex.Matcher;
6   import java.util.regex.Pattern;
7   import org.lcsim.conditions.ConditionsManager;
8   import org.lcsim.conditions.ConditionsSet;
9   import org.lcsim.conditions.ConditionsConverter;
10  import org.lcsim.geometry.Subdetector;
11  
12  /**
13   * Currently assumes that each subdetector has a single sampling fraction. 
14   * This is obviously not true if the subdetector has more than one layering scheme, 
15   * or if a single "subdetector" represents more than one physical detector (e.g. barrel and endcap).
16   *
17   * @author Tony Johnson <tonyj@slac.stanford.edu>
18   */
19  public class SamplingFractionManager {
20      
21      private static SamplingFractionManager theSamplingFractionManager = new SamplingFractionManager();
22      private ConditionsManager manager;
23  
24      private SamplingFractionManager() {
25          manager = ConditionsManager.defaultInstance();
26          manager.registerConditionsConverter(new SamplingFractionConverter());
27      }
28  
29      public static SamplingFractionManager defaultInstance() {
30          return theSamplingFractionManager;
31      }
32  
33      public double getCorrectedEnergy(double rawEnergy, int layer, Subdetector detector) {
34          SamplingFraction sf = manager.getCachedConditions(SamplingFraction.class, "SamplingFractions/" + detector.getName()).getCachedData();
35          return sf.getCorrectedEnergy(rawEnergy, layer);
36      }
37      
38      private static class SamplingFraction {
39          private final double defaultSamplingFraction;
40          private final boolean digital;
41          private final Map<Integer, Double> layerMap = new HashMap<Integer, Double>();
42  
43          private SamplingFraction(ConditionsSet set) {
44              defaultSamplingFraction = set.getDouble("samplingFraction");
45              digital = set.getBoolean("digital", false);
46              Pattern pattern = Pattern.compile("samplingFraction\\[((\\d+(-\\d+)?)(,\\d+(-\\d+)?)*)\\]");
47              Pattern p2 = Pattern.compile(",?(\\d+)(-(\\d+))?");
48  
49              for (Object o : set.keySet()) {
50                  String key = o.toString();
51  
52                  // Get rid of embedded whitespace, and match
53                  Matcher matcher = pattern.matcher(key.replaceAll("\\s", ""));
54                  if (matcher.matches()) {
55                      double s = set.getDouble(key);
56                      String layers = matcher.group(1);
57                      Matcher m2 = p2.matcher(layers);
58                      while (m2.find()) {
59                          int start = Integer.parseInt(m2.group(1));
60                          int end = m2.group(3) == null ? -1 : Integer.parseInt(m2.group(3));
61                          if (end > start) {
62                              for (int i = start; i <= end; i++) {
63                                  layerMap.put(i, s);
64                              }
65                          } else {
66                              layerMap.put(start, s);
67                          }
68                      }
69                  }
70              }
71          }
72  
73          double getCorrectedEnergy(double rawEnergy, int layer) {
74              Double layerSF = layerMap.get(layer);
75              double samplingFraction = layerSF == null ? defaultSamplingFraction : layerSF;
76              return (digital ? 1 : rawEnergy) / samplingFraction;
77          }
78      }
79  
80      private static class SamplingFractionConverter implements ConditionsConverter<SamplingFraction> {
81          public Class<SamplingFractionManager.SamplingFraction> getType() {
82              return SamplingFraction.class;
83          }
84  
85          public SamplingFractionManager.SamplingFraction getData(ConditionsManager manager, String name) {
86              ConditionsSet conditions = manager.getConditions(name);
87              return new SamplingFraction(conditions);
88          }
89      }
90  }