float[][][][][] acct = new float[nx][ny][nz][npx][npy]; BasicHep3Vector pp = new BasicHep3Vector(0.,0.,0.); TransportState tst = new TransportState(); int ofx = (npx-1)/2; int ofy = (npy-1)/2;

+ if(doPrint) + { + System.out.println("we have final state pixel offsets X: "+tst.offsetX+" Y: "+tst.offsetY); + System.out.println("adding to central pixel offsets X: "+ofx+" Y: "+ofy); + System.out.println("And so adding hit to pxi :"+pxi+" pyi"+pyi); + }

+ finalstat[3]=nst; + if(doPrint) System.out.println("transport status is "+status+" after "+nst+" steps"); + if(doPrint) System.out.println("Equivalent point X: "+ep.x()+" Y: "+ep.y()+" Z: "+ep.z()); + if(doPrint) System.out.println("we have epOx: "+epOx+" and epOy "+epOy); + if(doPrint) System.out.println("So finalstat[0]="+finalstat[0]+" and finalstat[1]="+finalstat[1]);

+ for(int k=0; k<nnobns; k++) + { + sigmasr[i][j][k]=dpar[k]; + if(dpar[k] < 0.00001) System.out.println("sigmasr value is too small for i: "+i+" j: "+j+" k: "+k); + }

+ for(int k=0; k<nnobns; k++) + { + sigmasc[i][j][k]=dpar[k]; + if(dpar[k] < 0.00001) System.out.println("sigmasc value is too small for i: "+i+" j: "+j+" k: "+k); + }

+ int i=0; + int j=0; + int k=0; + if((sigmasr == null) || (sigmasc==null)) + { + System.out.println("Sensor in detector element "+dele.getName()+" does not have resolution tables!"); + } + for(i=0; i<ntlbns; i++) + { + for(j=0; j<ntabns; j++) + { + for(k=0; k<nnobns; k++) + { + if(sigmasr != null) + { + if(sigmasr[i][j][k] < 0.00001) + System.out.println("wrong table sigmasr element for i,j,k: "+i+" "+j+" "+k); + } + if(sigmasc != null) + { + if(sigmasc[i][j][k] < 0.00001) + System.out.println("wrong table sigmasc element for i,j,k: "+i+" "+j+" "+k); + } + } + } + }

+ if((sigrs < 0.0001) || (!(sigrs > 0.0001))) + { + System.out.println("Too small error in row: "+sigrs+" for tlb "+tlb+" tab "+tab+" snb "+snb+" dtl "+dtl+" dta "+dta+" dnf "+dnf); + System.out.println("interpolating between values:"); + System.out.println(" "+df.format(f[1])+" "+df.format(f[5])); + System.out.println(df.format(f[0])+" "+df.format(f[4])); + System.out.println(" "+df.format(f[3])+" "+df.format(f[7])); + System.out.println(df.format(f[2])+" "+df.format(f[6])); + }

+ if((sigcs < 0.0001) || (!(sigcs > 0.0001))) + { + System.out.println("Too small error in col.: "+sigcs+" for tlb "+tlb+" tab "+tab+" snb "+snb+" dtl "+dtl+" dta "+dta+" dnf "+dnf); + System.out.println("interpolating between values:"); + System.out.println(" "+df.format(f[1])+" "+df.format(f[5])); + System.out.println(df.format(f[0])+" "+df.format(f[4])); + System.out.println(" "+df.format(f[3])+" "+df.format(f[7])); + System.out.println(df.format(f[2])+" "+df.format(f[6])); + }

- if(sigcs < 0.0001) - System.out.println("Too small error in col."+sigcs+" for tlb "+tlb+" tab "+tab+" snb "+snb+" dtl "+dtl+" dta "+dta+" dnf "+dnf); - if(sigrs < 0.0001) - System.out.println("Too small error in row "+sigrs+" for tlb "+tlb+" tab "+tab+" snb "+snb+" dtl "+dtl+" dta "+dta+" dnf "+dnf);

+ + public int getMinTimeStamp() + { + int mts = 0; + boolean first=true; + for(RawTrackerHit rth:hits) + { + short[] adv = rth.getADCValues(); + if(adv.length == 3) + { + int ts = adv[2]; + if(first) mts=ts; + first=false; + if(ts < mts) mts=ts; + } + } + return mts; + }

