ShakeMap.java

  1. package gov.usgs.earthquake.shakemap;

  3. import gov.usgs.earthquake.product.Content;
  4. import gov.usgs.earthquake.product.Product;
  5. import gov.usgs.util.StreamUtils;
  6. import gov.usgs.util.XmlUtils;

  8. import java.io.InputStream;
  9. import java.math.BigDecimal;
  10. import java.util.Date;
  11. import java.util.HashMap;
  12. import java.util.logging.Level;
  13. import java.util.logging.Logger;

  15. /**
  16.  * ShakeMap object to add additional Product properties based on contents.
  17.  *
  18.  * This subclass of Product provides access to additional ShakeMap-specific
  19.  * attributes and loads these attributes, as well as additional Product
  20.  * attributes from ShakeMap source XML files.
  21.  */
  22. public class ShakeMap extends Product {

  24.     /** Property for event description */
  25.     public static final String EVENT_DESCRIPTION_PROPERTY = "event-description";
  26.     /** Property for event type */
  27.     public static final String EVENT_TYPE_PROPERTY = "event-type";
  28.     /** Property for map status */
  29.     public static final String MAP_STATUS_PROPERTY = "map-status";
  30.     /** Property for max latitude */
  31.     public static final String MAXIMUM_LATITUDE_PROPERTY = "maximum-latitude";
  32.     /** Property for max longitude */
  33.     public static final String MAXIMUM_LONGITUDE_PROPERTY = "maximum-longitude";
  34.     /** Property for min latitude */
  35.     public static final String MINIMUM_LATITUDE_PROPERTY = "minimum-latitude";
  36.     /** Property for min longitude */
  37.     public static final String MINIMUM_LONGITUDE_PROPERTY = "minimum-longitude";
  38.     /** Property for process timestamp */
  39.     public static final String PROCESS_TIMESTAMP_PROPERTY = "process-timestamp";

  41.     private static final Logger LOGGER = Logger.getLogger(ShakeMap.class
  42.             .getName());

  44.     /** References to file content in the Product */
  45.     public static final String GRID_XML_ATTACHMENT = "download/grid.xml";
  46.     /** References to file content in the Product */
  47.     public static final String INFO_XML_ATTACHMENT = "download/info.xml";

  49.     // The files below have been decided to be unsupported at this time to
  50.     // encourage
  51.     // adoption of grid.xml by all networks.
  52.     // public static final String GRID_XYZ_ATTACHMENT = "download/grid.xyz.zip";
  53.     // public static final String STATIONLIST_XML_ATTACHMENT =
  54.     // "download/stationlist.xml";
  55.     /** Invisible attachment */
  56.     public static final String INVISIBLE_ATTACHMENT = ".invisible";

  58.     /** A suffix added to all event codes for scenarios */
  59.     public static final String SCENARIO_ID_SUFFIX = "_se";

  61.     // Map types
  62.     /** Map type - actual */
  63.     public static final String ACTUAL = "ACTUAL";
  64.     /** Map type - scenario */
  65.     public static final String SCENARIO = "SCENARIO";
  66.     /** Map type - test */
  67.     public static final String TEST = "TEST";

  69.     /** key in info.xml for maximum mmi */
  70.     public static final String MAXIMUM_MMI_INFO_KEY = "mi_max";
  71.     /** Property for max MMI */
  72.     public static final String MAXIMUM_MMI_PROPERTY = "maxmmi";

  74.     /**
  75.      * @param product
  76.      *            the base product to be converted to a ShakeMap product
  77.      */
  78.     public ShakeMap(final Product product) {
  79.         super(product);

  81.         // prefer grid attachment
  82.         Content gridxml = product.getContents().get(GRID_XML_ATTACHMENT);
  83.         if (gridxml != null) {
  84.             InputStream gridXmlIn = null;
  85.             try {
  86.                 // parse grid.xml
  87.                 GridXMLHandler gridxmlHandler = new GridXMLHandler();
  88.                 gridXmlIn = gridxml.getInputStream();
  89.                 HashMap<String, String> grid = gridxmlHandler.parse(gridXmlIn);
  90.                 // parse through hash maps to set shakemap properties
  91.                 this.setGridXMLProperties(grid);
  92.             } catch (Exception e) {
  93.                 // error parsing grid
  94.                 LOGGER.log(Level.WARNING, "error parsing grid.xml", e);
  95.             } finally {
  96.                 StreamUtils.closeStream(gridXmlIn);
  97.             }
  98.         }

  100.         Content infoxml = product.getContents().get(INFO_XML_ATTACHMENT);
  101.         if (infoxml != null) {
  102.             InputStream infoXmlIn = null;
  103.             try {
  104.                 // parse info.xml
  105.                 InfoXMLHandler infoxmlHandler = new InfoXMLHandler();
  106.                 infoXmlIn = infoxml.getInputStream();
  107.                 HashMap<String, String> info = infoxmlHandler.parse(infoXmlIn);
  108.                 // parse through hash maps to set shakemap properties
  109.                 this.setInfoXMLProperties(info);
  110.             } catch (Exception e) {
  111.                 LOGGER.log(Level.WARNING, "error parsing info.xml", e);
  112.             } finally {
  113.                 StreamUtils.closeStream(infoXmlIn);
  114.             }
  115.         }


  118.         /*
  119.          * else { // At this time we are disabling all non-grid.xml
  120.          * functionality // as all shakemaps sent in should have a grid.xml
  121.          * file.
  122.          *
  123.          * //otherwise try gridXYZ (has most) + stationlist (has depth) source =
  124.          * product.getContents().get(GRID_XYZ_ATTACHMENT); if (source != null) {
  125.          * GridXYZHandler handler = new GridXYZHandler(this); try {
  126.          * handler.parse(source.getInputStream()); } catch (Exception e) {
  127.          * //error parsing gridxyz throw new IllegalArgumentException(e); } }
  128.          *
  129.          * source = product.getContents().get(STATIONLIST_XML_ATTACHMENT); if
  130.          * (source != null) { StationlistXMLHandler handler = new
  131.          * StationlistXMLHandler(this); try {
  132.          * handler.parse(source.getInputStream()); } catch (Exception e) {
  133.          * //error parsing stationlist throw new IllegalArgumentException(e); }
  134.          * } }
  135.          */
  136.     }

  138.     /**
  139.      * @param gridXML
  140.      *            shakemap properties hash keyed by grid.xml attribute name
  141.      */
  142.     public void setGridXMLProperties (HashMap<String, String> gridXML) {
  143.         String depth;
  144.         String eventDescription;
  145.         String eventId;
  146.         String eventSource;
  147.         String eventSourceCode;
  148.         String eventTime;
  149.         String eventType;
  150.         String latitude;
  151.         String longitude;
  152.         String magnitude;
  153.         String mapStatus;
  154.         String maximumLatitude;
  155.         String maximumLongitude;
  156.         String minimumLatitude;
  157.         String minimumLongitude;
  158.         String processTimestamp;
  159.         String version;


  162.         // eventId
  163.         eventSource = gridXML.get(GridXMLHandler.EVENT_NETWORK_XML);
  164.         eventSourceCode = gridXML.get(GridXMLHandler.EVENT_ID_XML);
  165.         eventId = eventSource + eventSourceCode;

  167.         if (valueIsEmpty(getEventId(), eventId))  {
  168.             setEventId(eventSource, eventSourceCode);
  169.         }

  171.         // less preferred eventId (if not already set)
  172.         eventSource = gridXML.get(GridXMLHandler.SHAKEMAPGRID_ORIGINATOR_XML);
  173.         eventSourceCode = gridXML.get(GridXMLHandler.SHAKEMAPGRID_ID_XML);
  174.         eventId = eventSource + eventSourceCode;

  176.         if (valueIsEmpty(getEventId(), eventId))  {
  177.             setEventId(eventSource, eventSourceCode);
  178.         }


  181.         // ShakeMap Metadata
  182.         processTimestamp = gridXML.get(GridXMLHandler.SHAKEMAPGRID_TIMESTAMP_XML);
  183.         if (valueIsEmpty(XmlUtils.formatDate(getProcessTimestamp()), processTimestamp)) {
  184.             setProcessTimestamp(XmlUtils.getDate(processTimestamp));
  185.         }

  187.         version = gridXML.get(GridXMLHandler.SHAKEMAPGRID_VERSION_XML);
  188.         if (valueIsEmpty(getVersion(), version)) {
  189.             setVersion(version);
  190.         }

  192.         eventType = gridXML.get(GridXMLHandler.SHAKEMAPGRID_EVENT_TYPE_XML);
  193.         if (valueIsEmpty(getEventType(), eventType)) {
  194.             setEventType(eventType);
  195.         }

  197.         mapStatus = gridXML.get(GridXMLHandler.SHAKEMAPGRID_EVENT_STATUS_XML);
  198.         if (valueIsEmpty(getMapStatus(), mapStatus)) {
  199.             setMapStatus(mapStatus);
  200.         }


  203.         // ShakeMap Grid
  204.         minimumLongitude = gridXML.get(GridXMLHandler.GRIDSPEC_LONMIN_XML);
  205.         if (valueIsEmpty(getString(getMinimumLongitude()), minimumLongitude)) {
  206.             setMinimumLongitude(getBigDecimal(minimumLongitude));
  207.         }

  209.         maximumLongitude = gridXML.get(GridXMLHandler.GRIDSPEC_LONMAX_XML);
  210.         if (valueIsEmpty(getString(getMaximumLongitude()), maximumLongitude)) {
  211.             setMaximumLongitude(getBigDecimal(maximumLongitude));
  212.         }

  214.         minimumLatitude = gridXML.get(GridXMLHandler.GRIDSPEC_LATMIN_XML);
  215.         if (valueIsEmpty(getString(getMinimumLatitude()), minimumLatitude)) {
  216.             setMinimumLatitude(getBigDecimal(minimumLatitude));
  217.         }

  219.         maximumLatitude = gridXML.get(GridXMLHandler.GRIDSPEC_LATMAX_XML);
  220.         if (valueIsEmpty(getString(getMaximumLatitude()), maximumLatitude)) {
  221.             setMaximumLatitude(getBigDecimal(maximumLatitude));
  222.         }


  225.         // Event
  226.         latitude = gridXML.get(GridXMLHandler.EVENT_LATITUDE_XML);
  227.         if (valueIsEmpty(getString(getLatitude()), latitude)) {
  228.             setLatitude(getBigDecimal(latitude));
  229.         }

  231.         longitude = gridXML.get(GridXMLHandler.EVENT_LONGITUDE_XML);
  232.         if (valueIsEmpty(getString(getLongitude()), longitude)) {
  233.             setLongitude(getBigDecimal(longitude));
  234.         }

  236.         magnitude = gridXML.get(GridXMLHandler.EVENT_MAGNITUDE_XML);
  237.         if (valueIsEmpty(getString(getMagnitude()), magnitude)) {
  238.             setMagnitude(getBigDecimal(magnitude));
  239.         }

  241.         depth = gridXML.get(GridXMLHandler.EVENT_DEPTH_XML);
  242.         if (valueIsEmpty(getString(getDepth()), depth)) {
  243.             setDepth(getBigDecimal(depth));
  244.         }

  246.         eventTime = gridXML.get(GridXMLHandler.EVENT_TIMESTAMP_XML)
  247.                 .replace("GMT", "Z")
  248.                 .replace("UTC","Z");
  249.         if (valueIsEmpty(XmlUtils.formatDate(getEventTime()), eventTime)) {
  250.             setEventTime(XmlUtils.getDate(eventTime));
  251.         }

  253.         eventDescription = gridXML.get(GridXMLHandler.EVENT_DESCRIPTION_XML);
  254.         if (valueIsEmpty(getEventDescription(), eventDescription)) {
  255.             setEventDescription(eventDescription);
  256.         }

  258.     };

  260.     /**
  261.      * @param infoXML
  262.      *            shakemap properties hash keyed by info.xml attribute name
  263.      */
  264.     public void setInfoXMLProperties (HashMap<String, String> infoXML) {
  265.         // read maxmmi from info.xml
  266.         if (infoXML.containsKey(MAXIMUM_MMI_INFO_KEY)) {
  267.             this.getProperties().put(MAXIMUM_MMI_PROPERTY,
  268.                     infoXML.get(MAXIMUM_MMI_INFO_KEY));
  269.         }
  270.     };

  272.     /**
  273.      * @param productValue
  274.      *            the value from the PDL object
  275.      * @param xmlValue
  276.      *            the value from the XML document
  277.      * @return if the shakemap property is already set
  278.      */
  279.     public boolean valueIsEmpty (String productValue, String xmlValue) {
  280.         // nothing to be set
  281.         if (xmlValue == null) {
  282.             return false;
  283.         }
  284.         // no value has been set
  285.         if (productValue == null) {
  286.             return true;
  287.         }
  288.         // value is set and values are different, log warning
  289.         if (!productValue.equals(xmlValue)) {
  290.             LOGGER.log(Level.FINE,
  291.                     "The ShakeMap property value: \"" + xmlValue + "\"" +
  292.                     " does not match the product value: \"" + productValue + "\".");
  293.         }
  294.         return false;
  295.     }

  297.     /**
  298.      * @param mapStatus
  299.      *            the map status to set
  300.      */
  301.     public void setMapStatus(String mapStatus) {
  302.         getProperties().put(MAP_STATUS_PROPERTY, mapStatus);
  303.     }

  305.     /**
  306.      * @return the status of this map
  307.      */
  308.     public String getMapStatus() {
  309.         return getProperties().get(MAP_STATUS_PROPERTY);
  310.     }

  312.     /**
  313.      * @param eventType
  314.      *            the event type to set
  315.      */
  316.     public void setEventType(String eventType) {
  317.         getProperties().put(EVENT_TYPE_PROPERTY, eventType);
  318.     }

  320.     /**
  321.      * @return the event type of this product as defined in ShakeMap
  322.      */
  323.     public String getEventType() {
  324.         return getProperties().get(EVENT_TYPE_PROPERTY);
  325.     }

  327.     /**
  328.      * @param processTimestamp
  329.      *            the process timestamp to set
  330.      */
  331.     public void setProcessTimestamp(Date processTimestamp) {
  332.         getProperties().put(PROCESS_TIMESTAMP_PROPERTY,
  333.                 XmlUtils.formatDate(processTimestamp));
  334.     }

  336.     /**
  337.      * @return the process timestamp of this ShakeMap
  338.      */
  339.     public Date getProcessTimestamp() {
  340.         return XmlUtils
  341.                 .getDate(getProperties().get(PROCESS_TIMESTAMP_PROPERTY));
  342.     }

  344.     /**
  345.      * @return the event description text for this ShakeMap
  346.      */
  347.     public String getEventDescription() {
  348.         return getProperties().get(EVENT_DESCRIPTION_PROPERTY);
  349.     }

  351.     /**
  352.      * @param eventDescription
  353.      *            the event description to set
  354.      */
  355.     public void setEventDescription(String eventDescription) {
  356.         getProperties().put(EVENT_DESCRIPTION_PROPERTY, eventDescription);
  357.     }

  359.     /**
  360.      * @return the minimum longitude boundary of this ShakeMap
  361.      */
  362.     public BigDecimal getMinimumLongitude() {
  363.         return getBigDecimal(getProperties().get(MINIMUM_LONGITUDE_PROPERTY));
  364.     }

  366.     /**
  367.      * @param minimumLongitude
  368.      *            the minimum longitude to set
  369.      */
  370.     public void setMinimumLongitude(BigDecimal minimumLongitude) {
  371.         getProperties().put(MINIMUM_LONGITUDE_PROPERTY,
  372.                 minimumLongitude.toPlainString());
  373.     }

  375.     /**
  376.      * @return the maximum longitude boundary of this ShakeMap
  377.      */
  378.     public BigDecimal getMaximumLongitude() {
  379.         return getBigDecimal(getProperties().get(MAXIMUM_LONGITUDE_PROPERTY));
  380.     }

  382.     /**
  383.      * @param maximumLongitude
  384.      *            the maximum longitude to set
  385.      */
  386.     public void setMaximumLongitude(BigDecimal maximumLongitude) {
  387.         getProperties().put(MAXIMUM_LONGITUDE_PROPERTY,
  388.                 maximumLongitude.toPlainString());
  389.     }

  391.     /**
  392.      * @return the minimum latitude boundary of this ShakeMap
  393.      */
  394.     public BigDecimal getMinimumLatitude() {
  395.         return getBigDecimal(getProperties().get(MINIMUM_LATITUDE_PROPERTY));
  396.     }

  398.     /**
  399.      * @param minimumLatitude
  400.      *            the minimum latitude to set
  401.      */
  402.     public void setMinimumLatitude(BigDecimal minimumLatitude) {
  403.         getProperties().put(MINIMUM_LATITUDE_PROPERTY,
  404.                 minimumLatitude.toPlainString());
  405.     }

  407.     /**
  408.      * @return the maximum latitude boundary of this ShakeMap
  409.      */
  410.     public BigDecimal getMaximumLatitude() {
  411.         return getBigDecimal(getProperties().get(MAXIMUM_LATITUDE_PROPERTY));
  412.     }

  414.     /**
  415.      * @param maximumLatitude
  416.      *            the maximum latitude to set
  417.      */
  418.     public void setMaximumLatitude(BigDecimal maximumLatitude) {
  419.         getProperties().put(MAXIMUM_LATITUDE_PROPERTY,
  420.                 maximumLatitude.toPlainString());
  421.     }

  423.     /**
  424.      * Returns String value as BigDecimal
  425.      * @param value to return as BigDecimal
  426.      * @return a BigDecimal
  427.      */
  428.     protected BigDecimal getBigDecimal (String value) {
  429.         if (value == null) {
  430.             return null;
  431.         }
  432.         return new BigDecimal(value);
  433.     }

  435.     /**
  436.      * Returns BigDecimal value as String
  437.      * @param value a BigDecimal
  438.      * @return a string
  439.      */
  440.     protected String getString (BigDecimal value) {
  441.         if (value == null) {
  442.             return null;
  443.         }
  444.         return value.toString();
  445.     }

  447. }
Created with JaCoCo 0.8.8.202204050719