codageneratortn.java

一个用java写的地震分析软件(无源码)-used to write a seismic analysis software (without source)

        if (goodWindowCount >= 2) { // solve for Afree and Qfree

            smallestResidualSum = 999999.;
            for (int idx = 1; idx < goodWindowCount; idx++ ) {
                for (int idx2 = 0; idx2 < idx; idx2++) {
                    double numerator = log10WindowAmp[idx]*log10WindowTime[idx2] - log10WindowAmp[idx2]*log10WindowTime[idx];
                    double denominator = windowWeight[idx]*log10WindowTime[idx2] - windowWeight[idx2]*log10WindowTime[idx];
                    if (denominator < 0.001) denominator = 0.001;
                    double A0 = numerator/denominator;
                    double Q0 = (log10WindowAmp[idx] - windowWeight[idx]*A0)/log10WindowTime[idx];
                    double sum = 0.;
                    for (int idx3 = 0; idx3 < goodWindowCount; idx3++) {
                        double residual = windowWeight[idx3]*A0 + log10WindowTime[idx3]*Q0 - log10WindowAmp[idx3];
                        sum += Math.abs(residual);
                    }
                    if (sum <= smallestResidualSum) {
                        aFree = A0;
                        qFree = Q0;
                        smallestResidualSum = sum;
                    }
                }
            }
        }

        if (goodWindowCount > 2) {
            rms = smallestResidualSum/(goodWindowCount-2);       // save l1-fit as rms for qfree and afree
            quality = 1.;
        }
        else {
            if (goodWindowCount == 2) {
                rms = smallestResidualSum;
                quality = .5;
            }
            else {
                rms = 0.0;
                quality = .25;
            }
        }
    }

/** Print input setting to System.out*/
    public void printInputSettings() {
        System.out.println(inputToString());
    }

/** Print last results to System.out*/
    public void printResults() {
        System.out.println(outputToString());
    }

/** Print good time amp pair values to System.out*/
    public void printTimeAmps() {
        System.out.println(timeAmpsToString());
    }

/** Return String of any good time amp values.*/
    public String timeAmpsToString() {
        TimeAmp [] ta = getGoodWindowTimeAmps();
        int size = ta.length;
        if (size <= 0) return null;
        StringBuffer sb = new StringBuffer(512);
        for (int idx = 0; idx < size; idx++) {
            sb.append(" ");
            sb.append(ta[idx].toString(','));
            if (idx % 5 == 0) sb.append("\n");
        }
        return sb.toString();
    }

    public String inputToString() {
        StringBuffer sb = new StringBuffer(256);
        sb.append(" minWin: ").append(minGoodWindowsToEndCalcOnClipping);
        sb.append(" maxWin: ").append(maxGoodWindowCount);
        sb.append(" winSize: ").append(windowSize);
        sb.append(" nsamp: ").append(lastSampleIdxInTimeSeries+1);
        sb.append(" sps: ").append(secsPerSample);
        sb.append(" SmP: ").append(secsPastPTimeAtStartingIdx);
        sb.append("\n    startSNR: ").append(codaStartSignalToNoiseRatio);
        sb.append(" endSNR: ").append(codaCutoffSignalToNoiseRatio);
        sb.append(" passNSR: ").append(passThruNoiseDecayAmpRatio);
        sb.append(" clipReset: ").append(resetOnClipping);
        return sb.toString();
    }

    public String outputToString() {
        StringBuffer sb = new StringBuffer(256);
        //if (fmt == null) fmt = new Concat();
        sb.append("    ").append(codaPhase).append(" ");
        Concatenate.format(sb, quality, 2, 1);
        Concatenate.format(sb, tauFinal, 4, 1);
        Concatenate.format(sb, firstWindowAveAbsAmp, 9, 0);
        Concatenate.format(sb, aveAbsAmpAtEndOfCoda, 9, 0);
        Concatenate.format(sb, goodWindowCount, 4);
        Concatenate.format(sb, badWindowCount,  4);
        Concatenate.format(sb, firstGoodWindow, 4);
        Concatenate.format(sb, rms, 3, 2);
        Concatenate.format(sb, qFix, 3, 2);
        Concatenate.format(sb, qFree, 3, 2);
        Concatenate.format(sb, aFree, 3, 2);
        Concatenate.format(sb, aFix, 3, 2);
        sb.append(" ");
        String filterStr = (isFilterEnabled() && hasFilter()) ?  "true    " : "false   ";
        sb.append(filterStr);
        sb.append(getExitStatusString());
        return sb.toString();
    }
    public String outputToLabeledString() {
        StringBuffer sb = new StringBuffer(256);
        sb.append(" status: ").append(exitStatus);
        sb.append(" phase: ").append(codaPhase);
        sb.append(" qual: ").append(quality);
        sb.append(" tau: ").append(tauFinal);
        sb.append(" startAmp: ").append(firstWindowAveAbsAmp);
        sb.append(" endAmp: ").append(aveAbsAmpAtEndOfCoda);
        sb.append(" ngood: ").append(goodWindowCount);
        sb.append(" nbad: ").append(badWindowCount);
        sb.append(" 1stGoodAt: ").append(firstGoodWindow);
        sb.append(" rms: ").append(rms);
        sb.append(" QFix: ").append(qFix);
        sb.append(" QFree: ").append(qFree);
        sb.append(" AFree: ").append(aFree);
        sb.append(" AFix: ").append(aFix);
        sb.append(" desc: ").append(getExitStatusString());
        return sb.toString();
    }
    public String outputHeaderString() {
        StringBuffer sb = new StringBuffer(132);
        sb.append("            phase qual   tau startAmp    endAmp good bad 1st   rms  QFix  QFree AFree AFix Filter   Status");
        return sb.toString();
    }