public static final double BunchInterval = 369.* nanosecond; // nominal public static final double BunchIntervalA = 180.* nanosecond; // minimum - var A public static final double BunchIntervalB = 500.* nanosecond; // maximum - var B

public static final int NumberOfBunchesInTrain = 2625; // nominal public static final int NumberOfBunchesInTrainA = 5340; // var A = min interval and max number public static final int NumberOfBunchesInTrainB = 1260; // var B = max interval and min number

public static final double BunchTrainDuration = NumberOfBunchesInTrain * BunchInterval; // nominal public static final double BunchTrainDurationA = NumberOfBunchesInTrainA * BunchIntervalA; public static final double BunchTrainDurationB = NumberOfBunchesInTrainB * BunchIntervalB;

+ public void setTimeWindow(int tw) { t_window=tw; } // time window to accept cluster if there is time + // stamp. Expressed in time stamp units (usualy BC) +

lcsim/src/org/lcsim/recon/vertexing/pixsim

PixilatedSensorManager.java 1.4 -> 1.5

diff -u -r1.4 -r1.5
--- PixilatedSensorManager.java	17 Dec 2010 21:48:45 -0000	1.4
+++ PixilatedSensorManager.java	29 Dec 2010 22:29:37 -0000	1.5
@@ -21,7 +21,7 @@

  * for each event (only sensors which have hits in them are created)
  *
  * @author Nick Sinev

- * @version $Id: PixilatedSensorManager.java,v 1.4 2010/12/17 21:48:45 sinev Exp $

+ * @version $Id: PixilatedSensorManager.java,v 1.5 2010/12/29 22:29:37 sinev Exp $

  */
 
 public class PixilatedSensorManager extends Driver

@@ -32,13 +32,21 @@

  boolean read_rest_bar=true;
  boolean read_rest_ec=true;
  boolean incl_el_noise = false;

- boolean ready = false;

+ boolean ready = false;
+ boolean digital = false;

  static PixSimConstants cons = PixSimConstants.instance();
  static final int MAXHTSPEV = 100000;

+ static IlcOption ilcopt = IlcOption.NOMINAL;

  private static final double bunch_period = cons.BunchInterval;

+ private static double thr_to_noise_ratio = 5.;
+ private static double adc_scale_bar = 25.;
+ private static double adc_scale_ec = 25.;

  private static int phys_bc = 0;

+ private static int time_window = 1;

  private static int cluster_thr_barr = 8;

- private static int cluster_thr_ec = 8;

+ private static int cluster_thr_ec = 8;
+ private static int pixel_thr_barr = 4;
+ private static int pixel_thr_ec = 4;

  private static boolean firstcall = true;
  private static boolean assign_bc = true;
  private static double enoise = 50.;

@@ -100,8 +108,19 @@

  private static boolean ec_pl_ec_mi_same_prop = true;
 
 // here we have arrays of all settable variables for different sensor options

- private static int[] opt_cluster_thr_barr = {8,1,8,1,1,1,1,1,1,8};
- private static int[] opt_cluster_thr_ec =  {8,1,8,1,1,1,1,1,1,8};

+ private static int[] opt_cluster_thr_barr = {8,6,8,1,1,1,1,1,1,8};
+ private static int[] opt_pixel_thr_barr = {4,3,4,1,1,1,1,1,1,4};
+ private static int[] opt_cluster_thr_ec =  {8,6,8,1,1,1,1,1,1,8};
+ private static int[] opt_pixel_thr_ec = {4,3,4,1,1,1,1,1,1,4};
+ private static double[] opt_lor_cor_b_x = {0.001,0.0065,0.001,0.001,0.0005,0.0005,0.0005,0.0003,0.0003,0.0003};
+ private static double[] opt_lor_cor_b_y = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ private static double[] opt_lor_cor_b_z = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ private static double[] opt_lor_cor_ep_x = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ private static double[] opt_lor_cor_ep_y = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ private static double[] opt_lor_cor_ep_z = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ private static double[] opt_lor_cor_em_x = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ private static double[] opt_lor_cor_em_y = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
+ private static double[] opt_lor_cor_em_z = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};

  private static boolean[] opt_prop_tab_barrel_local = {false,false,false,true,true,true,true,true,true,true};
  private static boolean[] opt_prop_tab_ec_pl_local = {false,false,false,true,true,true,true,true,true,true};
  private static boolean[] opt_prop_tab_ec_mi_local = {false,false,false,true,true,true,true,true,true,true};

