diff --git a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/CLASDecoder.java b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/CLASDecoder.java
index 3d32f87807..275b434dae 100644
--- a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/CLASDecoder.java
+++ b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/CLASDecoder.java
@@ -217,34 +217,38 @@ public Bank getDataBankADC(String name, DetectorType type){
         List<DetectorDataDgtz> adcDGTZ = this.getEntriesADC(type);
         if (adcDGTZ.isEmpty()) return null;
 
-        Bank adcBANK = new Bank(schemaFactory.getSchema(name), adcDGTZ.size());
-
+        Bank adcBANK = new Bank(schemaFactory.getSchema(name),
+                adcDGTZ.stream().mapToInt(b -> b.getADCSize()).sum());
+       
+        int row = 0;
         for(int i = 0; i < adcDGTZ.size(); i++){
-            adcBANK.putByte( 0, i, (byte) adcDGTZ.get(i).getDescriptor().getSector());
-            adcBANK.putByte( 1, i, (byte) adcDGTZ.get(i).getDescriptor().getLayer());
-            adcBANK.putShort(2, i, (short) adcDGTZ.get(i).getDescriptor().getComponent());
-            adcBANK.putByte( 3, i, (byte) adcDGTZ.get(i).getDescriptor().getOrder());
-            adcBANK.putInt(  4, i, adcDGTZ.get(i).getADCData(0).getADC());
-            if (type == DetectorType.BMT || type == DetectorType.FMT || type == DetectorType.FTTRK) {
-            	adcBANK.putInt( 4, i, adcDGTZ.get(i).getADCData(0).getHeight());
-            	adcBANK.putInt( 7, i, adcDGTZ.get(i).getADCData(0).getIntegral());
-            	adcBANK.putLong(8, i, adcDGTZ.get(i).getADCData(0).getTimeStamp());
-            }
-            if(type == DetectorType.BAND) {
-                adcBANK.putInt(  5, i, adcDGTZ.get(i).getADCData(0).getHeight());
-                adcBANK.putFloat(6, i, (float) adcDGTZ.get(i).getADCData(0).getTime());
-                adcBANK.putShort(7, i, (short) adcDGTZ.get(i).getADCData(0).getPedestal());
-            }
-            else {
-                adcBANK.putFloat(5, i, (float) adcDGTZ.get(i).getADCData(0).getTime());
-                adcBANK.putShort(6, i, (short) adcDGTZ.get(i).getADCData(0).getPedestal());
+            for (int j = 0; j<adcDGTZ.get(i).getADCSize(); j++) {
+                adcBANK.putByte( 0, row, (byte) adcDGTZ.get(i).getDescriptor().getSector());
+                adcBANK.putByte( 1, row, (byte) adcDGTZ.get(i).getDescriptor().getLayer());
+                adcBANK.putShort(2, row, (short) adcDGTZ.get(i).getDescriptor().getComponent());
+                adcBANK.putByte( 3, row, (byte) adcDGTZ.get(i).getDescriptor().getOrder());
+                adcBANK.putInt(  4, row, adcDGTZ.get(i).getADCData(j).getADC());
+                if (type == DetectorType.BMT || type == DetectorType.FMT || type == DetectorType.FTTRK) {
+                    adcBANK.putInt( 4, row, adcDGTZ.get(i).getADCData(j).getHeight());
+                    adcBANK.putInt( 7, row, adcDGTZ.get(i).getADCData(j).getIntegral());
+                    adcBANK.putLong(8, row, adcDGTZ.get(i).getADCData(j).getTimeStamp());
+                }
+                if(type == DetectorType.BAND) {
+                    adcBANK.putInt(  5, row, adcDGTZ.get(i).getADCData(j).getHeight());
+                    adcBANK.putFloat(6, row, (float) adcDGTZ.get(i).getADCData(j).getTime());
+                    adcBANK.putShort(7, row, (short) adcDGTZ.get(i).getADCData(j).getPedestal());
+                }
+                else {
+                    adcBANK.putFloat(5, row, (float) adcDGTZ.get(i).getADCData(j).getTime());
+                    adcBANK.putShort(6, row, (short) adcDGTZ.get(i).getADCData(j).getPedestal());
+                }
+                if(type == DetectorType.BST) adcBANK.putLong(7, row, adcDGTZ.get(i).getADCData(j).getTimeStamp());
+                row++;
             }
-            if(type == DetectorType.BST) adcBANK.putLong(7, i, adcDGTZ.get(i).getADCData(0).getTimeStamp());
-         }
+        }
         return adcBANK;
     }
 