// Methods to  initialize global data values
/** Returns last results in input  Coda object */
    public Coda setCodaResults(Coda results) {
        return resultsToCoda((CodaTN) results) ;
    }

/** Returns maximum value allowed for aveAbsAmpCurrentCodaWindow/aveAbsAmpLastGoodCodaDecayWindow.
* If value is exceeded (e.g. a noise burst or new phase arrival) the timeseries scan of coda is terminated.
 */
    public double getPassThruNoiseDecayAmpRatio() {
        return passThruNoiseDecayAmpRatio;
    }

/** Sets maximum value allowed for aveAbsAmpCurrentCodaWindow/aveAbsAmpLastGoodCodaDecayWindow. */
    public void setPassThruNoiseDecayAmpRatio(double passThruNoiseDecayAmpRatio) {
        if (passThruNoiseDecayAmpRatio > 0.) this.passThruNoiseDecayAmpRatio = passThruNoiseDecayAmpRatio;
    }

/** Returns Qfix */
    public double getQFix() {
        return qFix;
    }

/** Sets QFix value. */
    public void setQFix(double qFix) {
        if (qFix > 0.) this.qFix = qFix;
    }

    public void setResetOnClipping(boolean value) {
        resetOnClipping = value;
    }

    public boolean isResetOnClipping() {
        return resetOnClipping;
    }

/** Returns the minimum number of good coda time series windows needed to terminate the coda calculation
*   if the current window amplitude is above the clipping level.
*/
    public int getMinGoodWindows() {
        return minGoodWindowsToEndCalcOnClipping;
    }

    public void setMinGoodWindows(int numberOfWindows) {
        this.minGoodWindowsToEndCalcOnClipping = numberOfWindows;
    }

/** Returns maximum number of valid coda time series windows allowed before coda calculation is terminated.*/
    public int getMaxGoodWindows() {
        return maxGoodWindowCount;
    }

/** Sets maximum number of valid coda time series windows allowed before coda calculation is terminated.*/
    public void setMaxGoodWindows(int maxCount) {
        if (maxCount > this.maxGoodWindowCount) initBuffers(maxCount);
    }

/** Gets maximum number coda seconds duration for coda cutoff */
    public double getMaxCodaDurationSecs() {
        return getWindowStartingSampleSecsOffset(maxGoodWindowCount) + windowSize;
    }

/** Returns size in seconds of the time series window over which absolute amplitude values are averaged.*/
    public double getWindowSize() {
        return windowSize;
    }

/** Sets size in seconds of the time series window over which to average the absolute amplitude values.*/
    public void setWindowSize(double windowSize) {
        this.windowSize = windowSize;
    }

/** Valid coda window counting begins if averagedAbsoluteAmpofWindow/averagedAbsoluteValueOfNoise > snrToStart.  */
    public void setCodaStartSignalToNoiseRatio(double snrToStart) {
        codaStartSignalToNoiseRatio = snrToStart;
    }

    public double getCodaStartSignalToNoiseRatio() {
        return codaStartSignalToNoiseRatio ;
    }

/** Valid coda window counting ends if averagedAbsoluteAmpofWindow/averagedAbsoluteValueOfNoise < snrToEnd.  */
    public void setCodaCutoffSignalToNoiseRatio(double snrToEnd) {
        codaCutoffSignalToNoiseRatio = snrToEnd;
    }

    public double getCodaCutoffSignalToNoiseRatio() {
        return codaCutoffSignalToNoiseRatio ;
    }

/** Returns the average of the absolute demeaned values of the time series amplitudes over the specified range. */
    public static double calcLongTermAbsAverage(float [] timeSeriesAmps, int startingSampleIdx, int numberOfSamples,
                 double bias, int codaStartingIdx) {
        int nSamples = startingSampleIdx + numberOfSamples;
        if (nSamples > codaStartingIdx) nSamples = codaStartingIdx - startingSampleIdx;
        if (startingSampleIdx < 0 || nSamples > timeSeriesAmps.length || numberOfSamples < 0 )
            throw new IllegalArgumentException("starting or ending index is outside of input array bounds");
        double sum = 0.;
        for (int idx = startingSampleIdx; idx < nSamples; idx++) {
            sum += Math.abs((double) timeSeriesAmps[idx] - bias);
        }
        return sum/numberOfSamples;
    }

/** Returns the mean of the values of the time series amplitudes over the specified range. */
    public static double calcBias(float [] timeSeriesAmps, int startingSampleIdx, int numberOfSamples) {
        int nSamples = startingSampleIdx + numberOfSamples;
        if (startingSampleIdx < 0 || nSamples > timeSeriesAmps.length || numberOfSamples < 0 )
            throw new IllegalArgumentException("starting or ending index is outside of input array bounds");
        double sum = 0.;
        for (int idx = startingSampleIdx; idx < nSamples; idx++) {
            sum += (double) timeSeriesAmps[idx];
        }
        return sum/numberOfSamples;
    }

/** Returns bias window size in samples. */
    public double getNoiseBiasSamples() {
        return noiseBiasSamples;
    }

/** Returns bias window size in samples. */
    public void setNoiseBiasSamples(int noiseBiasSamples) {
        this.noiseBiasSamples = noiseBiasSamples;
    }

/** Returns a status value set by the coda calculations methods. */
    public int getExitStatus() {
        return exitStatus;
    }

/** Returns the String value of the exit code set by the coda calculations methods. */
    public String getExitStatusString() {
        return exitStatusString;
    }

}