@@ -110,10 +129,11 @@

  private static boolean[] opt_res_tab_ec_mi_local = {false,false,false,true,true,true,true,true,true,true};
  private static boolean[] opt_ec_bar_same_prop = {false,false,false,false,false,false,false,false,false,false};
  private static boolean[] opt_ec_pl_ec_mi_same_prop = {true,true,true,true,true,true,true,true,true,true};

+ private static boolean[] is_digital = {false,true,false,true,true,true,true,true,true,true};

 
  private static String[] opt_bar_prop_tname = 
  {"CCD_20x20x20_B5_propagator.dat",

-  "CCD_20x20x20_B5_propagator.dat",

+  "Chronopix_20x20x20_hr_B5_Barr_propagator.dat",

   "CCD_20x20x20_B5_propagator.dat",
   "CCD_20x20x20_B5_propagator.dat",
   "Chronopix_8x8x20hr_B5_Barr_propagator.dat",

@@ -126,7 +146,7 @@

 
  private static String[] opt_ec_pl_prop_tname = 
  {"CCD_20x20x20_B5_EC_propagator.dat",

-  "CCD_20x20x20_B5_EC_propagator.dat",

+  "Chronopix_20x20x20_hr_B5_EC_propagator.dat",

   "CCD_20x20x20_B5_EC_propagator.dat",
   "CCD_20x20x20_B5_EC_propagator.dat",
   "Chronopix_8x8x20_B5_EC_propagator.dat",

@@ -152,7 +172,7 @@

 
  private static String[] opt_rtab_name_bar = 
  {"CCD_20x20x20_B5_res_bar.dat",

-  "CCD_20x20x20_B5_res_bar.dat",

+  "Chronopix_20x20x20_hr_B5_res_bar.dat",

   "CPCCD_20x20x20_B5_res_bar.dat",
   "ShortColCCD_20x20x20_B5_res_bar.dat",
   "Chronopix_8x8x20hr_B5_res_bar.dat",

@@ -165,7 +185,7 @@

 
  private static String[] opt_rtab_name_ec_pl=
  {"CCD_20x20x20_B5_res_ec.dat",

-  "CCD_20x20x20_B5_res_ec.dat",

+  "Chronopix_20x20x20_hr_B5_res_ec.dat",

   "CPCCD_20x20x20_B5_res_ec.dat",
   "ShortColCCD_20x20x20_B5_res_ec.dat",
   "Chronopix_8x8x20hr_B5_res_ec.dat",

@@ -178,7 +198,7 @@

 
  private static String[] opt_rtab_name_ec_mi = 
  {"CCD_20x20x20_B5_res_ec.dat",

-  "CCDd_20x20x20_B5_res_ec.dat",

+  "Chronopix_20x20x20_B5_res_ec.dat",

   "CPCCD_20x20x20_B5_res_ec.dat",
   "ShortColCCD_20x20x20_B5_res_ec.dat",
   "Chronopix_8x8x20hr_B5_res_ec.dat",

@@ -241,7 +261,7 @@

  public PixilatedSensorManager(SensorOption opt, boolean usetable)
  {
   if(opt == SensorOption.ClassicCCD) option = 0;

-  if(opt == SensorOption.ClassicCCDdigit) option = 1;

+  if(opt == SensorOption.Chrono20x20x20) option = 1;

   if(opt == SensorOption.CPCCD) option = 2;
   if(opt == SensorOption.ShortColumnCCD) option = 3;
   if(opt == SensorOption.Chrono8x8x20) option = 4;

@@ -253,13 +273,168 @@

   use_prop_tab_barrel = usetable;
   use_prop_tab_ec_pl = usetable;
   use_prop_tab_ec_mi = usetable;

+  setOptionVariables();
+ }
+
+// Setters
+
+ public void setIlcOption(IlcOption opt) { ilcopt = opt; if(opt==IlcOption.CLIC) time_window=50; }
+
+ public void setTimeWindow(int tw) { time_window=tw; } 
+
+ public void includeElectronicsNoiseHits(boolean yes) { incl_el_noise=yes; }
+
+ public void setThresholdToNoiseRatio(double ratio) { thr_to_noise_ratio=ratio; }
+
+ public void setPixelThreshold( int thr) { pixel_thr_barr = thr; pixel_thr_ec = thr; }
+
+ public void setPixelThresholdBarrel( int thr) { pixel_thr_barr = thr; }
+
+ public void setPixelThresholdEndcap( int thr) { pixel_thr_ec = thr; }
+
+ public void setClusterThreshold( int thr) { cluster_thr_barr = thr; cluster_thr_ec = thr;}
+
+ public void setClusterThresholdBarrel( int thr) { cluster_thr_barr = thr; }
+
+ public void setClusterThresholdEndcap( int thr) { cluster_thr_ec = thr; }
+
+ public void setNoiseLevel(double noise) { enoise=noise; }
+
+ public void setADCscale(double scale) { adc_scale_bar = scale; adc_scale_ec=scale;}
+
+ public void setADCscaleEndcap(double scale) { adc_scale_ec=scale;}
+
+ public void setADCscaleBarrel(double scale) { adc_scale_bar = scale; }
+
+ public void setDigitalReadout(boolean yes) { digital=yes; }
+
+ public void setPhysicsBeamCrossing(int bc) { phys_bc=bc; }
+
+ public void setBarrelElectronics(IPixelSensorElectronics el) { bar_el=el; } 
+ 
+ public void setEndcapElectronics(IPixelSensorElectronics el) { ecp_el=el; ecm_el=el; }
+
+ public void setEndcapPlusElectronics(IPixelSensorElectronics el) { ecp_el=el; }
+
+ public void setEndcapMinusElectronics(IPixelSensorElectronics el) { ecm_el=el; }
+
+ public void useLocalPropagatorTables(boolean local)
+ {
+  prop_tab_barrel_local = local;
+  prop_tab_ec_pl_local = local;
+  prop_tab_ec_mi_local = local;
+ }
+
+ public void useLocalResolutionTables(boolean local)
+ {
+  res_tab_barrel_local = local;
+  res_tab_ec_pl_local = local;
+  res_tab_ec_mi_local = local;
+
+ } 
+
+ public void calibrateBarrelResolution(boolean yes, int stat, String fname)
+ {
+  calibr_stat_b = stat;
+  rtab_name_bar = fname;
+  cal_res_bar=yes;
+  read_rest_bar=false;
+ }
+
+ public void calibrateEndcapResolution(boolean yes,int stat, String fnamepl, String fnamemi)
+ {
+  calibr_stat_ep = stat;
+  calibr_stat_em = stat;
+  rtab_name_ec_pl = fnamepl;
+  rtab_name_ec_mi = fnamemi;
+  cal_res_ec=yes;
+  read_rest_ec=false;
+ }
+
+ public void calibrateEndcapResolution(boolean yes,int stat, String fname)
+ {
+  calibr_stat_ep = stat;
+  calibr_stat_em = stat;
+  rtab_name_ec_pl = fname;
+  rtab_name_ec_mi = fname;
+  cal_res_ec=yes;
+  read_rest_ec=false;
+  if(!ec_pl_ec_mi_same_prop) 
+   System.out.println("Warning!Propagators for plus and minus ec are different! Can't use same resolution table!");
+ }
+
+ public void usePropagatorTable(String tname)
+ {
+  bar_prop_tname = tname;
+  use_prop_tab_barrel = true;
+  use_prop_tab_ec_pl = false;
+  use_prop_tab_ec_mi = false;
+  if(!ec_bar_same_prop) System.out.println("Propagators for barrel and ec are different - can't use same table!");
+  if(ec_bar_same_prop) 
+  { 
+   if(!ec_pl_ec_mi_same_prop) System.out.println("Propagators for plus and minus ec are different - can't use same table!");  
+   if(ec_pl_ec_mi_same_prop)
+   {
+    use_prop_tab_ec_pl = true;
+    use_prop_tab_ec_mi = true;
+   } 
+  }
+ }  
+
+ public void usePropagatorTables(String btname, String etname)
+ {
+  bar_prop_tname = btname;
+  ec_pl_prop_tname = etname;
+  use_prop_tab_barrel = true;
+  use_prop_tab_ec_pl = true;
+  if(!ec_pl_ec_mi_same_prop) System.out.println("Propagators for plus and minus ec are different - can't use same table!");  
+  if(ec_pl_ec_mi_same_prop)
+  {
+   use_prop_tab_ec_mi = true;
+  }
+ }
+
+// getters
+
+ public List<IDetectorElement> getBarrelDetectorElements()
+ {
+   return vxbrels;

+ public List<IDetectorElement> getEndcapPlusDetectorElements()
+ {
+   return vxecpels;
+ }
+
+ public List<IDetectorElement> getEndcapMinusDetectorElements()
+ {
+   return vxecmels;
+ }
+
+ public List<PixilatedSensor> getBarrelSensors()
+ {
+   return psbrl;
+ } 
+
+ public List<PixilatedSensor> getEndcapPlusSensors()
+ {
+   return psecpl;
+ }
+ 
+ public List<PixilatedSensor> getEndcapMinusSensors()
+ {
+   return psecml;
+ }
+
+
+
+
+// private functions
+

   private void setup()
   {
    if(option == 0)
    {

-    setOptionVariables();

     IPixelSensorElectronics el = new CCDElectronics();
     el.includeElectronicNoiseHits(incl_el_noise);
     el.setADCScale(25.);

@@ -280,19 +455,46 @@

    }
    if(option == 1)
    {

-    setOptionVariables();
-    IPixelSensorElectronics el = new CCDElectronics();

+    IPixelSensorElectronics el=null;
+    if(!digital) el = new CCDElectronics();
+    if(digital) el = new ChronoPixelElectronics(ilcopt);

     el.includeElectronicNoiseHits(incl_el_noise);

-    el.setADCScale(140.);
-    el.setNoiseLevel(enoise);
-    el.setADCSaturation(1);
-    el.setBunchesPerClock(30); // this is about maximum clock image speed (100 KHz) for classic CCD - asuming 50MHz speed in R register
-                              // for VXD3 CCD we would set this value to 300 (10 KHz image clock and 5 MHz R register speed)

+    if(digital)
+    {
+     el.setADCScale(enoise*thr_to_noise_ratio);
+     el.setNoiseLevel(enoise);
+     el.setADCSaturation(1);
+     el.useCorrelatedDoubleSampling(false);
+    }
+    if(!digital)
+    {
+     el.setNoiseLevel(enoise);
+     el.setADCSaturation(255);
+     el.useCorrelatedDoubleSampling(true);
+    }
+    el.setBunchesPerClock(1);

     el.useCorrelatedDoubleSampling(false);

-    el.setPixelThreshold(1);

     bar_el = el;
     ecp_el = el;
     ecm_el = el;

+    if(!digital)
+    {
+     bar_el.setADCScale(adc_scale_bar);
+     bar_el.setPixelThreshold(pixel_thr_barr);
+     ecp_el.setADCScale(adc_scale_ec);
+     ecm_el.setADCScale(adc_scale_ec);
+     ecp_el.setPixelThreshold(pixel_thr_ec);
+     ecm_el.setPixelThreshold(pixel_thr_ec);
+     opt_lor_cor_b_x[option]=0.00556;
+    } 
+    if(digital)
+    {
+     bar_el.setPixelThreshold(1);
+     ecp_el.setPixelThreshold(1);
+     ecm_el.setPixelThreshold(1);
+     cluster_thr_barr=1;
+     cluster_thr_ec=1;
+    }

     bpcf = new PixelConfiguration();
     bcpr = new CarrierPropagator(bpcf);
     ecppr = new CarrierPropagator(bpcf);

@@ -301,7 +503,6 @@

    }
    if(option == 2)
    {

-    setOptionVariables();

     IPixelSensorElectronics el = new CCDElectronics();
     el.includeElectronicNoiseHits(incl_el_noise);
     el.setADCScale(25.);

@@ -335,114 +536,12 @@

   rtab_name_ec_mi = opt_rtab_name_ec_mi[option];
   cluster_thr_barr = opt_cluster_thr_barr[option];
   cluster_thr_ec = opt_cluster_thr_ec[option];

+  pixel_thr_barr = opt_pixel_thr_barr[option];
+  pixel_thr_ec = opt_pixel_thr_ec[option];
+  digital = is_digital[option];

- public void includeElectronicsNoiseHits(boolean yes) { incl_el_noise=yes; }
-
- public void setNoiseLevel(double noise) { enoise=noise; }
-
- public List<IDetectorElement> getBarrelDetectorElements()
- {
-   return vxbrels;
- }
- 
- public List<IDetectorElement> getEndcapPlusDetectorElements()
- {
-   return vxecpels;
- }
-
- public List<IDetectorElement> getEndcapMinusDetectorElements()
- {
-   return vxecmels;
- }
-
- public List<PixilatedSensor> getBarrelSensors()
- {
-   return psbrl;
- } 
-
- public List<PixilatedSensor> getEndcapPlusSensors()
- {
-   return psecpl;
- }
- 
- public List<PixilatedSensor> getEndcapMinusSensors()
- {
-   return psecml;
- }
-
- public void setPhysicsBeamCrossing(int bc)
- {
-  phys_bc=bc;
- }
-
- public void setBarrelElectronics(IPixelSensorElectronics el)
- {
-  bar_el=el;
- } 
- 
- public void setEndcapElectronics(IPixelSensorElectronics el)
- {
-  ecp_el=el;
-  ecm_el=el;
- }
-
- public void setEndcapPlusElectronics(IPixelSensorElectronics el)
- {
-  ecp_el=el;
- }
-
- public void setEndcapMinusElectronics(IPixelSensorElectronics el)
- {
-  ecm_el=el;
- }
-
- public void calibrateBarrelResolution(boolean yes, int stat, String fname)
- {
-  calibr_stat_b = stat;
-  rtab_name_bar = fname;
-  cal_res_bar=yes;
- }
-
- public void calibrateEndcapResolution(boolean yes,int stat, String fnamepl, String fnamemi)
- {
-  calibr_stat_ep = stat;
-  calibr_stat_em = stat;
-  rtab_name_ec_pl = fnamepl;
-  rtab_name_ec_mi = fnamemi;
-  cal_res_ec=yes;
- }
-
- public void usePropagatorTable(String tname)
- {
-  bar_prop_tname = tname;
-  use_prop_tab_barrel = true;
-  use_prop_tab_ec_pl = false;
-  use_prop_tab_ec_mi = false;
-  if(!ec_bar_same_prop) System.out.println("Propagators for barrel and ec are different - can't use same table!");
-  if(ec_bar_same_prop) 
-  { 
-   if(!ec_pl_ec_mi_same_prop) System.out.println("Propagators for plus and minus ec are different - can't use same table!");  
-   if(ec_pl_ec_mi_same_prop)
-   {
-    use_prop_tab_ec_pl = true;
-    use_prop_tab_ec_mi = true;
-   } 
-  }
- }  
-
- public void usePropagatorTables(String btname, String etname)
- {
-  bar_prop_tname = btname;
-  ec_pl_prop_tname = etname;
-  use_prop_tab_barrel = true;
-  use_prop_tab_ec_pl = true;
-  if(!ec_pl_ec_mi_same_prop) System.out.println("Propagators for plus and minus ec are different - can't use same table!");  
-  if(ec_pl_ec_mi_same_prop)
-  {
-   use_prop_tab_ec_mi = true;
-  }
- }

+ // driver process function

   
  public void process(EventHeader event)
  {

@@ -593,14 +692,22 @@

    { 
     if(res_tab_barrel_local) eeb.readTable(rtab_name_bar);
     else eeb.readTable(rtab_name_bar,det);

-   }

+   }
+   BasicHep3Vector Lor_corr = new BasicHep3Vector(0.,0.,0.);

    for(IDetectorElement de:vxbrels)
    {
     PixilatedSensor pse = new PixilatedSensor(de,bcpr,false);
     pse.setElectronics(bar_el);
     pse.setErrorEstimate(eeb);

-    pse.setClusterThreshold(cluster_thr_barr);  
-    if(nbe==0 && cal_res_bar) pse.calibrateErrorEstimate(calibr_stat_b,rtab_name_bar);

+    pse.setClusterThreshold(cluster_thr_barr);
+    pse.setTimeWindow(time_window);  
+    Lor_corr.setV(opt_lor_cor_b_x[option],opt_lor_cor_b_y[option],opt_lor_cor_b_z[option]);
+    pse.setLorentzCorrection(Lor_corr);  
+    if(nbe==0 && cal_res_bar)
+    { 
+     eeb.setTableParameters(11,11,11,0.,1.5,0.,1.5,1.5,6.5);
+     pse.calibrateErrorEstimate(calibr_stat_b,rtab_name_bar);
+    }

     nbe++; 
     psbrl.add(pse);
    }

@@ -615,33 +722,44 @@

     PixilatedSensor pse = new PixilatedSensor(de,ecppr,true); 
     pse.setElectronics(ecp_el);
     pse.setErrorEstimate(eeep);

-    pse.setClusterThreshold(cluster_thr_ec);  
-    eeep.setTableParameters(11,11,11,0.,1.5,0.,1.5,2.2,7.2);
-    if(nbc==0 && cal_res_ec) pse.calibrateErrorEstimate(calibr_stat_ep,rtab_name_ec_pl);

+    pse.setClusterThreshold(cluster_thr_ec);
+    pse.setTimeWindow(time_window);  
+    Lor_corr.setV(opt_lor_cor_ep_x[option],opt_lor_cor_ep_y[option],opt_lor_cor_ep_z[option]);
+    pse.setLorentzCorrection(Lor_corr);  
+    if(nbc==0 && cal_res_ec)
+    {
+     eeep.setTableParameters(11,11,11,0.,1.5,0.,1.5,1.5,6.5);
+     pse.calibrateErrorEstimate(calibr_stat_ep,rtab_name_ec_pl);
+    }

     nbc++; 
     psecpl.add(pse);
    }     
    int nbcm = 0;

-   if((read_rest_ec)&&(!ec_pl_ec_mi_same_prop))  eeem.readTable(rtab_name_ec_mi);
-   if(ec_pl_ec_mi_same_prop) eeem=eeep;
-   else

+   if((read_rest_ec)&&(!ec_pl_ec_mi_same_prop))

-    if(read_rest_ec)
-    {
-     if(res_tab_ec_mi_local) eeem.readTable(rtab_name_ec_mi);
-     else eeem.readTable(rtab_name_ec_mi,det);
-    }

+    if(res_tab_ec_mi_local) eeem.readTable(rtab_name_ec_mi);
+    else eeem.readTable(rtab_name_ec_mi,det);

+   if(ec_pl_ec_mi_same_prop) eeem=eeep;

    for(IDetectorElement de:vxecmels)
    {
     PixilatedSensor pse = new PixilatedSensor(de,ecmpr,true); 
     pse.setElectronics(ecm_el);
     pse.setErrorEstimate(eeem);
     pse.setClusterThreshold(cluster_thr_ec);

+    pse.setTimeWindow(time_window);  
+    Lor_corr.setV(opt_lor_cor_em_x[option],opt_lor_cor_em_y[option],opt_lor_cor_em_z[option]);
+    pse.setLorentzCorrection(Lor_corr);

     if(!ec_pl_ec_mi_same_prop)

-    { 
-     eeem.setTableParameters(11,11,11,0.,1.5,0.,1.5,2.2,7.2);
-     if(nbcm==0 && cal_res_ec) pse.calibrateErrorEstimate(calibr_stat_em,rtab_name_ec_mi);

+    {
+     if(!read_rest_ec)
+     {
+      if(nbcm==0 && cal_res_ec)
+      {
+       eeem.setTableParameters(11,11,11,0.,1.5,0.,1.5,1.5,6.5);
+       pse.calibrateErrorEstimate(calibr_stat_ep,rtab_name_ec_mi);
+      }
+     }

     }
     nbcm++; 
     psecml.add(pse);

Commit in `lcsim/src/org/lcsim/recon/vertexing/pixsim` on MAIN
`CarrierPropagator.java`	+31	-10	1.2 -> 1.3
`ChronoPixelElectronics.java`	+14	-10	1.1 -> 1.2
`ErrorEstimate.java`	+73	-20	1.1 -> 1.2
`IlcOption.java`	+2	-2	1.1 -> 1.2
`PixCluster.java`	+21	-3	1.1 -> 1.2
`PixSimConstants.java`	+5	-1	1.1 -> 1.2
`PixilatedSensor.java`	+6	-1	1.3 -> 1.4
`PixilatedSensorManager.java`	+262	-144	1.4 -> 1.5
`SensorOption.java`	+2	-2	1.2 -> 1.3
	+416	-193