public EqkRuptureDataForNrml(EqkRupture rup) {
averageRake = rup.getAveRake();
if (rup.getTectRegType() != null) {
tectonicRegion = rup.getTectRegType().toString();
} else {
tectonicRegion = unknownTectonicRegionType;
}
magRupture = rup.getMag();
EvenlyGriddedSurfaceAPI grid = rup.getRuptureSurface();
/*
* the site data
*/
numberOfColumns = grid.getNumCols();
numberOfRows = grid.getNumRows();
int countSites = numberOfColumns * numberOfRows;
latGrid = new double[countSites];
lonGrid = new double[countSites];
depthGrid = new double[countSites];
for (int row = 0; row < numberOfRows; row++) {
for (int col = 0; col < numberOfColumns; col++) {
Location l = grid.get(row, col);
int index = (row) * numberOfColumns + (col);
latGrid[index] = l.getLatitude();
lonGrid[index] = l.getLongitude();
depthGrid[index] = l.getDepth();
} // for columns
} // for rows
} // constructor()
/** This makes and returns the nth probEqkRupture for this source. */
public ProbEqkRupture getRupture(int nthRupture) {
// set the magnitude
double mag = mags.get(nthRupture).doubleValue();
probEqkRupture.setMag(mag);
// set the probability if it's Poissonian (otherwise this was already
// set)
if (isPoissonian)
probEqkRupture.setProbability(
1 - Math.exp(-duration * ((Double) rates.get(nthRupture)).doubleValue()));
// set the rake, depth, and dip if necessary
if (variableDepthRakeAndDip) {
probEqkRupture.setAveRake(rakes.get(nthRupture).doubleValue());
double depth;
if (mag < this.aveRupTopVersusMag.getMinX()) depth = this.defaultHypoDepth;
else depth = aveRupTopVersusMag.getClosestY(mag);
// location.setDepth(depth);
location = new Location(location.getLatitude(), location.getLongitude(), depth);
probEqkRupture.setPointSurface(location, dips.get(nthRupture).doubleValue());
}
// return the ProbEqkRupture
return probEqkRupture;
}
public Element toXMLMetadata(Element root, String name) {
Element el = root.addElement(name);
el.addAttribute("sectionId", this.getSectionId() + "");
el.addAttribute("sectionName", this.getSectionName());
el.addAttribute("shortName", this.getShortName());
el.addAttribute("aveLongTermSlipRate", this.getOrigAveSlipRate() + "");
el.addAttribute("slipRateStdDev", this.getOrigSlipRateStdDev() + "");
el.addAttribute("aveDip", this.getAveDip() + "");
el.addAttribute("aveRake", this.getAveRake() + "");
el.addAttribute("aveUpperDepth", this.getOrigAveUpperDepth() + "");
el.addAttribute("aveLowerDepth", this.getAveLowerDepth() + "");
el.addAttribute("aseismicSlipFactor", this.getAseismicSlipFactor() + "");
el.addAttribute("couplingCoeff", this.getCouplingCoeff() + "");
el.addAttribute("dipDirection", this.getDipDirection() + "");
String parentSectionName = this.getParentSectionName();
if (parentSectionName != null) el.addAttribute("parentSectionName", parentSectionName);
el.addAttribute("parentSectionId", getParentSectionId() + "");
el.addAttribute("connector", isConnector() + "");
if (getZonePolygon() != null) zonePolygon.toXMLMetadata(el, "ZonePolygon");
if (getDateOfLastEvent() > Long.MIN_VALUE)
el.addAttribute("dateOfLastEventMillis", getDateOfLastEvent() + "");
if (!Double.isNaN(getSlipInLastEvent()))
el.addAttribute("slipInLastEvent", getSlipInLastEvent() + "");
FaultTrace trace = this.getFaultTrace();
Element traceEl = el.addElement("FaultTrace");
traceEl.addAttribute("name", trace.getName());
for (int j = 0; j < trace.getNumLocations(); j++) {
Location loc = trace.get(j);
traceEl = loc.toXMLMetadata(traceEl);
}
return root;
}
public String toString() {
String str = new String();
str += "sectionId = " + this.getSectionId() + "\n";
str += "sectionName = " + this.getSectionName() + "\n";
str += "shortName = " + this.getShortName() + "\n";
str += "aveLongTermSlipRate = " + this.getOrigAveSlipRate() + "\n";
str += "slipRateStdDev = " + this.getOrigSlipRateStdDev() + "\n";
str += "aveDip = " + this.getAveDip() + "\n";
str += "aveRake = " + this.getAveRake() + "\n";
str += "aveUpperDepth = " + this.getOrigAveUpperDepth() + "\n";
str += "aveLowerDepth = " + this.getAveLowerDepth() + "\n";
str += "aseismicSlipFactor = " + this.getAseismicSlipFactor() + "\n";
str += "couplingCoeff = " + this.getCouplingCoeff() + "\n";
str += "dipDirection = " + this.getDipDirection() + "\n";
str += "dateOfLastEventMillis = " + this.getDateOfLastEvent() + "\n";
str += "slipInLastEvent = " + this.getSlipInLastEvent() + "\n";
str += "faultTrace:\n";
for (int i = 0; i < this.getFaultTrace().size(); i++) {
Location loc = this.getFaultTrace().get(i);
str += "\t" + loc.getLatitude() + ", " + loc.getLongitude() + ", " + loc.getDepth() + "\n";
}
return str;
}
public GEMFaultSourceData getFaultSourceData() {
// Create the fault trace
Location loc1 = new Location(this.lat, this.lon, this.depth);
if (this.strike > 180) this.strike -= 360;
// Location loctmp =
// RelativeLocation.location(loc1,strike/180.0*Math.PI,this.rectangleLenght);
Location loctmp = LocationUtils.location(loc1, strike / 180.0 * Math.PI, this.rectangleLenght);
if (INFO) {
System.out.printf(" Fault origin : %6.2f %6.2f\n", this.lon, this.lat);
System.out.printf(
" Fault end point: %6.2f %6.2f\n", loctmp.getLongitude(), loctmp.getLatitude());
}
System.out.printf("New fault strike .......: %+6.2f\n", this.strike);
FaultTrace trace = new FaultTrace(String.format("%d", this.id));
Location loc2 = new Location(loctmp.getLatitude(), loctmp.getLongitude(), this.depth);
if (this.dip > 90.0) {
trace.add(loc2);
trace.add(loc1);
this.dip = 180.0 - this.dip;
System.out.println("reverting");
} else {
trace.add(loc1);
trace.add(loc2);
}
// Magnitude-frequency distribution - mmin, mmax, numInt
IncrementalMagFreqDist mfd = new IncrementalMagFreqDist(this.magnitude, this.magnitude, 1);
mfd.add(0, this.averageActivity);
// Lower seismogenic depth
double seismDepthLow = this.depth + this.rectangleWidth * Math.sin(this.dip / 180.0 * Math.PI);
if (INFO) System.out.println(this.id);
// Checking dip value
if (dip > 90.0 || this.dip < 0.0) {
System.out.println("ID" + id + " dip:" + dip);
throw new RuntimeException("dip out of range");
}
// Checking depth value
if (depth < 0.0) {
System.out.println("ID" + id + " depth:" + depth);
throw new RuntimeException("depth out of range");
}
// Checking Seismogenic layer
if (seismDepthLow < this.depth) {
System.out.println("ID" + id + " Depth upp:" + depth + " Depth low" + seismDepthLow);
throw new RuntimeException("inconsistent depths");
}
// Create the GEM fault source data
GEMFaultSourceData srcData =
new GEMFaultSourceData(
String.format("%d", this.id),
this.name,
TectonicRegionType.ACTIVE_SHALLOW,
mfd,
trace,
this.dip,
-90.0,
seismDepthLow,
this.depth,
true);
return srcData;
}
@SuppressWarnings("unchecked")
public static FaultSectionPrefData fromXMLMetadata(Element el) {
int sectionId = Integer.parseInt(el.attributeValue("sectionId"));
String sectionName = el.attributeValue("sectionName");
String shortName = el.attributeValue("shortName");
double aveLongTermSlipRate = Double.parseDouble(el.attributeValue("aveLongTermSlipRate"));
double aveDip = Double.parseDouble(el.attributeValue("aveDip"));
double aveRake = Double.parseDouble(el.attributeValue("aveRake"));
double aveUpperDepth = Double.parseDouble(el.attributeValue("aveUpperDepth"));
double aveLowerDepth = Double.parseDouble(el.attributeValue("aveLowerDepth"));
double aseismicSlipFactor = Double.parseDouble(el.attributeValue("aseismicSlipFactor"));
float dipDirection = Float.parseFloat(el.attributeValue("dipDirection"));
Attribute parentSectNameAtt = el.attribute("parentSectionName");
String parentSectionName;
if (parentSectNameAtt != null) parentSectionName = parentSectNameAtt.getStringValue();
else parentSectionName = null;
Attribute parentSectIDAtt = el.attribute("parentSectionId");
int parentSectionId;
if (parentSectIDAtt != null)
parentSectionId = Integer.parseInt(parentSectIDAtt.getStringValue());
else parentSectionId = -1;
Element traceEl = el.element("FaultTrace");
String traceName = traceEl.attributeValue("name");
FaultTrace trace = new FaultTrace(traceName);
Iterator<Element> traceIt = (Iterator<Element>) traceEl.elementIterator();
while (traceIt.hasNext()) {
Element locEl = traceIt.next();
trace.add(Location.fromXMLMetadata(locEl));
}
boolean connector = false;
Attribute connectorAtt = el.attribute("connector");
if (connectorAtt != null) connector = Boolean.parseBoolean(connectorAtt.getStringValue());
Region zonePolygon = null;
Element zonePolygonEl = el.element("ZonePolygon");
if (zonePolygonEl != null) {
zonePolygon = Region.fromXMLMetadata(zonePolygonEl);
}
FaultSectionPrefData data = new FaultSectionPrefData();
data.setSectionId(sectionId);
data.setSectionName(sectionName);
data.setShortName(shortName);
data.setAveSlipRate(aveLongTermSlipRate);
data.setAveDip(aveDip);
data.setAveRake(aveRake);
data.setAveUpperDepth(aveUpperDepth);
data.setAveLowerDepth(aveLowerDepth);
data.setAseismicSlipFactor(aseismicSlipFactor);
Attribute couplingAtt = el.attribute("couplingCoeff");
if (couplingAtt != null)
data.setCouplingCoeff(Double.parseDouble(couplingAtt.getStringValue()));
data.setDipDirection(dipDirection);
data.setFaultTrace(trace);
data.setParentSectionName(parentSectionName);
data.setParentSectionId(parentSectionId);
data.setConnector(connector);
data.setZonePolygon(zonePolygon);
Attribute lastEventAtt = el.attribute("dateOfLastEventMillis");
if (lastEventAtt != null)
data.setDateOfLastEvent(Long.parseLong(lastEventAtt.getStringValue()));
Attribute lastSlipAtt = el.attribute("slipInLastEvent");
if (lastSlipAtt != null)
data.setSlipInLastEvent(Double.parseDouble(lastSlipAtt.getStringValue()));
return data;
}