-
     public Bank getDataBankTDC(String name, DetectorType type){
 
         List<DetectorDataDgtz> tdcDGTZ = this.getEntriesTDC(type);
diff --git a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/DetectorEventDecoder.java b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/DetectorEventDecoder.java
index 20a2a64739..2265b36259 100644
--- a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/DetectorEventDecoder.java
+++ b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/DetectorEventDecoder.java
@@ -217,19 +217,32 @@ private void fitPulses(DetectorDataDgtz data, IndexedTable cfg) {
         final int nadc = data.getADCSize();
         for (int i = 0; i < nadc; i++) {
             ADCData adc = data.getADCData(i);
-            if(adc.getPulseSize()>0){
+            if (adc.getPulseSize() > 0) {
                 try {
-                    extendedFitter.fit(nsa, nsb, tet, ped, adc.getPulseArray());
+                    ExtendedFADCFitter[] hits = extendedFitter.multiFit(nsa, nsb, tet, ped, adc.getPulseArray());
+                    // the first hit is treated conventionally:
+                    adc.setIntegral(hits[0].adc + hits[0].ped*(nsa+nsb));
+                    adc.setHeight((short) hits[0].pulsePeakValue);
+                    adc.setTimeWord(hits[0].t0);
+                    adc.setPedestal((short) hits[0].ped);
+                    adc.setADC(nsa, nsb);
+                    // and extra hits get a new object here:
+                    for (int j = 1; j < hits.length; j++) {
+                        ADCData a = new ADCData();
+                        a.setOrder(adc.getOrder());
+                        a.setIntegral(hits[j].adc + hits[j].ped*(nsa+nsb));
+                        a.setHeight((short) hits[j].pulsePeakValue);
+                        a.setTimeWord(hits[j].t0);
+                        a.setPedestal((short) hits[j].ped);
+                        a.setADC(nsa, nsb);
+                        data.addADC(a);
+                    }
                 } catch (Exception e) {
+                    e.printStackTrace();
                     System.err.println(">>>> error : fitting pulse "+dd.getCrate()+
                         " / "+dd.getSlot()+" / "+dd.getChannel());
                 }
-                adc.setIntegral(extendedFitter.adc + extendedFitter.ped*(nsa+nsb));
-                adc.setHeight((short) this.extendedFitter.pulsePeakValue);
-                adc.setTimeWord(this.extendedFitter.t0);
-                adc.setPedestal((short) this.extendedFitter.ped);
             }
-            data.getADCData(i).setADC(nsa, nsb);
         }
     }
 
diff --git a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter.java b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter.java
index 245c5c84d8..1c513d56b7 100644
--- a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter.java
+++ b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter.java
@@ -17,9 +17,7 @@ public class ExtendedFADCFitter implements IFADCFitter {
     public double  baseline, rms;
     private int    tcourse, tfine;
 
-    public ExtendedFADCFitter(){
-        
-    }
+    public ExtendedFADCFitter(){}
 
     public void fitCourseTime(int nsa, int nsb, int tet, int pedr, short[] pulse) {
         pedsum=0;adc=0;mmsum=0;summing_in_progress=0;
@@ -121,45 +119,10 @@ public void fit(int nsa, int nsb, int tet, int pedr, short[] pulse) {
             }
         }
     }
-    
-    private double findPedestal(DetectorDataDgtz.ADCData data){
-        int ped = 0;
-        for(int i = this.pedistalMinBin; i < this.pedistalMaxBin; i++){
-            ped += data.getPulseValue(i);
-        }
-        double ped_norm =   ((double) ped) / (Math.abs(this.pedistalMaxBin-this.pedistalMinBin));
-        return ped_norm;
-    }
-    
-    private int findMaximumADC(DetectorDataDgtz.ADCData data){
-        int bin = this.pedistalMaxBin ;
-        int max = data.getPulseValue(pedistalMaxBin);
-        
-        for(int i = this.pedistalMaxBin; i < data.getPulseSize(); i++){
-            if(data.getPulseValue(i)>max){
-                max = data.getPulseValue(i);
-                bin = i;
-            }
-        }
-        return bin;
-    }
-    
-    private int findPulseIntegral(DetectorDataDgtz.ADCData data, int maxValueBin, int nsa, int nsb){
-        int min_bin = maxValueBin - nsb;
-        int max_bin = maxValueBin + nsa;
-        if(min_bin>=0&&max_bin<data.getPulseSize()){
-            
-        } else {
-            System.out.println("MIN _ MAX out of range....");            
-        }
-        return 0;
-    }
 
     @Override
     public void fit(DetectorDataDgtz.ADCData data) {
-        if(data.getPulseSize()>this.pedistalMaxBin){
-            double ped = this.findPedestal(data);
-        }
+        throw new UnsupportedOperationException("Not supported yet.");
     }
-
+    
 }
diff --git a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter1.java b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter1.java
new file mode 100644
index 0000000000..1e5eed8d51
--- /dev/null
+++ b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter1.java
@@ -0,0 +1,116 @@
+package org.jlab.detector.decode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExtendedFADCFitter1 implements IFADCFitter {
+    
+    static final int PED_BIN1=1;
+    static final int PED_BIN2=15;
+
+    public int     t0, adc, ped, pedsum, tcourse, tfine;
+    public int     thresholdCrossing, pulsePeakValue, pulsePeakPosition, pulseWidth;
+    public double  baseline, rms;
+    
+    public ExtendedFADCFitter1(){}
+    
+    public ExtendedFADCFitter1[] multiFit(int nsa, int nsb, int tet, int pedr, short[] pulse) {
+
+        t0=0; adc=0; ped=0; pedsum=0; baseline=0; rms=0; tcourse=0; tfine=0;
+        thresholdCrossing=0; pulsePeakValue=0; pulsePeakPosition=0; pulseWidth=0;
+
+        if (pedr != 0) {
+            // user-defined pedestal:
+            ped = pedr;
+        }
+        else {
+            // not enough samples, just set pedestal and abort:
+            if (pulse.length<PED_BIN2+1) {
+                for (int bin = 0; bin < pulse.length; bin++)
+                    pedsum += pulse[bin];
+                ped=pedsum/pulse.length;
+                return null;
+            }
+            // calculate pedestal:
+            for (int bin = PED_BIN1+1; bin < PED_BIN2+1; bin++) {
+                pedsum += pulse[bin];
+                rms  += pulse[bin] * pulse[bin];
+            }
+            baseline = ((double) pedsum)/ (PED_BIN2 - PED_BIN1);
+            ped = pedsum=pedsum/(PED_BIN2-PED_BIN1);	//(int) baseline;
+            rms = Math.sqrt(rms / (PED_BIN2 - PED_BIN1) - baseline * baseline);
+        }
+        
+        List<ExtendedFADCFitter1> hits = null;
+        boolean belowThreshold = false;
+
+        for (int crossBin = PED_BIN2+1; crossBin<pulse.length; crossBin++) {
+            
+            // mark that we went below theshold:
+            if (pulse[crossBin] <= ped+tet) belowThreshold = true;
+            
+            // we went below and above theshold again:
+            else if (belowThreshold) {
+                
+                belowThreshold = false;
+                
+                // find the maximum:
+                for (int maxBin = crossBin; maxBin<pulse.length; maxBin++) {
+                    if (pulse[maxBin] < pulse[maxBin-1]) {
+                        
+                        // make a new hit:
+                        ExtendedFADCFitter1 f = new ExtendedFADCFitter1();
+                        f.ped = ped;
+                        f.thresholdCrossing = crossBin;
+                        f.pulsePeakPosition = maxBin-1;
+                        f.pulsePeakValue = pulse[maxBin-1];
+                        
+                        // define its energy:
+                        final int eLimit = Math.min(pulse.length, crossBin + nsa);
+                        for (int eBin = Math.max(crossBin-nsb,0); eBin < eLimit; eBin++)
+                            f.adc += pulse[eBin] - f.ped;
+                        
+                        // find the half-max crossing upwards:
+                        final double halfMax = (pulse[maxBin-1] + baseline)/2;
+                        for (int halfBinUp = crossBin+1; halfBinUp < maxBin; halfBinUp++) {
+                            if (pulse[halfBinUp] <= halfMax && pulse[halfBinUp+1] > halfMax) {
+                                
+                                // define timing:
+                                int a0 = pulse[halfBinUp];
+                                int a1 = pulse[halfBinUp+1];
+                                f.tcourse = halfBinUp;
+                                f.tfine   = ((int) ((halfMax - a0)/(a1-a0) * 64));
+                                f.t0      = (tcourse << 6) + tfine;
+                                
+                                // find the half-max crossing downwards:
+                                for (int halfBinDown = halfBinUp; halfBinDown<pulse.length; halfBinDown++) {
+                                    if (pulse[halfBinDown] > halfMax && pulse[halfBinDown+1] <= halfMax) {
+                                        f.pulseWidth = halfBinDown - halfBinUp;
+                                        break;
+                                    }
+                                }
+                                break;
+                            }
+                        }
+                        
+                        // add the new hit we just made:
+                        if (hits == null ) hits = new ArrayList<>();
+                        hits.add(f);
+                        
+                        // move search bin forward:
+                        crossBin = f.pulsePeakPosition;
+                        break;
+                    }
+                }
+                // if we didn't generate a new hit, stop:
+                if (hits == null) break;
+            }
+        }
+        return hits == null ? null : hits.stream().toArray(ExtendedFADCFitter1[]::new);
+    }
+    
+    @Override
+    public void fit(DetectorDataDgtz.ADCData data) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+}