QuakemlProductCreator.java

  1. package gov.usgs.earthquake.eids;

  3. import gov.usgs.earthquake.event.Converter;
  4. import gov.usgs.earthquake.product.ByteContent;
  5. import gov.usgs.earthquake.product.Content;
  6. import gov.usgs.earthquake.product.Product;
  7. import gov.usgs.earthquake.product.ProductId;
  8. import gov.usgs.earthquake.product.io.ObjectProductSource;
  9. import gov.usgs.earthquake.product.io.XmlProductHandler;
  10. import gov.usgs.earthquake.quakeml.FileToQuakemlConverter;
  11. import gov.usgs.util.StreamUtils;
  12. import gov.usgs.util.XmlUtils;

  14. import java.io.File;
  15. import java.math.BigDecimal;
  16. import java.math.BigInteger;
  17. import java.util.ArrayList;
  18. import java.util.Date;
  19. import java.util.Iterator;
  20. import java.util.List;
  21. import java.util.Map;
  22. import java.util.logging.Logger;

  24. import org.quakeml_1_2.Axis;
  25. import org.quakeml_1_2.ConfidenceEllipsoid;
  26. import org.quakeml_1_2.CreationInfo;
  27. import org.quakeml_1_2.EvaluationMode;
  28. import org.quakeml_1_2.Event;
  29. import org.quakeml_1_2.EventDescription;
  30. import org.quakeml_1_2.EventDescriptionType;
  31. import org.quakeml_1_2.EventParameters;
  32. import org.quakeml_1_2.EventType;
  33. import org.quakeml_1_2.FocalMechanism;
  34. import org.quakeml_1_2.InternalEvent;
  35. import org.quakeml_1_2.Magnitude;
  36. import org.quakeml_1_2.MomentTensor;
  37. import org.quakeml_1_2.NodalPlane;
  38. import org.quakeml_1_2.NodalPlanes;
  39. import org.quakeml_1_2.Origin;
  40. import org.quakeml_1_2.OriginQuality;
  41. import org.quakeml_1_2.OriginUncertainty;
  42. import org.quakeml_1_2.OriginUncertaintyDescription;
  43. import org.quakeml_1_2.Quakeml;
  44. import org.quakeml_1_2.RealQuantity;
  45. import org.quakeml_1_2.ScenarioEvent;
  46. import org.quakeml_1_2.SourceTimeFunction;
  47. import org.quakeml_1_2.SourceTimeFunctionType;
  48. import org.quakeml_1_2.Tensor;
  49. import org.quakeml_1_2.TimeQuantity;
  50. import org.quakeml_1_2.PrincipalAxes;
  51. import org.quakeml_1_2.EvaluationStatus;

  53. /**
  54.  * Create Products from ANSS Quakeml files.
  55.  */
  56. public class QuakemlProductCreator implements ProductCreator {

  58.     /** For use in logging issues */
  59.     public static final Logger LOGGER = Logger
  60.             .getLogger(QuakemlProductCreator.class.getName());

  62.     /** Content type for xml */
  63.     public static final String XML_CONTENT_TYPE = "application/xml";
  64.     /** Content path for quakeml */
  65.     public static final String QUAKEML_CONTENT_PATH = "quakeml.xml";
  66.     /** Contents XML path */
  67.     public static final String CONTENTS_XML_PATH = "contents.xml";

  69.     /** Var for number of meters/kilometer... */
  70.     public static final BigDecimal METERS_PER_KILOMETER = new BigDecimal("1000");

  72.     /** Version */
  73.     public static final String VERSION = "1.0";

  75.     /**
  76.      * When phases exist it is a "phase" type product. When this flag is set to
  77.      * true, a lightweight, origin-only type product (without bulky phase data)
  78.      * is also sent.
  79.      */
  80.     private boolean sendOriginWhenPhasesExist = false;
  81.     private boolean sendMechanismWhenPhasesExist = false;

  83.     // xml for the eqmessage currently being processed
  84.     private String quakemlXML;
  85.     private CreationInfo eventParametersCreationInfo;

  87.     // attributes of current quakeml being processed
  88.     private String productSource;
  89.     private String productCode;
  90.     private String eventSource;
  91.     private String eventCode;
  92.     private Date updateTime;

  94.     private FileToQuakemlConverter converter = null;
  95.     private Converter formatConverter = new Converter();
  96.     private boolean validate = false;

  98.     // default to fixing padding issues
  99.     private boolean padForBase64Bug = true;

  101.     /** Default Constructor */
  102.     public QuakemlProductCreator() {
  103.         super();
  104.     }

  106.     /**
  107.      * Constructor taking in argument for Base64 bug padding
  108.      * @param padForBase64Bug Boolean if needed to pad
  109.      */
  110.     public QuakemlProductCreator(boolean padForBase64Bug) {
  111.         this.padForBase64Bug = padForBase64Bug;
  112.     }

  114.     /**
  115.      * Gets Quakeml products with no rawQuakeml
  116.      * @param message Parsed quakeml message
  117.      * @return List of products
  118.      * @throws Exception if error occurs
  119.      */
  120.     public List<Product> getQuakemlProducts(final Quakeml message)
  121.             throws Exception {
  122.         return getQuakemlProducts(message, null);
  123.     }

  125.     /**
  126.      * Gets Quakeml products with the message as a rawQuakeml
  127.      * @param message Parsed quakeml message
  128.      * @return List of products
  129.      * @throws Exception if error occurs
  130.      */
  131.     public List<Product> getQuakemlProducts(final String message)
  132.             throws Exception {
  133.         Quakeml quakeml = formatConverter.getQuakeml(message, validate);
  134.         return getQuakemlProducts(quakeml, message);
  135.     }

  137.     /**
  138.      * Get products in a quakeml message.
  139.      *
  140.      * @param message
  141.      *            the parsed quakeml message.
  142.      * @param rawQuakeml
  143.      *            bytes of quakeml message. If null, the quakeml object will be
  144.      *            serialized into xml. This parameter is used to preserve the
  145.      *            original input, instead of always serializing from the quakeml
  146.      *            object.
  147.      * @return list of products generated from quakeml message.
  148.      * @throws Exception if error occurs
  149.      */
  150.     public List<Product> getQuakemlProducts(final Quakeml message,
  151.             final String rawQuakeml) throws Exception {
  152.         List<Product> products = new ArrayList<Product>();

  154.         // serialize for embedding in product
  155.         quakemlXML = rawQuakeml;
  156.         if (quakemlXML == null) {
  157.             quakemlXML = convertQuakemlToString(message);
  158.         } else {
  159.             quakemlXML = fixRawQuakeml(quakemlXML);
  160.         }

  162.         EventParameters eventParameters = message.getEventParameters();
  163.         eventParametersCreationInfo = eventParameters.getCreationInfo();

  165.         // only process first event
  166.         Event firstEvent = QuakemlUtils.getFirstEvent(eventParameters);
  167.         if (firstEvent != null) {
  168.             if (firstEvent instanceof InternalEvent) {
  169.                 products.addAll(getInternalEventProducts(message, (InternalEvent) firstEvent));
  170.             } else if (firstEvent instanceof ScenarioEvent) {
  171.                 products.addAll(getScenarioEventProducts(message, (ScenarioEvent) firstEvent));
  172.             } else {
  173.                 products.addAll(getEventProducts(message, firstEvent));
  174.             }
  175.         }

  177.         // add property to all products to indicate they all come from the same
  178.         // eventParameters "envelope"
  179.         String eventParametersPublicID = eventParameters.getPublicID();
  180.         Iterator<Product> productIter = products.iterator();
  181.         while (productIter.hasNext()) {
  182.             Product next = productIter.next();
  183.             setProperty(next.getProperties(), "eventParametersPublicID",
  184.                     eventParametersPublicID);
  185.         }

  187.         eventParametersCreationInfo = null;
  188.         quakemlXML = null;

  190.         return products;
  191.     }

  193.     /**
  194.      * Get internal products in quakeml event element.
  195.      *
  196.      * Calls {@link #getEventProducts(Quakeml, Event)}, and adds "internal-"
  197.      * prefix to each type in the returned list of products.
  198.      *
  199.      * @param message
  200.      *            the quakeml message.
  201.      * @param event
  202.      *            the internal event element.
  203.      * @return list of internal products found in event element, may be empty.
  204.      * @throws Exception if error occurs
  205.      */
  206.     public List<Product> getInternalEventProducts(final Quakeml message,
  207.             final InternalEvent event) throws Exception {
  208.         List<Product> products = getEventProducts(message, event);
  209.         Iterator<Product> iter = products.iterator();
  210.         while (iter.hasNext()) {
  211.             ProductId nextId = iter.next().getId();
  212.             nextId.setType("internal-" + nextId.getType());
  213.         }
  214.         return products;
  215.     }

  217.     /**
  218.      * Get scenario products in quakeml event element.
  219.      *
  220.      * Calls {@link #getEventProducts(Quakeml, Event)}, and adds "-scenario"
  221.      * suffix to each type in the returned list of products.
  222.      *
  223.      * @param message
  224.      *            the quakeml message.
  225.      * @param event
  226.      *            the scenario event element.
  227.      * @return list of scenario products found in event element, may be empty.
  228.      * @throws Exception if error occurs
  229.      */
  230.     public List<Product> getScenarioEventProducts(final Quakeml message,
  231.             final ScenarioEvent event) throws Exception {
  232.         List<Product> products = getEventProducts(message, event);
  233.         Iterator<Product> iter = products.iterator();
  234.         while (iter.hasNext()) {
  235.             ProductId nextId = iter.next().getId();
  236.             nextId.setType(nextId.getType() + "-scenario");
  237.         }
  238.         return products;
  239.     }

  241.     /**
  242.      * Get products in quakeml event element.
  243.      *
  244.      * @param message
  245.      *            the quakeml message.
  246.      * @param event
  247.      *            the event element in the quakeml message.
  248.      * @return list of products found in event element, may be empty.
  249.      * @throws Exception if error occurs
  250.      */
  251.     public List<Product> getEventProducts(final Quakeml message, Event event)
  252.             throws Exception {
  253.         List<Product> products = new ArrayList<Product>();

  255.         // read catalog attributes for product source and code, and event source
  256.         // and code
  257.         productSource = event.getDatasource();
  258.         productCode = event.getDataid();
  259.         eventSource = event.getEventsource();
  260.         eventCode = event.getEventid();

  262.         if (productSource == null || eventSource == null || eventCode == null) {
  263.             LOGGER.warning("Missing catalog attributes from event element, skipping");
  264.             // not anss information, don't convert to products
  265.             return products;
  266.         } else if (productCode == null) {
  267.             productCode = eventSource + eventCode;
  268.         }
  269.         productSource = productSource.toLowerCase();

  271.         // product update time
  272.         updateTime = null;
  273.         if (eventParametersCreationInfo != null) {
  274.             updateTime = eventParametersCreationInfo.getCreationTime();
  275.         } else {
  276.             LOGGER.warning("Missing eventParameters creationTime, using now for update time");
  277.             updateTime = new Date();
  278.         }

  280.         ByteContent quakemlContent = new ByteContent(quakemlXML.getBytes());
  281.         quakemlContent.setContentType(XML_CONTENT_TYPE);
  282.         quakemlContent.setLastModified(updateTime);

  284.         boolean hasPhaseData = QuakemlUtils.hasPhaseData(event);

  286.         // create this object, may go unused
  287.         Product originProduct = new Product(new ProductId(productSource,
  288.                 (hasPhaseData ? "phase-data" : "origin"), productCode,
  289.                 updateTime));
  290.         originProduct.setEventId(eventSource, eventCode);
  291.         if (event.getCreationInfo() != null) {
  292.             originProduct.setVersion(event.getCreationInfo().getVersion());
  293.         }
  294.         originProduct.getContents().put(QUAKEML_CONTENT_PATH, quakemlContent);
  295.         originProduct.getContents().put(CONTENTS_XML_PATH, getContentsXML());

  297.         // track which event this product is from
  298.         setProperty(originProduct.getProperties(), "quakeml-publicid",
  299.                 event.getPublicID());

  301.         // delete origin product
  302.         if (event.getType() == EventType.NOT_EXISTING) {
  303.             originProduct.setStatus(Product.STATUS_DELETE);
  304.             products.add(originProduct);

  306.             Product phaseDelete = new Product(originProduct);
  307.             phaseDelete.getId().setType("phase-data");
  308.             products.add(phaseDelete);

  310.             // don't need to delete other stuff
  311.             // when origins for event are deleted, event is deleted
  312.             return products;
  313.         }

  315.         Origin origin = QuakemlUtils.getPreferredOrigin(event);
  316.         if (origin != null) {
  317.             // track which origin this product is from
  318.             setProperty(originProduct.getProperties(), "quakeml-origin-publicid",
  319.                     origin.getPublicID());

  321.             // update origin product
  322.             Map<String, String> properties = originProduct.getProperties();

  324.             TimeQuantity eventTime = origin.getTime();
  325.             if (eventTime != null) {
  326.                 originProduct.setEventTime(eventTime.getValue());
  327.                 setProperty(properties, "eventtime-error",
  328.                         eventTime.getUncertainty());
  329.             }
  330.             RealQuantity eventLatitude = origin.getLatitude();
  331.             if (eventLatitude != null) {
  332.                 originProduct.setLatitude(eventLatitude.getValue());
  333.                 setProperty(properties, "latitude-error",
  334.                         eventLatitude.getUncertainty());
  335.             }
  336.             RealQuantity eventLongitude = origin.getLongitude();
  337.             if (eventLongitude != null) {
  338.                 originProduct.setLongitude(eventLongitude.getValue());
  339.                 setProperty(properties, "longitude-error",
  340.                         eventLongitude.getUncertainty());
  341.             }
  342.             RealQuantity depth = origin.getDepth();
  343.             if (depth != null) {
  344.                 originProduct.setDepth(depth.getValue().divide(
  345.                         METERS_PER_KILOMETER));
  346.                 if (depth.getUncertainty() != null) {
  347.                     setProperty(properties, "vertical-error", depth
  348.                             .getUncertainty().divide(METERS_PER_KILOMETER));
  349.                 }
  350.                 if (origin.getDepthType() != null) {
  351.                     setProperty(properties, "depth-type", origin.getDepthType()
  352.                             .value());
  353.                 }
  354.             }

  356.             // read horizontal error
  357.             OriginUncertainty originUncertainty = origin.getOriginUncertainty();
  358.             if (originUncertainty != null) {
  359.                 if (originUncertainty.getHorizontalUncertainty() != null) {
  360.                     setProperty(properties, "horizontal-error",
  361.                             originUncertainty.getHorizontalUncertainty()
  362.                                     .divide(METERS_PER_KILOMETER));
  363.                 } else if (originUncertainty.getPreferredDescription() == OriginUncertaintyDescription.HORIZONTAL_UNCERTAINTY) {
  364.                     throw new IllegalArgumentException(
  365.                             "Missing horizontal uncertainty value");
  366.                 }

  368.                 ConfidenceEllipsoid ellipse = originUncertainty.getConfidenceEllipsoid();
  369.                 if (ellipse != null) {
  370.                     setProperty(properties, "error-ellipse-azimuth",
  371.                             ellipse.getMajorAxisAzimuth());
  372.                     setProperty(properties, "error-ellipse-plunge",
  373.                             ellipse.getMajorAxisPlunge());
  374.                     setProperty(properties, "error-ellipse-rotation",
  375.                             ellipse.getMajorAxisRotation());
  376.                     setProperty(properties, "error-ellipse-major",
  377.                             ellipse.getSemiMajorAxisLength());
  378.                     setProperty(properties, "error-ellipse-minor",
  379.                             ellipse.getSemiMinorAxisLength());
  380.                     setProperty(properties, "error-ellipse-intermediate",
  381.                             ellipse.getSemiIntermediateAxisLength());
  382.                 }
  383.             }

  385.             EventType eventType = event.getType();
  386.             properties.put("event-type",
  387.                     ((eventType == null) ? EventType.EARTHQUAKE : eventType)
  388.                             .value());

  390.             CreationInfo originCreationInfo = origin.getCreationInfo();
  391.             if (originCreationInfo != null) {
  392.                 setProperty(properties, "origin-source",
  393.                         originCreationInfo.getAgencyID());
  394.             }

  396.             OriginQuality originQuality = origin.getQuality();
  397.             if (originQuality != null) {
  398.                 setProperty(properties, "azimuthal-gap",
  399.                         originQuality.getAzimuthalGap());
  400.                 setProperty(properties, "num-phases-used",
  401.                         originQuality.getUsedPhaseCount());
  402.                 setProperty(properties, "num-stations-used",
  403.                         originQuality.getUsedStationCount());
  404.                 setProperty(properties, "minimum-distance",
  405.                         originQuality.getMinimumDistance());
  406.                 setProperty(properties, "standard-error",
  407.                         originQuality.getStandardError());
  408.             }

  410.             if (origin.getEvaluationMode() == EvaluationMode.MANUAL) {
  411.                 properties.put("review-status", "reviewed");
  412.             } else {
  413.                 properties.put("review-status", "automatic");
  414.             }

  416.             if (origin.getEvaluationStatus() != null) {
  417.                 properties.put("evaluation-status", origin
  418.                         .getEvaluationStatus().value());
  419.             } else {
  420.                 properties.put("evaluation-status",
  421.                         EvaluationStatus.PRELIMINARY.value());
  422.             }

  424.             // add magnitude properties
  425.             Magnitude magnitude = QuakemlUtils.getPreferredMagnitude(event);
  426.             if (magnitude != null) {
  427.                 // track which origin this product is from
  428.                 setProperty(originProduct.getProperties(), "quakeml-magnitude-publicid",
  429.                         magnitude.getPublicID());

  431.                 CreationInfo magnitudeCreationInfo = magnitude
  432.                         .getCreationInfo();
  433.                 if (magnitudeCreationInfo != null) {
  434.                     setProperty(properties, "magnitude-source",
  435.                             magnitudeCreationInfo.getAgencyID());
  436.                 }

  438.                 originProduct.setMagnitude(QuakemlUtils.getValue(magnitude
  439.                         .getMag()));

  441.                 setProperty(properties, "magnitude-type",
  442.                         QuakemlUtils.getMagnitudeType(magnitude.getType()));
  443.                 setProperty(properties, "magnitude-azimuthal-gap",
  444.                         magnitude.getAzimuthalGap());
  445.                 try {
  446.                     setProperty(properties, "magnitude-error", magnitude
  447.                             .getMag().getUncertainty());
  448.                 } catch (Exception e) {
  449.                     // no magnitude uncertainty
  450.                 }
  451.                 setProperty(properties, "magnitude-num-stations-used",
  452.                         magnitude.getStationCount());
  453.             } else {
  454.                 // a location without a magnitude
  455.             }

  457.             products.add(originProduct);
  458.         } else {
  459.             // no preferred origin found
  460.             // signal origin product hasn't been created
  461.             originProduct = null;
  462.         }

  464.         // look for event description products
  465.         Iterator<EventDescription> iter = event.getDescriptions().iterator();
  466.         while (iter.hasNext()) {
  467.             EventDescription next = iter.next();
  468.             EventDescriptionType type = next.getType();

  470.             if (type == EventDescriptionType.EARTHQUAKE_NAME) {
  471.                 if (originProduct != null) {
  472.                     // Region name overrides should be sent
  473.                     // from the admin pages, or attached to an origin. That way
  474.                     // only a preferred origin, or a manually sent region,
  475.                     // can alter the displayed region name
  476.                     setProperty(originProduct.getProperties(), "title", next
  477.                             .getText().trim());
  478.                 }
  479.             } else if (type == EventDescriptionType.TECTONIC_SUMMARY) {
  480.                 Product product = new Product(new ProductId(productSource,
  481.                         "tectonic-summary", productCode, updateTime));
  482.                 product.setEventId(eventSource, eventCode);
  483.                 ByteContent content = new ByteContent(next.getText().getBytes());
  484.                 content.setLastModified(updateTime);
  485.                 product.getContents().put("tectonic-summary.inc.html", content);

  487.                 products.add(product);
  488.             } else if (type == EventDescriptionType.FELT_REPORT) {
  489.                 Product product = new Product(new ProductId(productSource,
  490.                         "impact-text", productCode, updateTime));
  491.                 product.setEventId(eventSource, eventCode);
  492.                 ByteContent content = new ByteContent(next.getText().getBytes());
  493.                 content.setLastModified(updateTime);
  494.                 product.getContents().put("", content);

  496.                 products.add(product);
  497.             }
  498.         }

  500.         if (sendMechanismWhenPhasesExist || originProduct == null
  501.                 || !hasPhaseData) {
  502.             Iterator<FocalMechanism> focalMechanisms = event
  503.                     .getFocalMechanisms().iterator();
  504.             while (focalMechanisms.hasNext()) {
  505.                 FocalMechanism mech = focalMechanisms.next();
  506.                 Product mechProduct = null;

  508.                 if (hasPhaseData && originProduct != null) {
  509.                     // when a phase data product was created, send lightweight
  510.                     // focal mechanism
  511.                     Quakeml lightweightQuakeml = QuakemlUtils
  512.                             .getLightweightFocalMechanism(message,
  513.                                     mech.getPublicID());
  514.                     Event lightweightEvent = QuakemlUtils.getFirstEvent(
  515.                             lightweightQuakeml.getEventParameters());
  516.                     FocalMechanism lightweightMech = QuakemlUtils
  517.                             .getFocalMechanism(lightweightEvent,
  518.                                     mech.getPublicID());

  520.                     mechProduct = getFocalMechanismProduct(lightweightQuakeml,
  521.                             lightweightEvent, lightweightMech,
  522.                             convertQuakemlToString(lightweightQuakeml));
  523.                 } else {
  524.                     // otherwise, fall back to original
  525.                     mechProduct = getFocalMechanismProduct(message, event,
  526.                             mech, quakemlXML);
  527.                 }

  529.                 if (mechProduct != null) {
  530.                     products.add(mechProduct);
  531.                 }
  532.             }
  533.         }

  535.         // send lightweight origin product
  536.         if (sendOriginWhenPhasesExist && hasPhaseData && originProduct != null) {
  537.             // create lightweight origin product
  538.             Product lightweightOrigin = new Product(originProduct);
  539.             lightweightOrigin.getId().setType("origin");

  541.             Quakeml lightweightQuakeml = QuakemlUtils
  542.                     .getLightweightOrigin(message);

  544.             // serialize xml without phase data
  545.             ByteContent lightweightContent = new ByteContent(convertQuakemlToString(lightweightQuakeml).getBytes());
  546.             lightweightContent.setContentType(XML_CONTENT_TYPE);
  547.             lightweightContent.setLastModified(updateTime);
  548.             lightweightOrigin.getContents().put(QUAKEML_CONTENT_PATH,
  549.                     lightweightContent);

  551.             // insert at front of list
  552.             products.add(0, lightweightOrigin);
  553.         }

  555.         return products;
  556.     }

  558.     /**
  559.      * @param quakeml Quakeml
  560.      * @param event the event element in the quakeml message
  561.      * @param mech A focal mechanism
  562.      * @param quakemlContent String of content in Quakeml
  563.      * @return A product derived from a focal mechanism
  564.      */
  565.     protected Product getFocalMechanismProduct(final Quakeml quakeml,
  566.             final Event event, final FocalMechanism mech,
  567.             final String quakemlContent) {
  568.         MomentTensor momentTensor = mech.getMomentTensor();

  570.         // determine product id
  571.         String mechSource = mech.getDatasource();
  572.         String mechCode = mech.getDataid();
  573.         String mechType = mech.getDatatype();
  574.         if (mechType == null) {
  575.             // automatically determine mechanism type based on available data
  576.             mechType = "focal-mechanism";
  577.             if (momentTensor != null && momentTensor.getTensor() != null) {
  578.                 mechType = "moment-tensor";
  579.                 if (mechCode == null && momentTensor.getMethodID() != null) {
  580.                     mechCode = productCode + "_" + momentTensor.getMethodID();
  581.                 }
  582.             }
  583.         }
  584.         if (mechSource == null) {
  585.             mechSource = productSource;
  586.         }
  587.         if (mechCode == null) {
  588.             mechCode = productCode;
  589.         }
  590.         Product product = new Product(new ProductId(mechSource, mechType,
  591.                 mechCode, updateTime));
  592.         if (mech.getEvaluationStatus() == EvaluationStatus.REJECTED) {
  593.             // this is a delete
  594.             product.setStatus(Product.STATUS_DELETE);
  595.         }

  597.         // product is being contributed to containing event
  598.         product.setEventId(eventSource, eventCode);

  600.         ByteContent tensorContent = new ByteContent(quakemlContent.getBytes());
  601.         tensorContent.setContentType(XML_CONTENT_TYPE);
  602.         tensorContent.setLastModified(updateTime);
  603.         product.getContents().put(QUAKEML_CONTENT_PATH, tensorContent);
  604.         product.getContents().put(CONTENTS_XML_PATH, getContentsXML());

  606.         Map<String, String> properties = product.getProperties();

  608.         // track which mechanism is used in this product, for later
  609.         // extraction
  610.         setProperty(properties, "quakeml-publicid", mech.getPublicID());
  611.         // also track original event if set, in case this is a recontributed
  612.         // product
  613.         setProperty(properties, "original-eventsource", mech.getEventsource());
  614.         setProperty(properties, "original-eventsourcecode", mech.getEventid());

  616.         if (mech.getEvaluationMode() == EvaluationMode.MANUAL) {
  617.             properties.put("review-status", "reviewed");
  618.         } else {
  619.             properties.put("review-status", "automatic");
  620.         }

  622.         if (mech.getEvaluationStatus() != null) {
  623.             properties.put("evaluation-status", mech.getEvaluationStatus()
  624.                     .value());
  625.         } else {
  626.             properties.put("evaluation-status", EvaluationStatus.PRELIMINARY
  627.                     .value());
  628.         }

  630.         CreationInfo focalMechanismCreationInfo = mech.getCreationInfo();
  631.         if (focalMechanismCreationInfo != null) {
  632.             product.setVersion(focalMechanismCreationInfo.getVersion());
  633.             setProperty(properties, "beachball-source",
  634.                     focalMechanismCreationInfo.getAgencyID());
  635.         }

  637.         NodalPlanes planes = mech.getNodalPlanes();
  638.         if (planes != null) {
  639.             NodalPlane plane1 = planes.getNodalPlane1();
  640.             setProperty(properties, "nodal-plane-1-strike", plane1.getStrike());
  641.             setProperty(properties, "nodal-plane-1-dip", plane1.getDip());
  642.             setProperty(properties, "nodal-plane-1-rake", plane1.getRake());

  644.             NodalPlane plane2 = planes.getNodalPlane2();
  645.             setProperty(properties, "nodal-plane-2-strike", plane2.getStrike());
  646.             setProperty(properties, "nodal-plane-2-dip", plane2.getDip());
  647.             setProperty(properties, "nodal-plane-2-rake", plane2.getRake());
  648.         }

  650.         // add properties for principal axes
  651.         PrincipalAxes axes = mech.getPrincipalAxes();
  652.         if (axes != null) {
  653.             Axis tAxis = axes.getTAxis();
  654.             if (tAxis != null) {
  655.                 setProperty(properties, "t-axis-azimuth", tAxis.getAzimuth());
  656.                 setProperty(properties, "t-axis-plunge", tAxis.getPlunge());
  657.                 setProperty(properties, "t-axis-length", tAxis.getLength(), true);
  658.             }
  659.             Axis nAxis = axes.getNAxis();
  660.             if (nAxis != null) {
  661.                 setProperty(properties, "n-axis-azimuth", nAxis.getAzimuth());
  662.                 setProperty(properties, "n-axis-plunge", nAxis.getPlunge());
  663.                 setProperty(properties, "n-axis-length", nAxis.getLength(), true);
  664.             }
  665.             Axis pAxis = axes.getPAxis();
  666.             if (pAxis != null) {
  667.                 setProperty(properties, "p-axis-azimuth", pAxis.getAzimuth());
  668.                 setProperty(properties, "p-axis-plunge", pAxis.getPlunge());
  669.                 setProperty(properties, "p-axis-length", pAxis.getLength(), true);
  670.             }
  671.         }

  673.         setProperty(properties, "num-stations-used",
  674.                 mech.getStationPolarityCount());

  676.         // try to read triggering origin attributes for association
  677.         Origin triggeringOrigin = QuakemlUtils.getOrigin(event,
  678.                 mech.getTriggeringOriginID());
  679.         if (triggeringOrigin != null) {
  680.             // set properties for association purposes.
  681.             product.setLatitude(triggeringOrigin.getLatitude().getValue());
  682.             product.setLongitude(triggeringOrigin.getLongitude().getValue());
  683.             product.setEventTime(triggeringOrigin.getTime().getValue());
  684.             // add triggering depth if present
  685.             if (triggeringOrigin.getDepth() != null) {
  686.                 product.setDepth(triggeringOrigin.getDepth().getValue()
  687.                         .divide(METERS_PER_KILOMETER));
  688.             }
  689.         }

  691.         Tensor tensor = null;
  692.         if (momentTensor != null) {
  693.             setProperty(properties, "percent-double-couple",
  694.                     momentTensor.getDoubleCouple());
  695.             setProperty(properties, "scalar-moment",
  696.                     momentTensor.getScalarMoment(), true);
  697.             setProperty(properties, "beachball-type",
  698.                     momentTensor.getMethodID());
  699.             if (momentTensor.getInversionType() != null) {
  700.                 setProperty(properties, "inversion-type",
  701.                         momentTensor.getInversionType().value());
  702.             }

  704.             tensor = momentTensor.getTensor();
  705.             if (tensor != null) {
  706.                 setProperty(properties, "tensor-mpp", tensor.getMpp(), true);
  707.                 setProperty(properties, "tensor-mrp", tensor.getMrp(), true);
  708.                 setProperty(properties, "tensor-mrr", tensor.getMrr(), true);
  709.                 setProperty(properties, "tensor-mrt", tensor.getMrt(), true);
  710.                 setProperty(properties, "tensor-mtp", tensor.getMtp(), true);
  711.                 setProperty(properties, "tensor-mtt", tensor.getMtt(), true);
  712.             }

  714.             SourceTimeFunction sourceTimeFunction = momentTensor
  715.                     .getSourceTimeFunction();
  716.             if (sourceTimeFunction != null) {
  717.                 SourceTimeFunctionType sourceTimeFunctionType = sourceTimeFunction
  718.                         .getType();
  719.                 if (sourceTimeFunctionType != null) {
  720.                     setProperty(properties, "sourcetime-type",
  721.                             sourceTimeFunctionType.value());
  722.                 }
  723.                 setProperty(properties, "sourcetime-duration",
  724.                         sourceTimeFunction.getDuration());
  725.                 setProperty(properties, "sourcetime-risetime",
  726.                         sourceTimeFunction.getRiseTime());
  727.                 setProperty(properties, "sourcetime-decaytime",
  728.                         sourceTimeFunction.getDecayTime());
  729.             }

  731.             Origin derivedOrigin = QuakemlUtils.getOrigin(event,
  732.                     momentTensor.getDerivedOriginID());

  734.             if (derivedOrigin != null) {
  735.                 setProperty(properties, "derived-latitude",
  736.                         derivedOrigin.getLatitude());
  737.                 setProperty(properties, "derived-longitude",
  738.                         derivedOrigin.getLongitude());
  739.                 RealQuantity depth = derivedOrigin.getDepth();
  740.                 if (depth != null) {
  741.                     setProperty(properties, "derived-depth", depth.getValue()
  742.                             .divide(METERS_PER_KILOMETER));
  743.                 }
  744.                 setProperty(properties, "derived-eventtime",
  745.                         derivedOrigin.getTime());
  746.             }

  748.             Magnitude derivedMagnitude = QuakemlUtils.getMagnitude(event,
  749.                     momentTensor.getMomentMagnitudeID());
  750.             if (derivedMagnitude != null) {
  751.                 String derivedMagnitudeType = derivedMagnitude.getType();
  752.                 setProperty(properties, "derived-magnitude-type",
  753.                         derivedMagnitudeType);
  754.                 setProperty(properties, "derived-magnitude",
  755.                         derivedMagnitude.getMag());

  757.                 if (derivedMagnitudeType.equalsIgnoreCase("Mwd")) {
  758.                     product.getId().setType("broadband-depth");
  759.                 }
  760.             }
  761.         }

  763.         if (!Product.STATUS_DELETE.equals(product.getStatus())) {
  764.             // if not deleting, do some validation
  765.             String type = product.getId().getType();
  766.             if ("focal-mechanism".equals(type) && planes == null) {
  767.                 LOGGER.warning("Focal mechanism missing nodal planes");
  768.                 return null;
  769.             } else if ("moment-tensor".equals(type) && tensor == null) {
  770.                 LOGGER.warning("Moment tensor missing tensor parameters");
  771.                 return null;
  772.             }
  773.         }

  775.         return product;
  776.     }

  778.     /**
  779.      * setProperty for RealQuantity values. No exponentials
  780.      * @param properties to add
  781.      * @param name of property
  782.      * @param value of property
  783.      */
  784.     public void setProperty(final Map<String, String> properties,
  785.             final String name, final RealQuantity value) {
  786.         setProperty(properties, name, value, false);
  787.     }

  789.     /**
  790.      * setProperty for RealQuantity values
  791.      * @param properties to add
  792.      * @param name of property
  793.      * @param value of property
  794.      * @param allowExponential if allowed
  795.      */
  796.     public void setProperty(final Map<String, String> properties,
  797.             final String name, final RealQuantity value,
  798.             final boolean allowExponential) {
  799.         if (value == null) {
  800.             return;
  801.         }

  803.         setProperty(properties, name, value.getValue(), allowExponential);
  804.     }

  806.     /**
  807.      * setProperty for strings
  808.      * @param properties to add
  809.      * @param name of property
  810.      * @param value of property
  811.      */
  812.     public void setProperty(final Map<String, String> properties,
  813.             final String name, final String value) {
  814.         if (value == null) {
  815.             return;
  816.         }

  818.         properties.put(name, value);
  819.     }

  821.     /**
  822.      * setProperty for TimeQuantities
  823.      * @param properties to add
  824.      * @param name of property
  825.      * @param value of property
  826.      */
  827.     public void setProperty(final Map<String, String> properties,
  828.             final String name, final TimeQuantity value) {
  829.         if (value == null) {
  830.             return;
  831.         }

  833.         properties.put(name, XmlUtils.formatDate(value.getValue()));
  834.     }

  836.     /**
  837.      * setProperty taking in BigDecimals. No exponentials
  838.      * @param properties to add
  839.      * @param name of property
  840.      * @param value of property
  841.      */
  842.     public void setProperty(final Map<String, String> properties,
  843.             final String name, final BigDecimal value) {
  844.         setProperty(properties, name, value, false);
  845.     }

  847.     /**
  848.      * setProperty taking in BigDecimals
  849.      * @param properties to add
  850.      * @param name of property
  851.      * @param value of property
  852.      * @param allowExponential boolean
  853.      */
  854.     public void setProperty(final Map<String, String> properties,
  855.             final String name, final BigDecimal value,
  856.             final boolean allowExponential) {
  857.         if (value == null) {
  858.             return;
  859.         }

  861.         properties.put(name, allowExponential ? value.toString()
  862.                 : value.toPlainString());
  863.     }

  865.     /**
  866.      * setProperty taking in BigIntegers. No exponentials
  867.      * @param properties to add
  868.      * @param name of property
  869.      * @param value of property
  870.      */
  871.     public void setProperty(final Map<String, String> properties,
  872.             final String name, final BigInteger value) {
  873.         if (value == null) {
  874.             return;
  875.         }

  877.         properties.put(name, value.toString());
  878.     }

  880.     /**
  881.      * setProperty taking in Integers
  882.      * @param properties to add
  883.      * @param name of property
  884.      * @param value of property
  885.      */
  886.     public void setProperty(final Map<String, String> properties,
  887.             final String name, final Integer value) {
  888.         if (value == null) {
  889.             return;
  890.         }

  892.         properties.put(name, value.toString());
  893.     }

  895.     /** @param converter FileToQuakeml Converter to set */
  896.     public void setConverter(FileToQuakemlConverter converter) {
  897.         this.converter = converter;
  898.     }

  900.     /** @return FileToQuakeml converter */
  901.     public FileToQuakemlConverter getConverter() {
  902.         return converter;
  903.     }

  905.     @Override
  906.     public boolean isValidate() {
  907.         return validate;
  908.     }

  910.     @Override
  911.     public void setValidate(boolean validate) {
  912.         this.validate = validate;
  913.     }

  915.     /**
  916.      * Implement the ProductCreator interface.
  917.      */
  918.     @Override
  919.     public List<Product> getProducts(File file) throws Exception {
  920.         if (this.converter == null) {
  921.             // preserve quakeml input
  922.             String contents = new String(StreamUtils.readStream(file));
  923.             return this.getQuakemlProducts(contents);
  924.         } else {
  925.             Quakeml quakeml = this.converter.parseFile(file);
  926.             return this.getQuakemlProducts(quakeml);
  927.         }
  928.     }

  930.     /**
  931.      * @return XML contents
  932.      */
  933.     protected Content getContentsXML() {
  934.         StringBuffer buf = new StringBuffer();
  935.         buf.append("<?xml version=\"1.0\"?>\n");
  936.         buf.append("<contents xmlns=\"http://earthquake.usgs.gov/earthquakes/event/contents\">\n");
  937.         buf.append("<file title=\"Earthquake XML (Quakeml)\">\n");
  938.         buf.append("<format type=\"xml\" href=\"").append(QUAKEML_CONTENT_PATH)
  939.                 .append("\"/>\n");
  940.         buf.append("</file>\n");
  941.         buf.append("</contents>\n");

  943.         ByteContent content = new ByteContent(buf.toString().getBytes());
  944.         content.setContentType("application/xml");

  946.         return content;
  947.     }

  949.     /** @return boolean sendOriginWhenPhasesExist */
  950.     public boolean isSendOriginWhenPhasesExist() {
  951.         return sendOriginWhenPhasesExist;
  952.     }

  954.     /** @param sendOriginWhenPhasesExist boolean to set */
  955.     public void setSendOriginWhenPhasesExist(boolean sendOriginWhenPhasesExist) {
  956.         this.sendOriginWhenPhasesExist = sendOriginWhenPhasesExist;
  957.     }

  959.     /** @param sendMechanismWhenPhasesExist boolean to set */
  960.     public void setSendMechanismWhenPhasesExist(
  961.             boolean sendMechanismWhenPhasesExist) {
  962.         this.sendMechanismWhenPhasesExist = sendMechanismWhenPhasesExist;
  963.     }

  965.     /** @return sendMechanismWhenPhasesExist boolean */
  966.     public boolean isSendMechanismWhenPhasesExist() {
  967.         return sendMechanismWhenPhasesExist;
  968.     }

  970.     /** @param padForBase64Bug to set */
  971.     public void setPadForBase64Bug(boolean padForBase64Bug) {
  972.         this.padForBase64Bug = padForBase64Bug;
  973.     }

  975.     /** @return padForBase64Bug */
  976.     public boolean isPadForBase64Bug() {
  977.         return padForBase64Bug;
  978.     }

  980.     /**
  981.      * Utility function that converts quakeml to a string
  982.      *
  983.      * @param message
  984.      *                      The quakeml to be converted
  985.      *
  986.      * @return raw string
  987.      * @throws Exception if quakeml doesn't validate
  988.      */
  989.     private String convertQuakemlToString(Quakeml message) throws Exception{
  990.         return fixRawQuakeml(formatConverter.getString(message,validate));
  991.     }

  993.     /**
  994.      * Fixes base 64 bug: https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8222187
  995.      *
  996.      * @param rawMessage
  997.      *                          the message to edit
  998.      * @return the fixed string
  999.      */
  1000.     public String fixRawQuakeml(String rawMessage) {
  1001.         if (padForBase64Bug && rawMessage.getBytes().length % 4096 == 1) {
  1002.             rawMessage += ' ';
  1003.         }
  1004.         return rawMessage;
  1005.     }

  1007.     /**
  1008.      * Convert quakeml files to products.
  1009.      *
  1010.      * @param args
  1011.      *            a list of files to convert from quakeml to products.
  1012.      * @throws Exception if error occurs
  1013.      */
  1014.     public static void main(final String[] args) throws Exception {
  1015.         QuakemlProductCreator creator = new QuakemlProductCreator();
  1016.         creator.setSendOriginWhenPhasesExist(true);
  1017.         creator.setSendMechanismWhenPhasesExist(true);

  1019.         if (args.length == 0) {
  1020.             System.err
  1021.                     .println("Quakeml to product converter utility.  "
  1022.                             + "For visually inspecting products that would be created from quakeml files.");
  1023.             System.err.println();
  1024.             System.err.println("Usage: QuakemlProductCreator FILE [ FILE ]");
  1025.             System.err
  1026.                     .println("\tFILE - a quakeml file to convert to products, repeat as needed");
  1027.             System.exit(1);
  1028.         }

  1030.         for (String arg : args) {
  1031.             File quakeml = new File(arg);
  1032.             System.err.println("reading quakeml from "
  1033.                     + quakeml.getCanonicalPath());

  1035.             Iterator<Product> iter = creator.getProducts(quakeml).iterator();
  1036.             while (iter.hasNext()) {
  1037.                 Product next = iter.next();
  1038.                 new ObjectProductSource(next).streamTo(new XmlProductHandler(
  1039.                         new StreamUtils.UnclosableOutputStream(System.err)));
  1040.             }

  1042.             System.err.println();
  1043.         }
  1044.     }

  1046. }
Created with JaCoCo 0.8.8.202204050719