restore thread safety

Author: baltzell

common-tools/clas-detector/src/main/java/org/jlab/detector/pulse/ModeAHDC.java

@@ -45,17 +45,6 @@ public class ModeAHDC extends HipoExtractor  {
     // dream clock for fine timestamp correction
     private final float dream_clock = 8.0f;
 
-    //Waveform and corresponding pulse
-    //This is the CURRENT pulse, it is initialized
-    //at every extraction. This is not the cleanest
-    //but it avoids feeding the same arguments to all methods
-    private short[] samples;
-    private Pulse pulse;
-    private long time_ZS;
-    private int binMax;
-    private int numberOfBins;
-    private int effectiveNumberOfBins;
-    
     //Waveform types:
     //wfType 6 ⇒ too small (nsamples <= 10)
     //wfType 5 ⇒ decreasing baseline (or leadingEdgeTime fails)
@@ -65,47 +54,55 @@ public class ModeAHDC extends HipoExtractor  {
     //wfType 1 ⇒ saturing
     //wfType 0 ⇒ OK
 
+    public static class AHDCPulse extends Pulse {
+        public long time_ZS;
+        public int binMax;
+        public int numberOfBins;
+        public int effectiveNumberOfBins;
+        private short[] samples;
+    }
+    
     /**
      *
      */
-    public void preProcess() {
-        assignValidType(0);
-        this.numberOfBins = samples.length;
+    public void preProcess(AHDCPulse p) {
+        assignValidType(0, p);
+        p.numberOfBins = p.samples.length;
         // check if the signal is too short
         int countNotZeros = 0;
         boolean FirstNonZeroFromTheTailReached = false;
-        for (int i = samples.length-1; i >= 0; i--) {
-            if (samples[i] > 0) {
+        for (int i = p.samples.length-1; i >= 0; i--) {
+            if (p.samples[i] > 0) {
                 countNotZeros++;
                 if (!FirstNonZeroFromTheTailReached) {
                     FirstNonZeroFromTheTailReached = true;
-                    this.effectiveNumberOfBins = i+1; // this value can be identified as the effective number of bins
+                    p.effectiveNumberOfBins = i+1; // this value can be identified as the effective number of bins
                 }
             }
         }
-        if (countNotZeros <= 10) assignInvalidType();
+        if (countNotZeros <= 10) assignInvalidType(p);
     }
 
     /**
      * This method computes the waveform baseline
      * from the average of the first few samples
      */
-    public void baselineComputation()
+    public void baselineComputation(AHDCPulse p)
     {
         //Default baseline
         float adcOffset = -99;
 
         //Check if the wf has sufficient length, if not it is invalid
-        if (numberOfBins >= this.nBaselineSamples+1){
+        if (p.numberOfBins >= this.nBaselineSamples+1){
 
             //The baseline is the average of the first few samples
             for(int i=0; i<this.nBaselineSamples;i++){
-                adcOffset += this.samples[i];
+                adcOffset += p.samples[i];
             }
             adcOffset = adcOffset/this.nBaselineSamples;
         }
-        else {this.assignInvalidType();}//invalid, too short wf
-        this.pulse.pedestal = adcOffset;
+        else {this.assignInvalidType(p);}//invalid, too short wf
+        p.pedestal = adcOffset;
     }
 
     /**
@@ -115,16 +112,16 @@ public void baselineComputation()
      *
      * @param type an int that is the new wf type to be applied
      */
-    public void assignValidType(int type){
+    public void assignValidType(int type, AHDCPulse p){
         //We only assign a new type if a more restrictive type was not defined before
-        if(type>this.pulse.wftype) this.pulse.wftype = (short) type;
+        if(type>p.wftype) p.wftype = (short) type;
     }
 
     /**
      * This method assigns an invalid type (-1) to the waveform
      */
-    public void assignInvalidType(){
-        this.pulse.wftype = 6;
+    public void assignInvalidType(AHDCPulse p){
+        p.wftype = 6;
     }
 
     /**
@@ -135,13 +132,13 @@ public void assignInvalidType(){
      * @return an int for status
      *
      */
-    public int waveformADCProcessing()
+    public int waveformADCProcessing(AHDCPulse p)
     {
         //int numberOfBins = this.samples.length;
 
         //Initialize to dummy values
-        this.pulse.adcMax = -99;
-        this.binMax = -99;
+        p.adcMax = -99;
+        p.binMax = -99;
 
         //For invalid wf, dummy values kept
         //if(this.pulse.wftype == 6) return 0;
@@ -154,20 +151,20 @@ public int waveformADCProcessing()
         int endPlateau = -99;
 
         //Looping through samples
-        for (int bin = 0; bin < numberOfBins; bin++){
+        for (int bin = 0; bin < p.numberOfBins; bin++){
             //Baseline subtraction
-            this.samples[bin] = (short) Math.max(this.samples[bin] - this.pulse.pedestal, 0);
+            p.samples[bin] = (short) Math.max(p.samples[bin] - p.pedestal, 0);
             //Look for maximum
-            if ((this.pulse.adcMax < this.samples[bin]) && (bin >= nBaselineSamples)) { // the max should not be in the baseline
-                this.pulse.adcMax = this.samples[bin];
-                this.binMax = bin;
+            if ((p.adcMax < p.samples[bin]) && (bin >= nBaselineSamples)) { // the max should not be in the baseline
+                p.adcMax = p.samples[bin];
+                p.binMax = bin;
             }
             //Integration
-            this.pulse.integral += this.samples[bin];
+            p.integral += p.samples[bin];
 
             //Check for saturation: if the sample exceeds the ths
             //and if it belongs to a group of saturating samples
-            if(this.samples[bin]>(this.ADC_LIMIT-this.pulse.pedestal)){
+            if(p.samples[bin]>(this.ADC_LIMIT-p.pedestal)){
                 //if this is the first sample saturating, start a new plateau
                 if(nsaturating==0) startPlateau = bin;
                 //else continue the plateau
@@ -182,23 +179,23 @@ public int waveformADCProcessing()
         //Saturating samples: if the number of consecutive saturating samples
         //is greater than the limit, we consider the wf saturated
         if(maxNsaturating>=this.consecutiveSaturatingSamples){
-            this.assignValidType(1);
+            this.assignValidType(1, p);
             //The time is taken as the middle of the plateau
-            this.binMax = (startPlateau + endPlateau)/2;
+            p.binMax = (startPlateau + endPlateau)/2;
         }
 
         //Define the pulse time as the peak time
-        this.pulse.time = (this.binMax + this.time_ZS)*this.samplingTime;
+        p.time = (p.binMax + p.time_ZS)*this.samplingTime;
         //If there are 2*npts+1 points around the peak
         //(if the peak is not at an edge of the window)
         //Then the peak ADC value is revisited to be the average of these
         //TO DO: just use the adcmax???
         int npts = 1;
-        if (this.pulse.adcMax == 0) { assignValidType(5);} // classification before the fit
-        if ((this.binMax - npts >= 0) && (this.binMax + npts <= numberOfBins - 1)){
-            this.pulse.adcMax = 0;
-            for (int bin = this.binMax - npts; bin <= this.binMax + npts; bin++) this.pulse.adcMax += this.samples[bin];
-            this.pulse.adcMax = this.pulse.adcMax/(2*npts+1);
+        if (p.adcMax == 0) { assignValidType(5, p);} // classification before the fit
+        if ((p.binMax - npts >= 0) && (p.binMax + npts <= p.numberOfBins - 1)){
+            p.adcMax = 0;
+            for (int bin = p.binMax - npts; bin <= p.binMax + npts; bin++) p.adcMax += p.samples[bin];
+            p.adcMax = p.adcMax/(2*npts+1);
         }
 
         return 0;
@@ -212,47 +209,47 @@ public int waveformADCProcessing()
      * @return an int for status
      *
      */
-    public int waveformCFAprocessing(){
+    public int waveformCFAprocessing(AHDCPulse p){
 
         //Initialization
-        this.pulse.leadingEdgeTime = -9999;
-        this.pulse.trailingEdgeTime = -9999;
-        this.pulse.timeOverThreshold = -9999;
+        p.leadingEdgeTime = -9999;
+        p.trailingEdgeTime = -9999;
+        p.timeOverThreshold = -9999;
 
         //Set the CFA threshold
-        float threshold = this.amplitudeFractionCFA*this.pulse.adcMax;
+        float threshold = this.amplitudeFractionCFA*p.adcMax;
 
         //Crossing the threshold before the peak
         int binRise = -99;
-        for (int bin = 0; bin < binMax - 1; bin++){
-            if (this.samples[bin] < threshold && this.samples[bin+1] >= threshold)
+        for (int bin = 0; bin < p.binMax - 1; bin++){
+            if (p.samples[bin] < threshold && p.samples[bin+1] >= threshold)
                 binRise = bin; //Here we keep only the last time the signal crosses the threshold
         }
         //If the waveform does not cross the ths before the peak
         //it was early or remant from a previous event and we cannot define a leading time
         //we set the time at zero
         if(binRise==-99) {
-            this.assignValidType(5);
-            this.pulse.leadingEdgeTime = (0 + this.time_ZS)*this.samplingTime;
+            this.assignValidType(5, p);
+            p.leadingEdgeTime = (0 + p.time_ZS)*this.samplingTime;
         }
         else
         {
             float slopeRise = 0;
             //linear interpolation
             //threshold = leadingtime*(ADC1-ADC0)+ADC0
-            if (binRise + 1 <= numberOfBins-1)
-                slopeRise = this.samples[binRise+1] - this.samples[binRise];
-            float fittedBinRise = (slopeRise == 0) ? binRise : binRise + (threshold - this.samples[binRise])/slopeRise;
-            this.pulse.leadingEdgeTime = (fittedBinRise + this.time_ZS)*this.samplingTime;
+            if (binRise + 1 <= p.numberOfBins-1)
+                slopeRise = p.samples[binRise+1] - p.samples[binRise];
+            float fittedBinRise = (slopeRise == 0) ? binRise : binRise + (threshold - p.samples[binRise])/slopeRise;
+            p.leadingEdgeTime = (fittedBinRise + p.time_ZS)*this.samplingTime;
         }
 
         //Crossing the threshold back down after the peak
         int binFall = -99;
-        for (int bin = binMax; bin < numberOfBins-1; bin++){
-            if (this.samples[bin] > threshold
-                && this.samples[bin+1] <= threshold
-                && this.samples[bin]>0
-                && this.samples[bin+1]>0){
+        for (int bin = p.binMax; bin < p.numberOfBins-1; bin++){
+            if (p.samples[bin] > threshold
+                && p.samples[bin+1] <= threshold
+                && p.samples[bin]>0
+                && p.samples[bin+1]>0){
                 binFall = bin+1;
                 break; //We keep only the first time the signal crosses back the threshold
             }
@@ -261,21 +258,21 @@ public int waveformCFAprocessing(){
         //it was late and falling edge cannot be defined
         //the time correspond to the end of the signal
         if(binFall==-99) {
-            this.assignValidType(2);
-            this.pulse.trailingEdgeTime = (this.effectiveNumberOfBins -1 + this.time_ZS)*this.samplingTime;
+            this.assignValidType(2, p);
+            p.trailingEdgeTime = (p.effectiveNumberOfBins -1 + p.time_ZS)*this.samplingTime;
         }
         else
         {
             float slopeFall = 0;
             if (binFall - 1 >= 0)
-                slopeFall = this.samples[binFall] - this.samples[binFall-1];
-            float fittedBinFall = (slopeFall == 0) ? binFall : binFall-1 + (threshold - this.samples[binFall-1])/slopeFall;
-            this.pulse.trailingEdgeTime = (fittedBinFall + this.time_ZS)*this.samplingTime;
+                slopeFall = p.samples[binFall] - p.samples[binFall-1];
+            float fittedBinFall = (slopeFall == 0) ? binFall : binFall-1 + (threshold - p.samples[binFall-1])/slopeFall;
+            p.trailingEdgeTime = (fittedBinFall + p.time_ZS)*this.samplingTime;
         }
 
-        this.pulse.timeOverThreshold = this.pulse.trailingEdgeTime - this.pulse.leadingEdgeTime;
+        p.timeOverThreshold = p.trailingEdgeTime - p.leadingEdgeTime;
         //if ((this.pulse.timeOverThreshold < 300) || (this.pulse.timeOverThreshold > 750)) this.assignValidType(4); // bad tot
-        if (this.pulse.timeOverThreshold < 300) this.assignValidType(4); // tot too small
+        if (p.timeOverThreshold < 300) this.assignValidType(4, p); // tot too small
 
         return 0;
     }
@@ -287,24 +284,24 @@ public int waveformCFAprocessing(){
      * @return an int for status
      *
      */
-    public int computeTimeUsingConstantFractionDiscriminator(){
+    public int computeTimeUsingConstantFractionDiscriminator(AHDCPulse p){
         //Dummy values for hits for which the leading edge is not defined
-        this.pulse.constantFractionTime = -99;
-        if(this.pulse.wftype>=4) return 0;
+        p.constantFractionTime = -99;
+        if(p.wftype>=4) return 0;
 
         //int numberOfBins = this.samples.length;
-        float[] signal = new float[numberOfBins];
+        float[] signal = new float[p.numberOfBins];
 
         // signal generation
-        for (int bin = 0; bin < numberOfBins; bin++){
-            signal[bin] = (1 - this.fractionCFD)*this.samples[bin]; // we fill it with a fraction of the original signal
-            if (bin < numberOfBins - this.binDelayCFD)
-                signal[bin] += -1*this.fractionCFD*this.samples[bin + this.binDelayCFD]; // we advance and invert a complementary fraction of the original signal and superimpose it to the previous signal
+        for (int bin = 0; bin < p.numberOfBins; bin++){
+            signal[bin] = (1 - this.fractionCFD)*p.samples[bin]; // we fill it with a fraction of the original signal
+            if (bin < p.numberOfBins - this.binDelayCFD)
+                signal[bin] += -1*this.fractionCFD*p.samples[bin + this.binDelayCFD]; // we advance and invert a complementary fraction of the original signal and superimpose it to the previous signal
         }
         // determine the two humps
         int binHumpSup = 0;
         int binHumpInf = 0;
-        for (int bin = 0; bin < numberOfBins; bin++){
+        for (int bin = 0; bin < p.numberOfBins; bin++){
             if (signal[bin] > signal[binHumpSup])
                 binHumpSup = bin;
         }
@@ -319,10 +316,10 @@ public int computeTimeUsingConstantFractionDiscriminator(){
                 binZero = bin; // last pass below zero
         } // at this stage : binZero < constantFractionTime/samplingTime <= binZero + 1 // constantFractionTime is determined by assuming a linear fit between binZero and binZero + 1
         float slopeCFD = 0;
-        if (binZero + 1 <= numberOfBins)
+        if (binZero + 1 <= p.numberOfBins)
             slopeCFD = signal[binZero+1] - signal[binZero];
         float fittedBinZero = (slopeCFD == 0) ? binZero : binZero + (0 - signal[binZero])/slopeCFD;
-        this.pulse.constantFractionTime = (fittedBinZero + this.time_ZS)*this.samplingTime;
+        p.constantFractionTime = (fittedBinZero + p.time_ZS)*this.samplingTime;
 
         return 0;
     }
@@ -336,9 +333,9 @@ public int computeTimeUsingConstantFractionDiscriminator(){
      * @param fineTimeStampResolution correspond to the dream clock (usually equals to 8; but to be checked!)
      */
 
-    private void fineTimeStampCorrection(long timestamp, float fineTimeStampResolution) {
+    private void fineTimeStampCorrection(long timestamp, float fineTimeStampResolution, AHDCPulse p) {
         long fineTimeStamp = timestamp & 0x00000007; // keep and convert last 3 bits of binary timestamp
-        this.pulse.leadingEdgeTime += (double) ((fineTimeStamp+0.5) * fineTimeStampResolution); //fineTimeStampCorrection, only on the leadingEdgeTime for the moment (we don't use timeMax or constantFractionTime in the reconstruction yet)
+        p.leadingEdgeTime += (double) ((fineTimeStamp+0.5) * fineTimeStampResolution); //fineTimeStampCorrection, only on the leadingEdgeTime for the moment (we don't use timeMax or constantFractionTime in the reconstruction yet)
     }
 
     /**
@@ -357,33 +354,33 @@ public List<Pulse> extract(NamedEntry pars, int id, long timestamp, long time_ZS
         //Initialize everything each time a new wf is read
         //and new adc information is extracted.
         //This is messy but avoids feeding the same arguments to all methods
-        this.pulse = new Pulse();
-        this.pulse.id = id;
-        this.pulse.timestamp = timestamp;
-        this.time_ZS = time_ZS;
-        this.samples = samples;
-        this.binMax = -99;
-        
-        List<Pulse> output = new ArrayList<>();
+        AHDCPulse pulse = new AHDCPulse();
+        pulse.id = id;
+        pulse.timestamp = timestamp;
+        pulse.time_ZS = time_ZS;
+        pulse.samples = samples;
+        pulse.binMax = -99;
 
         // Pre Process
-        this.preProcess();
+        this.preProcess(pulse);
+
         //Baseline computation
-        this.baselineComputation();
+        this.baselineComputation(pulse);
 
         //Get the ADC information from the pulse (peak ADC and time, integral)
-        this.waveformADCProcessing();
+        this.waveformADCProcessing(pulse);
 
         //Get the time overr threshold
-        this.waveformCFAprocessing();
+        this.waveformCFAprocessing(pulse);
 
         //Get the CFD time
-        this.computeTimeUsingConstantFractionDiscriminator();
+        this.computeTimeUsingConstantFractionDiscriminator(pulse);
 
         // Fine timestamp correction on leadingEdgeTime
-        this.fineTimeStampCorrection(timestamp, dream_clock);
+        this.fineTimeStampCorrection(timestamp, dream_clock, pulse);
 
-        output.add(this.pulse);
+        List<Pulse> output = new ArrayList<>();
+        output.add(pulse);
         return output;
     }