codamagnitudegenerator.java

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

        } catch (JasiCommitException ex) {
          return false;
        }
    }

    protected CalibratedCoda [] getCalibratedCoda(Coda [] codaArray) {
        int size = (codaArray == null) ? 0 : codaArray.length;
        ArrayList list = new ArrayList(size);
        int calibratedCodaCount = 0;
        for (int idx = 0; idx < size; idx++) {
            Solution sol = codaArray[idx].getAssociatedSolution();
            if (sol != currentSol)
                throw new AssociatedSolutionMismatchException("Current solution != associated solution.");
            Channel chan = codaArray[idx].getChannelObj();
            CodaCalibrParms calibrParms = getCodaCalibrParms(chan);
            boolean isSummaryChannelType = summaryChannelType(chan.getSeedchan());
            if (! isSummaryChannelType) {
                if (debug) System.out.println("    calcSummaryMag not summary channel type: " +  getStnChlNameString(chan));
                continue;
            }
            if (! calibrParms.hasMagCorr()) {
                if (isSummaryChannelType) {
                    if (logCodaCalc) System.out.println("    calcSummaryMag no magCorr found for: " + getStnChlNameString(chan));
                }
                continue;
            }
            //calibratedCoda[calibratedCodaCount].coda = codaArray[idx];
            //calibratedCoda[calibratedCodaCount].calibr = calibrParms;
            list.add(new CalibratedCoda(codaArray[idx], calibrParms));
            calibratedCodaCount++;
        }
        if (calibratedCodaCount < 1) {
            calibrList = null; // reset to re-initialize for next event ??
        }
        return (CalibratedCoda []) list.toArray(new CalibratedCoda[list.size()]);
    }

    protected Magnitude createSummaryMag(CalibratedCoda [] calibratedCoda, boolean verbose) {
        int calibratedCodaCount = calibratedCoda.length;
        if (calibratedCodaCount < minCodaCountForSummaryMag) {
            resultsMessage = "calibratedCodaCount < minCodaCountForSummaryMag";
            return null;
        }

        double [] magValues = new double[calibratedCodaCount];
        double [] range     = new double[calibratedCodaCount];
        double [] azimuth   = new double[calibratedCodaCount];
        double [] weights   = new double[calibratedCodaCount];

        for (int idx = 0; idx < calibratedCodaCount; idx++) {
            Channel chan   = calibratedCoda[idx].coda.getChannelObj();
            range[idx]     = getChannelToSolutionDistance(chan);
            azimuth[idx]   = getChannelToSolutionAzimuth(chan);
            magValues[idx] = setChannelMag(calibratedCoda[idx].coda, calibratedCoda[idx].calibr);
            weights[idx]   = calibratedCoda[idx].coda.weightIn.doubleValue();
        }

        double sumMagValue = summaryMagStats.calcValue(magValues, weights, calibratedCodaCount);

        // report summary statistics.
        if (verbose) System.out.println("Summary coda magnitude fit solution id: " + currentSolId + summaryMagStats.toString());

        Arrays.sort(range,   0, calibratedCodaCount); // ascending, first is closest to solution
        Arrays.sort(azimuth, 0, calibratedCodaCount);
        double gap = getMaxGap(azimuth, calibratedCodaCount);

        Magnitude mag = createSummaryMag(summaryMagStats.count, summaryMagStats.value, summaryMagStats.getError(), range[0], gap);
        //moved to MCA class invocation of updateCodaMagResiduals(mag, calibratedCoda, logMagResiduals);
        resultsMessage = "CodaMagnitudeGenerator success - created summary magnitude";
        return mag;
    }

    protected void updateCodaMagResiduals(Magnitude mag, CalibratedCoda [] codaArray, boolean verbose) {
        if (mag == null || codaArray == null) throw new NullPointerException("input argument null");
        int size = codaArray.length;
        if (size < 1 ) return;

        double magValue = mag.value.doubleValue();
        if (verbose) System.out.println("  channel       dist     mag   resid      wt segments");
        for (int idx = 0; idx < size; idx++) {
            Coda coda = codaArray[idx].coda;
            // System.out.println("fit updateCodaMag result [" + idx + "]:" + coda.toString());

            ChannelMag chanMag = coda.getChannelMag();
            if (! chanMag.value.isNull()) {
                chanMag.residual.setValue(chanMag.value.doubleValue() - magValue);
                chanMag.weight.setValue(1.);
            }

            coda.associateMag(mag);

            if (verbose) {
                StringBuffer sb = new StringBuffer(132);
                sb.append("  ");
                sb.append(getStnChlNameString(coda.getChannelObj()));
                Concatenate.format(sb, coda.getHorizontalDistance(), 4,1).append(" ");
                if (debug) sb.append(codaArray[idx].calibr.toString()).append(" ");
                Concatenate.format(sb, chanMag.value.doubleValue(),4,2).append(" ");
                Concatenate.format(sb, chanMag.residual.doubleValue(),4,2).append(" ");
                Concatenate.format(sb, coda.weightIn.doubleValue(),4,2).append(" ");
                Concatenate.format(sb, coda.windowCount.longValue(),4);
                System.out.println(sb.toString());
            }
        }
        if (verbose) System.out.println();
    }

    protected final double getMaxGap(double[] azimuth, int length) {
        int size = (azimuth == null) ? 0 : length;
        if (size < 2 ) return 360.;

        int maxIdx = size - 1;
        double deltaAz = 0.;
        double maxGap  = 0.;
        for (int idx = 0; idx < maxIdx; idx++) {
            deltaAz = Math.abs(azimuth[idx+1] - azimuth[idx]);
            if (deltaAz > maxGap) maxGap = deltaAz;
        }
        deltaAz = 360. - Math.abs(azimuth[maxIdx]) + Math.abs(azimuth[0]);
        return (deltaAz > maxGap) ? deltaAz : maxGap;
    }

    public boolean calcSummaryMagForEvid(long id, boolean useExisting) {
        Solution sol = Solution.create().getValidById(id);
        if (sol == null) {
            resultsMessage = "CodaMagnitudeGenerator.calcSummaryMagForEvid error - no solution for input id:" + id;
            if (verbose) System.out.println(resultsMessage);
            return false;
        }
        return calcSummaryMag(sol, useExisting);
    }

    public int calcSummaryMagByTime(double start, double end, boolean useExisting) {
        return calcSummaryMag(Solution.create().getByTime(start, end), useExisting);
    }

    public int calcSummaryMag(SolutionList solList, boolean useExisting) {
        return calcSummaryMag((Solution []) solList.toArray(new Solution[solList.size()]), useExisting);
    }

    public int calcSummaryMag(Solution [] solutions, boolean useExisting) {
        int size = (solutions == null) ? 0 : solutions.length;
        if (size < 1) return 0;
        int successCount = 0;
        for (int index = 0; index < size; index++) {
            if (calcSummaryMag(solutions[index], useExisting)) successCount++;
        }
        return successCount;
    }

    public boolean calcSummaryMag(Solution sol, boolean useExisting) {
        if (sol == null) {
            System.out.println("CodaMagnitudeGenerator error - null solution input");
            return false;
        }
        Coda [] codaArray = null;
        if (useExisting) {
            Collection codaList = Coda.create().getBySolution(sol);
            if (codaList != null) codaArray = (Coda []) codaList.toArray(new Coda [codaList.size()]);
            setSolution(sol);
        }
        else {
             calcChannelMag(sol);
             codaArray = currentSol.codaList.getArray();
        }
        if (codaArray == null || codaArray.length == 0) {
            if (verbose)
                System.out.println("CodaMagnitudeGenerator - null or zero length codaArray, solution id: " + currentSolId);
            resultsMessage = "coda count < minCountForSummaryMag";
            return false;
        }
        return calcSummaryMag(codaArray);
    }

    public abstract boolean commitMag() throws JasiCommitException ;
    public abstract boolean commitCoda() throws JasiCommitException ;

    public boolean commit() throws JasiCommitException {
        return (commitCoda()) ? commitMag() : false;
    }

    public final void setAutoCommit(boolean value) {
        autoCommit = value;
    }

    public final boolean isAutoCommit() {
        return autoCommit;
    }

    protected void logHeader() {
        System.out.println();
        System.out.println("-----------------------------------------------------------------");
        System.out.println(currentSol.toFingerFormat());
        System.out.println("-----------------------------------------------------------------");
        System.out.println();
    }

    protected void logCodaOutputHeader() {
        System.out.println(
            "            range  phase qual   tau startAmp    endAmp good bad 1st   rms  QFix  QFree AFree AFix Filter   Status"
        );
    }

    public String getResultsMessage() {
        return resultsMessage;
    }

    protected String getStnChlNameString(Channel chan) {
        StringBuffer sb = new StringBuffer(32);
        sb.append(chan.getChannelName().toDelimitedSeedString('_'));
        sb.append("  ");
        return sb.substring(0,12);
    }

    protected void logCodaResult(Channel chan) {
        if (debug) logCodaOutputHeader();
        StringBuffer sb = new StringBuffer(160);
        sb.append(getStnChlNameString(chan));
        Concatenate.format(sb, chan.dist.doubleValue(), 4, 1);
        sb.append(" ");
        sb.append(codaGenerator.outputToString());
        System.out.println(sb.toString());
    }

    protected void setDefaultSource(String sourceDevice) {
        defaultSourceDevice = sourceDevice;
    }

