From 43e4a3836a42526e91b5055719685b1d9effacf4 Mon Sep 17 00:00:00 2001
From: Peter Powers <pmpowers@usgs.gov>
Date: Sun, 13 Dec 2020 14:29:27 -0700
Subject: [PATCH] mfd test docs and cleaning
---
.../java/gov/usgs/earthquake/nshmp/Maths.java | 4 +-
.../gov/usgs/earthquake/nshmp/mfd/Mfd.java | 247 +++++++----
.../gov/usgs/earthquake/nshmp/mfd/Mfds.java | 28 ++
.../earthquake/nshmp/model/Deserialize.java | 4 +-
.../nshmp/model/FaultRuptureSet.java | 16 +-
.../usgs/earthquake/nshmp/model/MfdTrees.java | 4 +-
.../nshmp/mfd/IncrementalMfdBuilderTest.java | 141 -------
.../usgs/earthquake/nshmp/mfd/MfdTests.java | 397 +++++++++++++++++-
.../usgs/earthquake/nshmp/mfd/Mfds2Test.java | 44 --
.../usgs/earthquake/nshmp/mfd/MfdsTests.java | 93 ++--
10 files changed, 641 insertions(+), 337 deletions(-)
delete mode 100644 src/test/java/gov/usgs/earthquake/nshmp/mfd/IncrementalMfdBuilderTest.java
delete mode 100644 src/test/java/gov/usgs/earthquake/nshmp/mfd/Mfds2Test.java
diff --git a/src/main/java/gov/usgs/earthquake/nshmp/Maths.java b/src/main/java/gov/usgs/earthquake/nshmp/Maths.java
index b794ce31..fb47cf43 100644
--- a/src/main/java/gov/usgs/earthquake/nshmp/Maths.java
+++ b/src/main/java/gov/usgs/earthquake/nshmp/Maths.java
@@ -23,7 +23,7 @@ public final class Maths {
public static final double PI_BY_2 = Math.PI / 2;
/** Constant for 2Ï€. */
- public static final double TWO_PI = 2 * Math.PI;
+ public static final double TWO_PI = 2.0 * Math.PI;
/** Conversion multiplier for degrees to radians. */
public static final double TO_RADIANS = Math.toRadians(1.0);
@@ -35,7 +35,7 @@ public final class Maths {
* The precomputed √<span style="border-top:1px solid; padding:0 0.1em;"
* >2</span>.
*/
- public static final double SQRT_2 = Math.sqrt(2);
+ public static final double SQRT_2 = Math.sqrt(2.0);
/**
* The precomputed √<span style="border-top:1px solid; padding:0 0.1em;"
diff --git a/src/main/java/gov/usgs/earthquake/nshmp/mfd/Mfd.java b/src/main/java/gov/usgs/earthquake/nshmp/mfd/Mfd.java
index 07ba4f0a..71ce10ff 100644
--- a/src/main/java/gov/usgs/earthquake/nshmp/mfd/Mfd.java
+++ b/src/main/java/gov/usgs/earthquake/nshmp/mfd/Mfd.java
@@ -1,21 +1,23 @@
package gov.usgs.earthquake.nshmp.mfd;
-import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
import static gov.usgs.earthquake.nshmp.Earthquakes.checkMagnitude;
import static gov.usgs.earthquake.nshmp.Earthquakes.magToMoment;
import static gov.usgs.earthquake.nshmp.mfd.Mfd.Type.GR;
import static gov.usgs.earthquake.nshmp.mfd.Mfd.Type.GR_TAPER;
import static gov.usgs.earthquake.nshmp.mfd.Mfd.Type.INCR;
import static gov.usgs.earthquake.nshmp.mfd.Mfd.Type.SINGLE;
+import static gov.usgs.earthquake.nshmp.mfd.Mfds.checkRate;
import static gov.usgs.earthquake.nshmp.mfd.Mfds.gutenbergRichterRate;
+import java.util.Arrays;
import java.util.EnumSet;
-import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;
import gov.usgs.earthquake.nshmp.Maths;
+import gov.usgs.earthquake.nshmp.Text;
import gov.usgs.earthquake.nshmp.data.MutableXySequence;
import gov.usgs.earthquake.nshmp.data.Sequences;
import gov.usgs.earthquake.nshmp.data.XyPoint;
@@ -57,8 +59,13 @@ import gov.usgs.earthquake.nshmp.data.XySequence;
*
* <p>MFD {@link Properties} hold references to the parameters used to
* initialize an MFD, including its {@link Type}. Properties objects may be
- * constructed directly and support a {@link Properties#toBuilder()} method.
- * NSHM
+ * constructed directly and support a {@link Properties#toBuilder()} method. The
+ * the {@code Mfd.Type} will be {@code INCREMENTAL} if the MFD was created
+ * directly from magnitude and rate data or is the result of combining more than
+ * one MFD via {@link Mfds#combine(java.util.Collection)}. Similarly, properties
+ * <i>may</i> not align with an associated MFD downstream if a builder
+ * initialized with a set of properties has been used to create multiple MFDs
+ * with variably scaled rates or transformed in various ways.
*
* @author U.S. Geological Survey
* @see Mfds
@@ -74,18 +81,24 @@ public final class Mfd {
this.props = props;
}
- /** The immutable values representing this MFD. */
+ /**
+ * The immutable values representing this MFD.
+ */
public XySequence data() {
return data;
}
- /** The properties used to initialize the MFD. */
+ /**
+ * The properties used to initialize the MFD.
+ */
public Properties properties() {
return props;
}
- // TODO need magnitude and rate checks
- // TODO Arrays.stream(magnitudes).forEach(Earthquakes::checkMagnitude);
+ @Override
+ public String toString() {
+ return "MFD:" + props.toString() + Text.NEWLINE + data.toString();
+ }
/**
* Create an MFD from copies of the supplied arrays. The returned MFD will be
@@ -110,6 +123,7 @@ public final class Mfd {
* @param xy data to wrap in an MFD
*/
public static Mfd create(XySequence xy) {
+ Mfds.checkValues(xy.xValues(), xy.yValues());
return new Mfd(XySequence.copyOf(xy), new Properties(INCR));
}
@@ -131,7 +145,10 @@ public final class Mfd {
* rounds each magnitude to 5 decimal places. This implementation constructs a
* distribution that is {@code μ ± 2σ} wide and represented by {@code nm}
* evenly distributed magnitude values. The initial distribution integrates to
- * one.
+ * one. The MFD, once built, will be of type: {@link Type#SINGLE} as it
+ * represents a single magnitude combined with a model of uncertainty. In the
+ * context of a hazard model, a normal distribution of magnitudes is typically
+ * used to represent aleatory variability.
*
* @param μ the mean magnitude
* @param nm the number of magnitudes in the resultant distribution
@@ -155,10 +172,10 @@ public final class Mfd {
* magnitude distribtion, this implementation rounds each magnitude to 4
* decimal places.
*
+ * @param b the Gutenberg-Richter b-value
+ * @param Δm the magnitude step of the distribtion
* @param mMin the minimum truncation magnitude
* @param mMax the maximum truncation magnitude
- * @param Δm the magnitude step of the distribtion
- * @param b the Gutenberg-Richter b-value
* @throws IllegalArgumentException if {@code mMin} or {@code mMax} is outside
* the range {@code [-2.0..9.7]}
* @throws IllegalArgumentException if {@code mMin > mMax}
@@ -167,11 +184,11 @@ public final class Mfd {
* {@code [0..2]}
*/
public static Mfd.Builder newGutenbergRichterBuilder(
- double mMin,
- double mMax,
+ double b,
double Δm,
- double b) {
- return new Properties.GutenbergRichter(b, Δm, mMin, mMax).toBuilder();
+ double mMin,
+ double mMax) {
+ return new Properties.GutenbergRichter(1.0, b, Δm, mMin, mMax).toBuilder();
}
/**
@@ -205,26 +222,40 @@ public final class Mfd {
double mMin,
double mMax,
double mc) {
- return new Properties.GrTaper(b, Δm, mMin, mMax, mc).toBuilder();
+ return new Properties.TaperedGr(1.0, b, Δm, mMin, mMax, mc).toBuilder();
}
/** Magnitude-frequency distribution (MFD) type identifier. */
public enum Type {
- /** An MFD with a single magnitude and rate. */
+ /**
+ * An MFD with a single magnitude and rate.
+ *
+ * @see Mfd#newSingleBuilder(double)
+ */
SINGLE,
- /** An MFD defining multiple magnitudes with varying rates. */
+ /**
+ * An MFD defining multiple magnitudes with varying rates.
+ *
+ * @see Mfd#create(double[], double[])
+ * @see Mfd#create(XySequence)
+ */
INCR,
- /** An incremental Gutenberg-Richter MFD. */
+ /**
+ * An incremental Gutenberg-Richter MFD.
+ *
+ * @see Mfd#newGutenbergRichterBuilder(double, double, double, double)
+ */
GR,
/**
* An incremental Gutenberg-Richter MFD with a rate scaling hint. This type
* of MFD is used with NSHM grid sources to indicate that rates above
* {@code M=6.5} (the minimum magnitude for finite faults) should be set to
- * zero if certain conditions are met.
+ * zero if certain conditions are met. This type of MFD can not be created
+ * directly.
*/
GR_MMAX_GR,
@@ -232,11 +263,16 @@ public final class Mfd {
* An incremental Gutenberg-Richter MFD with a rate scaling hint. This type
* of MFD is used with NSHM grid sources to indicate rates above some
* 'characterisitic' fault magnitude should be set to zero if certain
- * conditions are met.
+ * conditions are met. This type of MFD can not be created directly.
*/
GR_MMAX_SINGLE,
- /** A Gutenberg-Richter MFD with a tapered upper tail. */
+ /**
+ * A Gutenberg-Richter MFD with a tapered upper tail.
+ *
+ * @see Mfd#newTaperedGutenbergRichterBuilder(double, double, double,
+ * double, double)
+ */
GR_TAPER;
/** A set containing all Gutenberg-Richter MFD types. */
@@ -257,7 +293,7 @@ public final class Mfd {
private final MutableXySequence mfd;
/*
- * TODO clean Developer notes:
+ * Developer notes:
*
* add constraints preconditions for params other than magnitude
*
@@ -296,6 +332,8 @@ public final class Mfd {
*
* values are checked in toBuilder methods allowing us to verify values set
* via JSON deserialization
+ *
+ * TODO note GR bin centering in docs
*/
/**
@@ -306,16 +344,16 @@ public final class Mfd {
* @param rates to initialize builder with
*/
public static Builder from(double[] magnitudes, double[] rates) {
- return new Builder(new Properties(INCR), magnitudes, Optional.of(rates));
+ return new Builder(new Properties(INCR), magnitudes, rates);
}
/**
* Create an {@code Mfd.Builder} initialized with the supplied sequence.
*
- * @param mfd to initialize builder with
+ * @param xy sequence to initialize builder with
*/
- public static Builder from(XySequence mfd) {
- return new Builder(mfd);
+ public static Builder from(XySequence xy) {
+ return new Builder(xy);
}
/**
@@ -327,23 +365,25 @@ public final class Mfd {
return new Builder(mfd);
}
- private Builder(XySequence src) {
+ private Builder(XySequence xy) {
+ Mfds.checkValues(xy.xValues(), xy.yValues());
this.props = new Properties(INCR);
- this.mfd = MutableXySequence.copyOf(src);
+ this.mfd = MutableXySequence.copyOf(xy);
}
- private Builder(Mfd src) {
- this.props = src.props;
- this.mfd = MutableXySequence.copyOf(src.data);
+ private Builder(Mfd mfd) {
+ this.props = mfd.props;
+ this.mfd = MutableXySequence.copyOf(mfd.data);
}
- private Builder(
- Properties props,
- double[] magnitudes,
- Optional<double[]> rates) {
+ private Builder(Properties props, double[] magnitudes) {
+ this(props, magnitudes, new double[magnitudes.length]);
+ }
+ private Builder(Properties props, double[] magnitudes, double[] rates) {
+ Mfds.checkValues(Arrays.stream(magnitudes), Arrays.stream(rates));
this.props = props;
- this.mfd = MutableXySequence.create(magnitudes, rates);
+ this.mfd = MutableXySequence.create(magnitudes, Optional.of(rates));
}
/**
@@ -385,7 +425,7 @@ public final class Mfd {
* @return this {@code Builder} object
*/
public Builder scaleToCumulativeRate(double cumulativeRate) {
- return scale(cumulativeRate / Mfds.cumulativeRate(mfd));
+ return scale(checkRate(cumulativeRate) / Mfds.cumulativeRate(mfd));
}
/**
@@ -397,7 +437,7 @@ public final class Mfd {
* @return this {@code Builder} object
*/
public Builder scaleToIncrementalRate(double incrementalRate) {
- return scale(incrementalRate / mfd.y(0));
+ return scale(checkRate(incrementalRate) / mfd.y(0));
}
/**
@@ -407,7 +447,7 @@ public final class Mfd {
* @return this {@code Builder} object
*/
public Builder scaleToMomentRate(double momentRate) {
- return scale(momentRate / Mfds.momentRate(mfd));
+ return scale(checkRate(momentRate) / Mfds.momentRate(mfd));
}
/**
@@ -418,7 +458,7 @@ public final class Mfd {
* @return this {@code Builder} object
*/
public Builder transform(Consumer<XyPoint> action) {
- mfd.transform(action);
+ mfd.transform(checkNotNull(action));
return this;
}
}
@@ -426,9 +466,6 @@ public final class Mfd {
/**
* Properties object associated with a MFD. A properties object wraps the
* original parameters required to initialize a {@link Mfd.Builder}.
- * Properties <i>may</i> not align with an associated MFD downstream include
- * specific not include rate or uncertainty model information that may have
- * been used to scale and/or create multiple MFDs.
*/
public static class Properties {
@@ -436,6 +473,7 @@ public final class Mfd {
/* No-arg constructor for deserialization. */
private Properties() {
+ // TODO test this as null for no-arg
this.type = SINGLE;
}
@@ -476,8 +514,8 @@ public final class Mfd {
*
* @throws ClassCastException if properties are for other MFD type
*/
- public GrTaper getAsGrTaper() {
- return (GrTaper) this;
+ public TaperedGr getAsGrTaper() {
+ return (TaperedGr) this;
}
/** Return a MFD builder initialized with this properties object. */
@@ -485,31 +523,47 @@ public final class Mfd {
throw new UnsupportedOperationException();
}
+ @Override
+ public String toString() {
+ return type().toString();
+ }
+
/** Properties of a single magnitude MFD. */
public static final class Single extends Properties {
- private final double m;
+ private final double magnitude;
private final double rate;
/* No-arg constructor for deserialization. */
private Single() {
- m = Double.NaN;
+ magnitude = Double.NaN;
rate = 1.0;
};
- public Single(double m, double rate) {
+ /**
+ * Create a new properties object for a single MFD.
+ *
+ * @param magnitude of the distribution
+ * @param rate of the sole magnitude in the distribution
+ */
+ public Single(double magnitude, double rate) {
super(SINGLE);
- this.m = m;
+ this.magnitude = magnitude;
this.rate = rate;
}
- public Single(double m) {
- this(m, 1.0);
+ /**
+ * Create a new properties object for a single MFD with a rate of one.
+ *
+ * @param magnitude of the distribution
+ */
+ public Single(double magnitude) {
+ this(magnitude, 1.0);
}
/** The sole magnitude of the MFD */
- public double m() {
- return m;
+ public double magnitude() {
+ return magnitude;
}
/** The rate of the sole magnitude. */
@@ -522,17 +576,18 @@ public final class Mfd {
@Override
public Builder toBuilder() {
- checkMagnitude(m);
- checkArgument(rate >= 0.0);
+ /* Values checked in builder */
return new Builder(
this,
- new double[] { this.m },
- Optional.of(new double[] { this.rate == 0.0 ? 1.0 : this.rate }));
+ new double[] { this.magnitude },
+ // TODO this is bad
+ new double[] { this.rate == 0.0 ? 1.0 : this.rate });
}
// TODO note scale in docs
public Builder toGaussianBuilder(int nm, double σ, int nσ) {
- double μ = checkMagnitude(this.m);
+ /* Pre-check magnitudes; final arrays are checked in builder */
+ double μ = checkMagnitude(this.magnitude);
double mMin = checkMagnitude(μ - nσ * σ);
double mMax = checkMagnitude(μ + nσ * σ);
double Δm = (mMax - mMin) / (nm - 1);
@@ -540,18 +595,18 @@ public final class Mfd {
.centered()
.scale(5)
.build();
- Builder builder = new Builder(this, magnitudes, Optional.empty());
+ Builder builder = new Builder(this, magnitudes);
builder.mfd.forEach(p -> p.set(Maths.normalPdf(μ, σ, p.x())));
return builder;
}
@Override
public String toString() {
- return new StringBuilder()
- .append(type())
- .append(": ")
- .append(Map.of("m", m, "rate", rate))
+ String props = new StringBuilder()
+ .append("magnitude=").append(magnitude)
+ .append(", rate=").append(rate)
.toString();
+ return Mfds.propsToString(type(), props);
}
}
@@ -573,8 +628,10 @@ public final class Mfd {
this.mMax = Double.NaN;
}
- private GutenbergRichter(Type type, double a, double b, double Δm, double mMin,
- double mMax) {
+ private GutenbergRichter(
+ Type type, double a, double b,
+ double Δm, double mMin, double mMax) {
+
super(type);
this.a = a;
this.b = b;
@@ -583,8 +640,17 @@ public final class Mfd {
this.mMax = mMax;
}
- public GutenbergRichter(double b, double Δm, double mMin, double mMax) {
- this(GR, 1.0, b, Δm, mMin, mMax);
+ /**
+ * Create a new properties object for a Gutenberg-Richter MFD.
+ *
+ * @param a value of the distribution
+ * @param b value of the distribution
+ * @param Δm magnitude bin width of the distribution
+ * @param mMin minimum magnitude of the distribution
+ * @param mMin maximum magnitude of the distribution
+ */
+ public GutenbergRichter(double a, double b, double Δm, double mMin, double mMax) {
+ this(GR, a, b, Δm, mMin, mMax);
}
/** The Gutenberg-Richter {@code a}-value. */
@@ -619,33 +685,53 @@ public final class Mfd {
double[] magnitudes = Sequences.arrayBuilder(mMin, mMax, this.Δm)
.scale(4)
.build();
- Builder builder = new Builder(this, magnitudes, Optional.empty());
+ Builder builder = new Builder(this, magnitudes);
builder.mfd.forEach(p -> p.set(gutenbergRichterRate(this.a, this.b, p.x())));
return builder;
}
@Override
public String toString() {
+ return Mfds.propsToString(type(), propsString());
+ }
+
+ private String propsString() {
return new StringBuilder()
- .append(type())
- .append(": ")
- .append(Map.of("a", a, "b", b, "Δm", Δm, "mMin", mMin, "mMax", mMax))
+ .append("a=").append(a)
+ .append(", b=").append(b)
+ .append(", Δm=").append(Δm)
+ .append(", mMin=").append(mMin)
+ .append(", mMax=").append(mMax)
.toString();
}
}
/** Tapered Gutenberg–Richter MFD properties. */
- public static final class GrTaper extends GutenbergRichter {
+ public static final class TaperedGr extends GutenbergRichter {
private final double mc;
/* Dummy, no-arg constructor for deserialization. */
- private GrTaper() {
+ private TaperedGr() {
this.mc = Double.NaN;
}
- private GrTaper(double b, double Δm, double mMin, double mMax, double mc) {
- super(GR_TAPER, 1.0, b, Δm, mMin, mMax);
+ // TODO note that inital a value may not agree with distribution if
+ // it was transformed or scaled prior to building.
+
+ /**
+ * Create a new properties object for a tapered Gutenberg-Richter MFD with
+ * an initial {@code a}-value of one.
+ *
+ * @param a value of the distribution
+ * @param b value of the distribution
+ * @param Δm magnitude bin width of the distribution
+ * @param mMin minimum magnitude of the distribution
+ * @param mMin maximum magnitude of the distribution
+ * @param mc corner magnitude of the distribution
+ */
+ public TaperedGr(double a, double b, double Δm, double mMin, double mMax, double mc) {
+ super(GR_TAPER, a, b, Δm, mMin, mMax);
this.mc = mc;
}
@@ -663,12 +749,19 @@ public final class Mfd {
double[] magnitudes = Sequences.arrayBuilder(mMin, mMax, Δm())
.scale(4)
.build();
- Builder builder = new Builder(this, magnitudes, Optional.empty());
+ Builder builder = new Builder(this, magnitudes);
TaperFunction grTaper = new TaperFunction(Δm(), b(), mc);
builder.mfd.forEach(p -> p.set(
gutenbergRichterRate(a(), b(), p.x()) * grTaper.scale(p.x())));
return builder;
}
+
+ @Override
+ public String toString() {
+ return Mfds.propsToString(
+ type(),
+ super.propsString() + ", mc=" + mc);
+ }
}
private static final double M_MIN_MOMENT = magToMoment(4.0);
diff --git a/src/main/java/gov/usgs/earthquake/nshmp/mfd/Mfds.java b/src/main/java/gov/usgs/earthquake/nshmp/mfd/Mfds.java
index e3a21019..33321faa 100644
--- a/src/main/java/gov/usgs/earthquake/nshmp/mfd/Mfds.java
+++ b/src/main/java/gov/usgs/earthquake/nshmp/mfd/Mfds.java
@@ -7,6 +7,7 @@ import static java.lang.Math.log;
import static java.util.stream.Collectors.toList;
import java.util.Collection;
+import java.util.stream.DoubleStream;
import com.google.common.base.Converter;
import com.google.common.collect.Range;
@@ -15,6 +16,7 @@ import gov.usgs.earthquake.nshmp.Earthquakes;
import gov.usgs.earthquake.nshmp.Maths;
import gov.usgs.earthquake.nshmp.data.MutableXySequence;
import gov.usgs.earthquake.nshmp.data.XySequence;
+import gov.usgs.earthquake.nshmp.mfd.Mfd.Type;
/**
* Utility methods for working with magnitude frequency distributions (MFDs).
@@ -27,6 +29,30 @@ public final class Mfds {
private Mfds() {}
+ /**
+ * Ensure {@code rate ≥ 0.0}.
+ *
+ * @param rate to validate
+ * @return the validated rate
+ * @throws IllegalArgumentException if {@code rate} value is less than 0.0
+ */
+ public static double checkRate(double rate) {
+ return checkInRange(Range.atLeast(0.0), "Rate", rate);
+ }
+
+ static void checkValues(DoubleStream magnitudes, DoubleStream rates) {
+ magnitudes.forEach(Earthquakes::checkMagnitude);
+ rates.forEach(Mfds::checkRate);
+ }
+
+ static String propsToString(Type type, String propsString) {
+ return new StringBuilder(type.toString())
+ .append(" {")
+ .append(propsString)
+ .append("}")
+ .toString();
+ }
+
/**
* Combine the supplied MFDs into a single MFD, summing the rates of duplicate
* magnitudes.
@@ -128,6 +154,8 @@ public final class Mfds {
return moRate;
}
+ // TODO take Mfd not XySequence; replace with sum()??
+
/**
* Returns the total moment rate of an MFD defined by the magnitudes
* (x-vlaues) and incremental rates (y-values) in the supplied XySquence.
diff --git a/src/main/java/gov/usgs/earthquake/nshmp/model/Deserialize.java b/src/main/java/gov/usgs/earthquake/nshmp/model/Deserialize.java
index 4fe96e93..b393c007 100644
--- a/src/main/java/gov/usgs/earthquake/nshmp/model/Deserialize.java
+++ b/src/main/java/gov/usgs/earthquake/nshmp/model/Deserialize.java
@@ -36,9 +36,9 @@ import gov.usgs.earthquake.nshmp.geo.json.Properties;
import gov.usgs.earthquake.nshmp.gmm.Gmm;
import gov.usgs.earthquake.nshmp.gmm.UncertaintyModel;
import gov.usgs.earthquake.nshmp.mfd.Mfd;
-import gov.usgs.earthquake.nshmp.mfd.Mfd.Properties.GrTaper;
import gov.usgs.earthquake.nshmp.mfd.Mfd.Properties.GutenbergRichter;
import gov.usgs.earthquake.nshmp.mfd.Mfd.Properties.Single;
+import gov.usgs.earthquake.nshmp.mfd.Mfd.Properties.TaperedGr;
import gov.usgs.earthquake.nshmp.model.MfdConfig.AleatoryProperties;
import gov.usgs.earthquake.nshmp.tree.LogicGroup;
import gov.usgs.earthquake.nshmp.tree.LogicTree;
@@ -415,7 +415,7 @@ class Deserialize {
properties = GSON.fromJson(validateGr(obj), GutenbergRichter.class);
break;
case GR_TAPER:
- properties = GSON.fromJson(validateGrTaper(obj), GrTaper.class);
+ properties = GSON.fromJson(validateGrTaper(obj), TaperedGr.class);
break;
case INCR:
// TODO custom props object that we'll replace once MFDs built
diff --git a/src/main/java/gov/usgs/earthquake/nshmp/model/FaultRuptureSet.java b/src/main/java/gov/usgs/earthquake/nshmp/model/FaultRuptureSet.java
index 6fd5e69d..36cfe4b8 100644
--- a/src/main/java/gov/usgs/earthquake/nshmp/model/FaultRuptureSet.java
+++ b/src/main/java/gov/usgs/earthquake/nshmp/model/FaultRuptureSet.java
@@ -347,7 +347,7 @@ public class FaultRuptureSet implements RuptureSet {
Single props = mBranch.value().getAsSingle();
String id = String.join(":", props.type().name(), mBranch.id(), rBranch.id());
double weight = mBranch.weight() * rBranch.weight();
- propsTree.addBranch(id, new Single(props.m(), rate), weight);
+ propsTree.addBranch(id, new Single(props.magnitude(), rate), weight);
}
}
return propsTree.build();
@@ -418,7 +418,7 @@ public class FaultRuptureSet implements RuptureSet {
double Δm = Maths.round(Rm / nm, 6);
// System.out.println(Rm + " " + grProps.mMin + " " + mMax + " " + Δm);
- return new Mfd.Properties.GutenbergRichter(grProps.b(), Δm, grProps.mMin(), mMax);
+ return new Mfd.Properties.GutenbergRichter(1.0, grProps.b(), Δm, grProps.mMin(), mMax);
}
/*
@@ -644,10 +644,10 @@ public class FaultRuptureSet implements RuptureSet {
double moRate = moBranch.isPresent()
? moBranch.orElseThrow().value()
- : single.rate() * Earthquakes.magToMoment(single.m());
+ : single.rate() * Earthquakes.magToMoment(single.magnitude());
/* Optional epistemic uncertainty. */
- boolean epistemic = hasEpistemic(mfdConfig, single.m());
+ boolean epistemic = hasEpistemic(mfdConfig, single.magnitude());
/* Optional aleatory variability. */
boolean aleatory = mfdConfig.aleatoryProperties.isPresent();
@@ -657,7 +657,7 @@ public class FaultRuptureSet implements RuptureSet {
for (Branch<Double> epiBranch : mfdConfig.epistemicTree.orElseThrow()) {
- double mEpi = single.m() + epiBranch.value();
+ double mEpi = single.magnitude() + epiBranch.value();
double weightEpi = mfdWt * epiBranch.weight();
String id = mfdBranchId(mfdId, epiBranch.id());
@@ -685,14 +685,14 @@ public class FaultRuptureSet implements RuptureSet {
if (aleatory) {
MfdConfig.AleatoryProperties aleaProps = mfdConfig.aleatoryProperties.orElseThrow();
- Mfd mfd = newGaussianBuilder(single.m(), aleaProps)
+ Mfd mfd = newGaussianBuilder(single.magnitude(), aleaProps)
.scaleToMomentRate(moRate)
.build();
mfdTree.addBranch(mfdId, mfd, mfdWt);
} else {
- Mfd mfd = Mfd.newSingleBuilder(single.m())
+ Mfd mfd = Mfd.newSingleBuilder(single.magnitude())
.scaleToMomentRate(moRate)
.build();
mfdTree.addBranch(mfdId, mfd, mfdWt);
@@ -751,7 +751,7 @@ public class FaultRuptureSet implements RuptureSet {
/* GR MFD builder with mMax override. */
static Mfd.Builder newGrBuilder(Mfd.Properties.GutenbergRichter gr, double mMax) {
- return Mfd.newGutenbergRichterBuilder(gr.mMin(), mMax, gr.Δm(), gr.b());
+ return Mfd.newGutenbergRichterBuilder(gr.b(), gr.Δm(), gr.mMin(), mMax);
}
/* Expected moment rate of a GR MFD. */
diff --git a/src/main/java/gov/usgs/earthquake/nshmp/model/MfdTrees.java b/src/main/java/gov/usgs/earthquake/nshmp/model/MfdTrees.java
index 4c1a2516..5f765e57 100644
--- a/src/main/java/gov/usgs/earthquake/nshmp/model/MfdTrees.java
+++ b/src/main/java/gov/usgs/earthquake/nshmp/model/MfdTrees.java
@@ -91,7 +91,7 @@ class MfdTrees {
*/
private static Mfd mMaxGrMfd(Mfd.Properties props, double mMax) {
GutenbergRichter gr = props.getAsGr();
- return Mfd.newGutenbergRichterBuilder(gr.mMin(), mMax, gr.Δm(), gr.b())
+ return Mfd.newGutenbergRichterBuilder(gr.b(), gr.Δm(), gr.mMin(), mMax)
.transform(p -> p.set(p.x() > gr.mMax() ? 0.0 : p.y()))
.build();
}
@@ -113,7 +113,7 @@ class MfdTrees {
double[] weights = new double[mfdTree.size()];
for (int i = 0; i < mfdTree.size(); i++) {
Branch<Mfd.Properties> mfd = mfdTree.get(i);
- magnitudes[i] = mfd.value().getAsSingle().m();
+ magnitudes[i] = mfd.value().getAsSingle().magnitude();
weights[i] = mfd.weight();
}
return Mfd.create(magnitudes, weights);
diff --git a/src/test/java/gov/usgs/earthquake/nshmp/mfd/IncrementalMfdBuilderTest.java b/src/test/java/gov/usgs/earthquake/nshmp/mfd/IncrementalMfdBuilderTest.java
deleted file mode 100644
index 894f499a..00000000
--- a/src/test/java/gov/usgs/earthquake/nshmp/mfd/IncrementalMfdBuilderTest.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/**
- *
- */
-package gov.usgs.earthquake.nshmp.mfd;
-
-/**
- * @author U.S. Geological Survey
- *
- */
-class IncrementalMfdBuilderTest {
-
- // /**
- // * @throws java.lang.Exception
- // */
- // @BeforeAll
- // public static void setUpBeforeClass() throws Exception {}
- //
- // /**
- // * @throws java.lang.Exception
- // */
- // @AfterAll
- // public static void tearDownAfterClass() throws Exception {}
- //
- // /**
- // * @throws java.lang.Exception
- // */
- // @Before
- // public void setUp() throws Exception {}
- //
- // /**
- // * @throws java.lang.Exception
- // */
- // @After
- // public void tearDown() throws Exception {}
- //
- // /**
- // * Test method for {@link
- // gov.usgs.earthquake.nshmp.mfd.IncrementalMfdBuilder#builder()}.
- // */
- // @Test
- // public final void testBuilder() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#Object()}.
- // */
- // @Test
- // public final void testObject() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#getClass()}.
- // */
- // @Test
- // public final void testGetClass() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#hashCode()}.
- // */
- // @Test
- // public final void testHashCode() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#equals(java.lang.Object)}.
- // */
- // @Test
- // public final void testEquals() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#clone()}.
- // */
- // @Test
- // public final void testClone() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#toString()}.
- // */
- // @Test
- // public final void testToString() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#notify()}.
- // */
- // @Test
- // public final void testNotify() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#notifyAll()}.
- // */
- // @Test
- // public final void testNotifyAll() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#wait(long)}.
- // */
- // @Test
- // public final void testWaitLong() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#wait(long, int)}.
- // */
- // @Test
- // public final void testWaitLongInt() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#wait()}.
- // */
- // @Test
- // public final void testWait() {
- // fail("Not yet implemented"); // TODO
- // }
- //
- // /**
- // * Test method for {@link java.lang.Object#finalize()}.
- // */
- // @Test
- // public final void testFinalize() {
- // fail("Not yet implemented"); // TODO
- // }
-
-}
diff --git a/src/test/java/gov/usgs/earthquake/nshmp/mfd/MfdTests.java b/src/test/java/gov/usgs/earthquake/nshmp/mfd/MfdTests.java
index 24c1aeb6..4688fd36 100644
--- a/src/test/java/gov/usgs/earthquake/nshmp/mfd/MfdTests.java
+++ b/src/test/java/gov/usgs/earthquake/nshmp/mfd/MfdTests.java
@@ -1,12 +1,405 @@
package gov.usgs.earthquake.nshmp.mfd;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Arrays;
+
import org.junit.jupiter.api.Test;
+import gov.usgs.earthquake.nshmp.data.XySequence;
+import gov.usgs.earthquake.nshmp.mfd.Mfd.Properties;
+import gov.usgs.earthquake.nshmp.mfd.Mfd.Properties.GutenbergRichter;
+import gov.usgs.earthquake.nshmp.mfd.Mfd.Properties.Single;
+import gov.usgs.earthquake.nshmp.mfd.Mfd.Properties.TaperedGr;
+import gov.usgs.earthquake.nshmp.mfd.Mfd.Type;
+
class MfdTests {
+ static final double[] M = { 5.05, 5.15, 5.25, 5.35, 5.45 };
+ static final double[] R = { 0.1, 0.08, 0.06, 0.04, 0.02 };
+
+ @Test
+ void testCreate() {
+ /* Covers array and xy constructors. */
+ Mfd mfd = Mfd.create(M, R);
+ assertArrayEquals(M, mfd.data().xValues().toArray());
+ assertArrayEquals(R, mfd.data().yValues().toArray());
+ assertEquals(Type.INCR, mfd.properties().type());
+ }
+
+ static final double[] GAUSS_M = {
+ 6.76,
+ 6.808,
+ 6.856,
+ 6.904,
+ 6.952,
+ 7.0,
+ 7.048,
+ 7.096,
+ 7.144,
+ 7.192,
+ 7.24 };
+
+ static final double[] GAUSS_R = {
+ 0.4499247209432322,
+ 0.9243402889954612,
+ 1.618217124860106,
+ 2.414096273012355,
+ 3.068917835861028,
+ 3.324519003345273,
+ 3.068917835861028,
+ 2.414096273012355,
+ 1.618217124860106,
+ 0.9243402889954612,
+ 0.4499247209432322 };
+
+ @Test
+ void testBuilderFrom() {
+ // TODO
+ }
+
+ @Test
+ void testSingle() {
+
+ /* Factory builder; covers props.toBuilder() */
+ Mfd mfd = Mfd.newSingleBuilder(6.0).build();
+ XySequence xy = mfd.data();
+ assertTrue(xy.size() == 1);
+ assertEquals(6.0, xy.min().x());
+ assertEquals(1.0, xy.min().y());
+
+ /* Factory builder; covers props.toGaussianBuilder() */
+ mfd = Mfd.newGaussianBuilder(7.0, 11, 0.12, 2).build();
+ xy = mfd.data();
+ assertTrue(xy.size() == 11);
+ System.out.println(xy);
+ assertArrayEquals(GAUSS_M, xy.xValues().toArray());
+ assertArrayEquals(GAUSS_R, xy.yValues().toArray());
+
+ /* Properties */
+ Properties props = new Single(5.0, 2.0);
+ Single singleProps = props.getAsSingle(); // cover getAs
+ assertEquals(5.0, singleProps.magnitude());
+ assertEquals(2.0, singleProps.rate());
+ singleProps = new Single(7.0);
+ assertEquals(7.0, singleProps.magnitude());
+ assertEquals(1.0, singleProps.rate());
+
+ /* props.toString() */
+ assertEquals(
+ singleProps.type() +
+ " {magnitude=" + singleProps.magnitude() +
+ ", rate=" + singleProps.rate() + "}",
+ singleProps.toString());
+
+ // TODO changing rate=0 to 1 is probably not correct
+ // and this check should/will go away
+ singleProps = new Single(7.0, 0.0);
+ mfd = singleProps.toBuilder().build();
+ xy = mfd.data();
+ assertEquals(7.0, xy.min().x());
+ assertEquals(1.0, xy.min().y());
+ }
+
+ static final double[] GR_M = {
+ 5.05,
+ 5.15,
+ 5.25,
+ 5.35,
+ 5.45 };
+
+ static final double[] GR_R = {
+ 8.912509381337459E-5,
+ 7.079457843841373E-5,
+ 5.623413251903491E-5,
+ 4.466835921509635E-5,
+ 3.5481338923357534E-5 };
+
+ @Test
+ void testGutenbergRichter() {
+
+ /* Factory builder; covers props.toBuilder() */
+ Mfd mfd = Mfd.newGutenbergRichterBuilder(1.0, 0.1, 5.0, 5.5).build();
+ XySequence xy = mfd.data();
+ assertTrue(xy.size() == 5);
+ assertArrayEquals(GR_M, xy.xValues().toArray());
+ assertArrayEquals(GR_R, xy.yValues().toArray());
+
+ /* Properties */
+ Properties props = new GutenbergRichter(1.0, 1.0, 0.1, 5.0, 5.5);
+ GutenbergRichter grProps = props.getAsGr(); // cover getAs
+ assertEquals(1.0, grProps.a());
+ assertEquals(1.0, grProps.b());
+ assertEquals(0.1, grProps.Δm());
+ assertEquals(5.0, grProps.mMin());
+ assertEquals(5.5, grProps.mMax());
+
+ /* props.toString() */
+ assertEquals(
+ grProps.type() + " {a=" + grProps.a() +
+ ", b=" + grProps.b() +
+ ", Δm=" + grProps.Δm() +
+ ", mMin=" + grProps.mMin() +
+ ", mMax=" + grProps.mMax() + "}",
+ grProps.toString());
+ }
+
+ /*
+ * TODO something in the TaperedGR moment based scaling leads to differences
+ * in the 4th to 5th significant figure that should be better understood, and
+ * then this main method cleaned out. The results are still pretty close
+ * overall.
+ */
+ public static void main(String[] args) {
+ double bVal = 1.0;
+ double aVal = Math.log10(150.0);
+ double Δm = 0.1;
+ double mMin = 5.0;
+ double mMax = 8.0;
+ double mc = 7.5;
+
+ /* GR direct vs scaled builder comparison */
+ System.out.println("Gutenberg Richter");
+ Mfd mfd = new GutenbergRichter(aVal, bVal, Δm, mMin, mMax)
+ .toBuilder()
+ .build();
+
+ System.out.println(Arrays.toString(mfd.data().xValues().toArray()));
+ System.out.println(Arrays.toString(mfd.data().yValues().toArray()));
+
+ double incrRate = Mfds.gutenbergRichterRate(aVal, bVal, 5.05);
+ mfd = Mfd.newGutenbergRichterBuilder(bVal, Δm, mMin, mMax)
+ .scaleToIncrementalRate(incrRate)
+ .build();
+
+ System.out.println(Arrays.toString(mfd.data().yValues().toArray()));
+
+ /* GR direct vs scaled builder comparison */
+ System.out.println("Tapered Gutenberg Richter");
+ mfd = new TaperedGr(aVal, bVal, Δm, mMin, mMax, mc)
+ .toBuilder()
+ .build();
+
+ System.out.println(Arrays.toString(mfd.data().xValues().toArray()));
+ System.out.println(Arrays.toString(mfd.data().yValues().toArray()));
+
+ incrRate = Mfds.gutenbergRichterRate(aVal, bVal, 5.05);
+ mfd = Mfd.newTaperedGutenbergRichterBuilder(bVal, Δm, mMin, mMax, mc)
+ .scaleToIncrementalRate(incrRate)
+ .build();
+
+ System.out.println(Arrays.toString(mfd.data().yValues().toArray()));
+
+ }
+
+ private static final double[] TAPERED_GR_M = {
+ 5.05, 5.15, 5.25, 5.35, 5.45,
+ 5.55, 5.65, 5.75, 5.85, 5.95,
+ 6.05, 6.15, 6.25, 6.35, 6.45,
+ 6.55, 6.65, 6.75, 6.85, 6.95,
+ 7.05, 7.15, 7.25, 7.35, 7.45,
+ 7.55, 7.65, 7.75, 7.85, 7.95 };
+
+ /* using scaleToInrementalRate */
+ private static final double[] TAPERED_GR_R_SCALED = {
+ 3.6480433574236396E-4,
+ 3.0345403881799134E-4,
+ 2.5242909958337484E-4,
+ 2.099931150361607E-4,
+ 1.7470192588897718E-4,
+ 1.4535446859752395E-4,
+ 1.2095189730212225E-4,
+ 1.0066358352203966E-4,
+ 8.37988347826301E-5,
+ 6.978336683158799E-5,
+ 5.813972403773392E-5,
+ 4.847097401109892E-5,
+ 4.044710933063091E-5,
+ 3.37936743657631E-5,
+ 2.8282200517277984E-5,
+ 2.372208037314646E-5,
+ 1.9953542732997602E-5,
+ 1.684141264491656E-5,
+ 1.4269370950942086E-5,
+ 1.213450863835374E-5,
+ 1.034219228924177E-5,
+ 8.801777631086678E-6,
+ 7.4247305061395814E-6,
+ 6.128255653142835E-6,
+ 4.84871327802538E-6,
+ 3.5668582219695296E-6,
+ 2.3358516405761174E-6,
+ 1.2823409762916182E-6,
+ 5.437829885686744E-7,
+ 1.5949675112240326E-7 };
+
+ /* using a value directly from properties */
+ private static final double[] TAPERED_GR_R_DIRECT = {
+ 3.648734771264746E-4,
+ 3.0351155247723867E-4,
+ 2.5247694248332143E-4,
+ 2.100329150418206E-4,
+ 1.7473503715378214E-4,
+ 1.4538201763727166E-4,
+ 1.2097482132130438E-4,
+ 1.006826622960901E-4,
+ 8.381471718000331E-5,
+ 6.979659287661517E-5,
+ 5.815074326255646E-5,
+ 4.848016071724236E-5,
+ 4.0454775273297684E-5,
+ 3.3800079282566184E-5,
+ 2.8287560844165223E-5,
+ 2.3726576420233308E-5,
+ 1.9957324528955875E-5,
+ 1.684460459870263E-5,
+ 1.4272075425536471E-5,
+ 1.213680849238659E-5,
+ 1.034415244546678E-5,
+ 8.803445832444015E-6,
+ 7.426137715686032E-6,
+ 6.1294171417451564E-6,
+ 4.849632254896958E-6,
+ 3.5675342487878286E-6,
+ 2.3362943546550987E-6,
+ 1.2825840184413838E-6,
+ 5.438860517858616E-7,
+ 1.5952698054966957E-7 };
+
+ @Test
+ void testTaperedGr() {
+
+ /* Factory builder; covers props.toBuilder() */
+ double incrRate = Mfds.gutenbergRichterRate(Math.log10(4.0), 0.8, 5.05);
+ Mfd mfd = Mfd.newTaperedGutenbergRichterBuilder(0.8, 0.1, 5.0, 8.0, 7.5)
+ .scaleToIncrementalRate(incrRate)
+ .build();
+ XySequence xy = mfd.data();
+ assertTrue(xy.size() == 30);
+
+ System.out.println(Arrays.toString(xy.xValues().toArray()));
+ System.out.println(Arrays.toString(xy.yValues().toArray()));
+
+ assertArrayEquals(TAPERED_GR_M, xy.xValues().toArray());
+ assertArrayEquals(TAPERED_GR_R_SCALED, xy.yValues().toArray());
+
+ /* Properties */
+ double aValue = Math.log10(4.0);
+ Properties props = new TaperedGr(aValue, 0.8, 0.1, 5.0, 8.0, 7.5);
+ TaperedGr grProps = props.getAsGrTaper(); // cover getAs
+ assertEquals(aValue, grProps.a());
+ assertEquals(0.8, grProps.b());
+ assertEquals(0.1, grProps.Δm());
+ assertEquals(5.0, grProps.mMin());
+ assertEquals(8.0, grProps.mMax());
+ assertEquals(7.5, grProps.mc());
+ assertTrue(xy.size() == 30);
+ mfd = props.toBuilder().build();
+ xy = mfd.data();
+ assertArrayEquals(TAPERED_GR_M, xy.xValues().toArray());
+ assertArrayEquals(TAPERED_GR_R_DIRECT, xy.yValues().toArray());
+
+ /* props.toString() */
+ assertEquals(
+ grProps.type() + " {a=" + grProps.a() +
+ ", b=" + grProps.b() +
+ ", Δm=" + grProps.Δm() +
+ ", mMin=" + grProps.mMin() +
+ ", mMax=" + grProps.mMax() +
+ ", mc=" + grProps.mc() + "}",
+ grProps.toString());
+ }
+
+ private static final double[] GR_M_TRANDSORM = TAPERED_GR_M;
+
+ private static final double[] GR_R_TRANSFORM = {
+ 0.0013368764072006192,
+ 0.0010619186765762063,
+ 8.435119877855239E-4,
+ 6.700253882264454E-4,
+ 5.322200838503631E-4,
+ 4.2275743968966836E-4,
+ 3.3580817078525074E-4,
+ 2.667419115058385E-4,
+ 2.1188063169341338E-4,
+ 1.683027681452945E-4,
+ 1.3368764072006192E-4,
+ 1.0619186765762062E-4,
+ 8.435119877855238E-5,
+ 6.700253882264454E-5,
+ 5.322200838503631E-5,
+ 4.227574396896683E-5,
+ 3.358081707852507E-5,
+ 2.667419115058385E-5,
+ 2.1188063169341338E-5,
+ 1.683027681452945E-5,
+ 1.3368764072006191E-5,
+ 1.0619186765762062E-5,
+ 8.435119877855238E-6,
+ 6.700253882264454E-6,
+ 5.322200838503631E-6,
+ 4.227574396896683E-6,
+ 3.3580817078525076E-6,
+ 2.6674191150583848E-6,
+ 2.1188063169341338E-6,
+ 1.683027681452945E-6 };
+
@Test
- void test() {
- // fail("Not yet implemented");
+ void testBuilderTransforms() {
+
+ /* tolerances set based on experimentaion with each transform */
+
+ double bVal = 1.0;
+ double aVal = Math.log10(150.0);
+ double Δm = 0.1;
+ double mMin = 5.0;
+ double mMax = 8.0;
+
+ Mfd mfd = new GutenbergRichter(aVal, bVal, Δm, mMin, mMax)
+ .toBuilder()
+ .build();
+
+ /* Scale to incremental */
+ double incrRate = Mfds.gutenbergRichterRate(aVal, bVal, 5.05);
+ Mfd scaleIncrMfd = Mfd.newGutenbergRichterBuilder(bVal, Δm, mMin, mMax)
+ .scaleToIncrementalRate(incrRate)
+ .build();
+
+ assertArrayEquals(
+ mfd.data().yValues().toArray(),
+ scaleIncrMfd.data().yValues().toArray(),
+ 1e-18);
+
+ /* Scale to cumulative */
+ double cumulativeRateExpected = mfd.data().yValues().sum() * 2.0;
+ Mfd scaleCumulativeMfd = Mfd.newGutenbergRichterBuilder(bVal, Δm, mMin, mMax)
+ .scaleToCumulativeRate(cumulativeRateExpected)
+ .build();
+ double cumulativeRateActual = scaleCumulativeMfd.data().yValues().sum();
+ assertEquals(cumulativeRateExpected, cumulativeRateActual, 1e-17);
+
+ /* Scale to moment */
+ double momentRateExpected = Mfds.momentRate(mfd.data()) * 2.0;
+ Mfd scaleMomentMfd = Mfd.newGutenbergRichterBuilder(bVal, Δm, mMin, mMax)
+ .scaleToMomentRate(momentRateExpected)
+ .build();
+ double momentRateActual = Mfds.momentRate(scaleMomentMfd.data());
+ /* very small delta relative to 1e16 moment rate values */
+ assertEquals(momentRateExpected, momentRateActual, 10);
+
+ /* Transform */
+ double transformRateExpected = cumulativeRateExpected;
+ Mfd transformMfd = new GutenbergRichter(aVal, bVal, Δm, mMin, mMax)
+ .toBuilder()
+ .transform(xy -> xy.set(xy.y() * 2.0))
+ .build();
+ double transformRateActual = transformMfd.data().yValues().sum();
+ System.out.println(transformRateExpected);
+ System.out.println(transformRateActual);
+ /* these values happen to match exactly */
+ assertEquals(transformRateExpected, transformRateActual);
}
}
diff --git a/src/test/java/gov/usgs/earthquake/nshmp/mfd/Mfds2Test.java b/src/test/java/gov/usgs/earthquake/nshmp/mfd/Mfds2Test.java
deleted file mode 100644
index 50e6a8a2..00000000
--- a/src/test/java/gov/usgs/earthquake/nshmp/mfd/Mfds2Test.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- *
- */
-package gov.usgs.earthquake.nshmp.mfd;
-
-/**
- * @author U.S. Geological Survey
- *
- */
-class Mfds2Test {
-
- // /**
- // * @throws java.lang.Exception
- // */
- // @BeforeAll
- // public static void setUpBeforeClass() throws Exception {}
- //
- // /**
- // * @throws java.lang.Exception
- // */
- // @AfterAll
- // public static void tearDownAfterClass() throws Exception {}
- //
- // /**
- // * @throws java.lang.Exception
- // */
- // @Before
- // public void setUp() throws Exception {}
- //
- // /**
- // * @throws java.lang.Exception
- // */
- // @After
- // public void tearDown() throws Exception {}
- //
- // /**
- // * Test method for {@link gov.usgs.earthquake.nshmp.mfd.Mfds2#builder()}.
- // */
- // @Test
- // public final void testBuilder() {
- // fail("Not yet implemented"); // TODO
- // }
-
-}
diff --git a/src/test/java/gov/usgs/earthquake/nshmp/mfd/MfdsTests.java b/src/test/java/gov/usgs/earthquake/nshmp/mfd/MfdsTests.java
index cbcb65f6..20571e21 100644
--- a/src/test/java/gov/usgs/earthquake/nshmp/mfd/MfdsTests.java
+++ b/src/test/java/gov/usgs/earthquake/nshmp/mfd/MfdsTests.java
@@ -1,68 +1,43 @@
package gov.usgs.earthquake.nshmp.mfd;
-class MfdsTests {
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.stream.DoubleStream;
- private static final double MFD_TOL = 1e-10;
+import org.junit.jupiter.api.Test;
- // @Test
- // final void testTaperedGR() {
- // // IncrementalMfd tGR = Mfds.newTaperedGutenbergRichterMFD(5.05, 0.1, 30,
- // // 4.0, 0.8, 7.5, 1.0);
- //
- // double incrRate = Mfds.incrRate(4.0, 0.8, 5.05);
- // XySequence tGR = Mfd.newTaperedGutenbergRichterMfd(5.05, 7.95, 0.1, 0.8,
- // 7.5)
- // .scaleToIncrementalRate(incrRate)
- // .build();
- // assertArrayEquals(TAPERED_GR_MAGS, tGR.xValues().toArray(), MFD_TOL);
- // assertArrayEquals(TAPERED_GR_RATES, tGR.yValues().toArray(), MFD_TOL);
- // }
+import gov.usgs.earthquake.nshmp.mfd.Mfd.Type;
+
+class MfdsTests {
- public static void main(String[] args) {
- // TODO clean
- // IncrementalMfd tGR = Mfd.newTaperedGutenbergRichterMFD(5.05, 0.1, 30,
- // 4.0, 0.8, 7.5, 1.0);
- // System.out.println(tGR.xValues());
- // System.out.println(tGR.yValues());
- // for (Point2D p : tGR) {
- // System.out.println(p.getX() + " " + p.getY());
- // }
+ @Test
+ void testCheckRate() {
+ assertEquals(1.0, Mfds.checkRate(1.0));
+ assertThrows(IllegalArgumentException.class, () -> {
+ Mfds.checkRate(-1.0);
+ });
}
- private static final double[] TAPERED_GR_MAGS = {
- 5.05, 5.15, 5.25, 5.35, 5.45, 5.55, 5.65,
- 5.75, 5.85, 5.95, 6.05, 6.15, 6.25, 6.35, 6.45, 6.55, 6.65, 6.75, 6.85, 6.95, 7.05, 7.15,
- 7.25, 7.35, 7.45, 7.55, 7.65, 7.75, 7.85, 7.95 };
+ @Test
+ void testValues() {
+ assertThrows(IllegalArgumentException.class, () -> {
+ Mfds.checkValues(DoubleStream.of(-5.0), DoubleStream.of(1.0));
+ });
+ assertThrows(IllegalArgumentException.class, () -> {
+ Mfds.checkValues(DoubleStream.of(5.0), DoubleStream.of(-1.0));
+ });
+ assertDoesNotThrow(() -> {
+ Mfds.checkValues(DoubleStream.of(5.0), DoubleStream.of(1.0));
+ });
+ }
+
+ @Test
+ void testPropsToString() {
+ assertEquals(
+ Type.SINGLE.name() + " {dummy}",
+ Mfds.propsToString(Type.SINGLE, "dummy"));
+ }
- private static final double[] TAPERED_GR_RATES = {
- 3.6487347712647455E-4,
- 3.0351155247723856E-4,
- 2.524769424833213E-4,
- 2.1003291504182055E-4,
- 1.747350371537821E-4,
- 1.4538201763727163E-4,
- 1.2097482132130435E-4,
- 1.0068266229609008E-4,
- 8.38147171800033E-5,
- 6.979659287661515E-5,
- 5.815074326255645E-5,
- 4.848016071724235E-5,
- 4.0454775273297684E-5,
- 3.380007928256618E-5,
- 2.828756084416522E-5,
- 2.37265764202333E-5,
- 1.995732452895587E-5,
- 1.6844604598702625E-5,
- 1.4272075425536466E-5,
- 1.2136808492386587E-5,
- 1.0344152445466779E-5,
- 8.803445832444012E-6,
- 7.426137715686029E-6,
- 6.129417141745154E-6,
- 4.849632254896957E-6,
- 3.5675342487878273E-6,
- 2.3362943546550987E-6,
- 1.2825840184413836E-6,
- 5.438860517858615E-7,
- 1.5952698054966954E-7 };
}
--
GitLab