LISTSERV 16.5 - LCD-CVS Archives

lcsim/src/org/lcsim/contrib/SiStripSim

Kpix.java 1.6 -> 1.7

diff -u -r1.6 -r1.7
--- Kpix.java	14 Oct 2007 06:14:59 -0000	1.6
+++ Kpix.java	6 Nov 2007 19:58:03 -0000	1.7
@@ -9,9 +9,12 @@

 
 package org.lcsim.contrib.SiStripSim;

+import java.util.ArrayList;
+import java.util.List;

 import java.util.SortedMap;
 import java.util.TreeMap;
 import org.lcsim.detector.tracker.silicon.SiSensorElectrodes;

+import org.lcsim.units.clhep.SystemOfUnits;

 
 /**
  *

@@ -19,95 +22,331 @@

  */
 public class Kpix implements ReadoutChip
 {

-    // Fields
-    double _high_gain;
-    double _low_gain;
-
-    // Static
-    static double ELECTRON_CHARGE = 1.60217646E-4; // fC

+    
+    static final int VERSION_NUMBER = 0; // version number
+    
+    // Static values and defaults: DO NOT CHANGE
+    //==========================================
+    
+    public static class ControlRegisters
+    {
+        
+        enum GainMode
+        {SINGLE, DOUBLE}
+        enum Polarity
+        {POSITIVE, NEGATIVE}
+        
+        private int _version_number = VERSION_NUMBER;
+        private GainMode _gain_mode = GainMode.DOUBLE;
+        private Polarity _polarity = Polarity.POSITIVE;
+        private double _gain_crossover = 1.0;           // V
+        
+        public ControlRegisters()
+        {
+        }
+        
+        // Setters-
+        // do not allow public setting of version number
+        // do not allow setting gain crossover for now (more info needed for this)
+        private void setVersionNumber(int version_number)
+        {
+            _version_number = version_number;
+        }
+        
+        public void setPolarity(Polarity polarity)
+        {
+            _polarity = polarity;
+        }
+        
+        public void setGainMode(GainMode gain_mode)
+        {
+            _gain_mode = gain_mode;
+        }
+        
+        // Getters
+        public int getVersionNumber()
+        {
+            return _version_number;
+        }
+        
+        public GainMode getGainMode()
+        {
+            return _gain_mode;
+        }
+        
+        public Polarity getPolarity()
+        {
+            return _polarity;
+        }
+        
+        public double getGainCrossover()
+        {
+            return _gain_crossover;
+        }
+        
+        // Encoding and decoding resgister information
+        public int encoded()
+        {
+            return ( getVersionNumber()<<1 & getGainMode().ordinal() )<<1 & getPolarity().ordinal();
+        }
+        
+        public static ControlRegisters decoded(int encoded_registers)
+        {
+            ControlRegisters registers = new ControlRegisters();

-    static double NOISE_INTERCEPT = 300.0; // electrons
-    static double NOISE_SLOPE = 30.0; // electrons
-
-    static double HIGH_GAIN_DEFAULT = 10.0; // counts/fC
-    static double LOW_GAIN_DEFAULT = 0.5; // counts/fC
-//    static double GAIN_SWITCHOVER = ??; // Need a guess for this default
-
-    static boolean DOUBLE_GAIN_MODE = true; // double gain mode

+            int version_number = encoded_registers & 0xFC;
+            int double_gain = encoded_registers & 0x1;
+            int polarity = encoded_registers &    0x2;
+            
+            registers.setVersionNumber(version_number);
+            registers.setGainMode(GainMode.values()[double_gain]);
+            registers.setPolarity(Polarity.values()[polarity]);
+            
+            return registers;
+        }
+        
+    }

-    // Variables

+    // Fields
+    ControlRegisters _control_registers = new ControlRegisters();
+    KpixChannel _channel = new KpixChannel(_control_registers); // one per chip for now

     
     /** Creates a new instance of Kpix */
     public Kpix()
     {

-        _high_gain = HIGH_GAIN_DEFAULT * ELECTRON_CHARGE;
-        _low_gain = LOW_GAIN_DEFAULT * ELECTRON_CHARGE;
-        if (DOUBLE_GAIN_MODE)
-        {
-            _high_gain *= 2;
-            _low_gain *=2;
-        }

-
-    public SortedMap<Integer,Integer> readout(SortedMap<Integer,Integer> raw_charge, SiSensorElectrodes electrodes)

+    
+    // Set and get register information
+    public ControlRegisters getControlRegisters()

-        int nchannels = electrodes.getNCells();
-        
-        addNoise(raw_charge, nchannels);              
-        SortedMap<Integer,Integer> digitized_charge = digitize(raw_charge);
-        raw_charge.clear();
-        
-        return digitized_charge;

+        return _control_registers;

+    public KpixChannel getKpixChannels()
+    {
+        return _channel;
+    }
+    
+    // Actions
+    public SortedMap<Integer,List<Integer>> readout(SiElectrodeDataCollection data, SiSensorElectrodes electrodes)
+    {
+        addNoise(data,electrodes);
+        return digitize(data,electrodes);
+    }
+    
+    private void addNoise(SiElectrodeDataCollection data, SiSensorElectrodes electrodes)
+    {
+        
+    }

-    private void addNoise(SortedMap<Integer,Integer> electrode_charge, int nchannels)

+    private SortedMap<Integer,List<Integer>> digitize(SiElectrodeDataCollection data, SiSensorElectrodes electrodes)

-        for (Integer channel : electrode_charge.keySet())

+        SortedMap<Integer,List<Integer>> chip_data = new TreeMap<Integer,List<Integer>>();
+        for (Integer channel : data.keySet())

+            List<Integer> channel_data = new ArrayList<Integer>();
+            channel_data.add(getControlRegisters().encoded());
+            channel_data.add(getKpixChannels().digitize(data.get(channel)));
+            chip_data.put(channel,channel_data);

-        return;

+        return chip_data;

+    // Static calculations of important quantities
+    public static double computeCharge(KpixChannel.ReadoutRegisters readout_registers, ControlRegisters control_registers)
+    {
+        double gain = KpixChannel.computeGain(readout_registers, control_registers);
+        return gain*readout_registers.getAdcValue();
+    }

-//    private SiElectrodeDataCollection digitize(SiElectrodeDataCollection electrode_charge)
-//    {        
-//        
-//        SiElectrodeDataCollection digitized_charge = new SiElectrodeDataCollection();
-//                
-//        for (Integer channel : electrode_charge.keySet())
-//        {
-//
-//            SiElectrodeData analog = electrode_charge.get(channel);
-//
-//            double gain = _high_gain; 
-//            
-//            int digital = (int)Math.floor(analog.getCharge() * gain);
-//           
-//            if (digital != 0) digitized_charge.put(channel,new SiElectrodeData(digital);
-//        }
-//        return digitized_charge;
-//    }    
-    
-    private SortedMap<Integer,Integer> digitize(SortedMap<Integer,Integer> electrode_charge)
-    {

+    //=========================================
+    // Class representing a single KPiX channel
+    //=========================================
+
+    public static class KpixChannel
+    {
+        static final double NORMAL_GAIN_CAP = 400E-15; // 400 fF
+        static final double DOUBLE_GAIN_CAP = 200E-15; // 200 fF
+        static final double LOW_GAIN_CAP = 10E-12; // 10pF
+        static final double ADC_GAIN = 2.5; // count/mV
+        static final double NOISE_INTERCEPT = 300; // electrons
+        static final double NOISE_SLOPE = 30; // electrons

-        SortedMap<Integer,Integer> digitized_charge = new TreeMap<Integer,Integer>();

+        public static class ReadoutRegisters
+        {
+            enum GainRange
+            {NORMAL, LOW}
+            
+            GainRange _gain_range = GainRange.NORMAL;
+            int _buffer_number = 0;
+            int _time = 0;
+            int _adc_value = 0;
+            
+            public ReadoutRegisters()
+            {
+            }
+            
+            public void setGainRange(GainRange gain_range)
+            {
+                _gain_range = gain_range;
+            }
+            
+            public void setBufferNumber(int buffer_number)
+            {
+                _buffer_number = buffer_number;
+            }
+            
+            public void setTime(int time)
+            {
+                _time = time;
+            }
+            
+            public void setAdcValue(int adc_value)
+            {
+                _adc_value = adc_value;
+            }
+            
+            public GainRange getGainRange()
+            {
+                return _gain_range;
+            }
+            
+            public int getBufferNumber()
+            {
+                return _buffer_number;
+            }
+            
+            public int getTime()
+            {
+                return _time;
+            }
+            
+            public int getAdcValue()
+            {
+                return _adc_value;
+            }
+            
+            public int encoded()
+            {
+                return ((((getGainRange().ordinal()<<12 & getBufferNumber())<<8) & getTime())<<8) & getAdcValue() ;
+            }
+            
+            public static ReadoutRegisters decoded(int readout)
+            {
+                ReadoutRegisters registers = new ReadoutRegisters();
+                int adc_value = readout &          0xFF;
+                int time = readout &             0xFF00;
+                int buffer_number = readout & 0xFFF0000;
+                int gain_range = readout &   0x10000000;

-        for (Integer channel : electrode_charge.keySet())

+                registers.setAdcValue(adc_value);
+                registers.setTime(time);
+                registers.setBufferNumber(buffer_number);
+                registers.setGainRange(GainRange.values()[gain_range]);
+                
+                return registers;
+            }
+            
+        }
+        
+        ControlRegisters _control_registers;
+        
+        /** Creates a new instance of KpixChannel */
+        public KpixChannel(ControlRegisters control_registers)

-
-            double analog = electrode_charge.get(channel);
-
-            double gain = _high_gain;

+            _control_registers = control_registers;
+        }
+        
+        private int digitize(SiElectrodeData data)
+        {
+            return computeReadoutRegisters(data).encoded();
+        }
+        
+        private ReadoutRegisters computeReadoutRegisters(SiElectrodeData data)
+        {
+            ReadoutRegisters registers = new ReadoutRegisters();
+            registers.setTime(computeTime());
+            registers.setBufferNumber(computeBufferNumber());
+            registers.setGainRange(computeGainRange(data));
+            registers.setAdcValue(computeAdcValue(data,registers));

-            int digital = (int)Math.floor(analog * gain);
-           
-            if (digital != 0) digitized_charge.put(channel,digital);

+            return registers;
+        }
+        
+        private int computeTime()
+        {
+            return 0; // return all hits on bunch crossing 0 for now
+        }
+        
+        private int computeBufferNumber()
+        {
+            return 0; // return all hits in first buffer for now

-        return digitized_charge;

+        
+        private ReadoutRegisters.GainRange computeGainRange(SiElectrodeData data)
+        {
+            if (data.getCharge()*computeNormalFEGain(_control_registers) < _control_registers.getGainCrossover() )
+            {
+                return ReadoutRegisters.GainRange.NORMAL;
+            }
+            else
+            {
+                return ReadoutRegisters.GainRange.LOW;
+            }
+        }
+        
+        private int computeAdcValue(SiElectrodeData data, ReadoutRegisters readout_registers)
+        {
+            double gain = computeGain(readout_registers, _control_registers);
+            return (int)Math.floor(data.getCharge() * gain);
+        }
+        
+        
+        public static double computeGain(ReadoutRegisters readout_registers, ControlRegisters control_registers)
+        {
+            if (readout_registers.getGainRange() == ReadoutRegisters.GainRange.NORMAL)
+            {
+                return (int)Math.floor(computeNormalFEGain(control_registers)*ADC_GAIN);
+            }
+            else
+            {
+                return (int)Math.floor(computeLowFEGain(control_registers)*ADC_GAIN);
+            }
+        }
+        
+        public static double computeNormalFEGain(ControlRegisters control_registers)
+        {
+            double feedback_cap;
+            if (control_registers.getGainMode() == ControlRegisters.GainMode.SINGLE)
+            {
+                feedback_cap = NORMAL_GAIN_CAP;
+            }
+            else
+            {
+                feedback_cap = DOUBLE_GAIN_CAP;
+            }
+            return SystemOfUnits.e_SI/feedback_cap;
+        }
+        
+        public static double computeLowFEGain(ControlRegisters control_registers)
+        {
+            double feedback_cap;
+            if (control_registers.getGainMode() == ControlRegisters.GainMode.SINGLE)
+            {
+                feedback_cap = LOW_GAIN_CAP + NORMAL_GAIN_CAP;
+            }
+            else
+            {
+                feedback_cap = LOW_GAIN_CAP + DOUBLE_GAIN_CAP;
+            }
+            return SystemOfUnits.e_SI/feedback_cap;
+        }
+        
+        public static double computeNoise(double capacitance)
+        {
+            return NOISE_INTERCEPT + capacitance*NOISE_SLOPE;
+        }
+

Commit in `lcsim` on MAIN
`src/org/lcsim/contrib/RobKutschke/TKNHits/TKNRawHitsDriverV1.java`	+8	-13	1.1 -> 1.2
`src/org/lcsim/contrib/SiStripSim/SiElectrodeData.java`	+7	-5	1.3 -> 1.4
`/ReadoutChip.java`	+2	-1	1.3 -> 1.4
`/Kpix.java`	+306	-67	1.6 -> 1.7
`test/org/lcsim/detector/driver/TrackerDigitizationDriverTest.java`	+21	-10	1.2 -> 1.3
	+344	-96