// JasiSolutionProcessorIF
/*
    //public static final int CALC_CODA_ONLY                     = 0;
    //public static final int CALC_CODA_AND_SUMMARY              = 1;
    //public static final int CALC_SUMMARY_MAG_USE_EXISTING_CODA = 2;

    //public static final int UNKNOWN_PROCESSING_MODE = -1;
    //public static final int NULL_INPUT = -2;
    //public static final int INPUT_NOOP = 0;
    //public static final int UNIT_SUCCESS = 1;

    public int processSolution(Solution sol)  {
        switch (getSolutionProcessingMode().getIdCode()) {
            case CALC_CODA_ONLY:
                return calcChannelMag(Solution sol)  ;
            case CALC_CODA_AND_SUMMARY:
                return calcSummaryMag(sol, false) ;
            case CALC_SUMMARY_MAG_USE_EXISTING_CODA:
                return calcSummaryMag(sol, true) ;
        }
        return UNKNOWN_PROCESSING_MODE;
    }
*/

    public int processSolution(long evid) {
        return processSolution(Solution.create().getValidById(evid)); // create a Solution object using prefor of evid
    }

    public int processSolution(Solution sol)  {
        if (sol == null) return ProcessingResult.NULL_INPUT.getIdCode();
        CodaSolutionProcessingMode mode = (CodaSolutionProcessingMode) getSolutionProcessingMode();
        if (mode == CodaSolutionProcessingMode.CALC_CODA_ONLY) {
            return calcChannelMag(sol);
        }
        else if (mode == CodaSolutionProcessingMode.CALC_CODA_AND_SUMMARY_MAG) {
            return (calcSummaryMag(sol, false)) ?
                ProcessingResult.UNIT_SUCCESS.getIdCode() : ProcessingResult.FAILURE.getIdCode();
        }
        else if (mode == CodaSolutionProcessingMode.CALC_SUMMARY_MAG_USE_EXISTING_CODA) {
           return (calcSummaryMag(sol, true)) ?
                ProcessingResult.UNIT_SUCCESS.getIdCode() : ProcessingResult.FAILURE.getIdCode();
        }
        else return ProcessingResult.UNKNOWN_PROCESSING_MODE.getIdCode();
    }

    public int processSolution(Solution [] solutions) {
        if (solutions == null) return ProcessingResult.NULL_INPUT.getIdCode();
        int size = solutions.length;
        if (size < 1 ) return ProcessingResult.INPUT_NOOP.getIdCode();
        int resultCode = ProcessingResult.UNIT_SUCCESS.getIdCode();
        for (int index = 0; index < size; index++) {
            resultCode = processSolution(solutions [index]);
            if (resultCode != ProcessingResult.UNIT_SUCCESS.getIdCode()) break;
        }
        return resultCode;
    }

    public int processSolution(SolutionList solList) {
        return processSolution(solList.getArray()) ;
    }

    public void setSolutionProcessingMode(SolutionProcessingMode processingMode) {
        this.processingMode = (CodaSolutionProcessingMode) processingMode;
    }

    public SolutionProcessingMode getSolutionProcessingMode() {
        return processingMode;
    }

    public boolean isValidId(long id) { return (id > 0); }

} // end of CodaMagnitudeGenerator class