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.getName());

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

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

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

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

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

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

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

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

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

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

  154.     // eventId
  155.     eventSource = gridXML.get(GridXMLHandler.EVENT_NETWORK_XML);
  156.     eventSourceCode = gridXML.get(GridXMLHandler.EVENT_ID_XML);
  157.     eventId = eventSource + eventSourceCode;

  159.     if (valueIsEmpty(getEventId(), eventId)) {
  160.       setEventId(eventSource, eventSourceCode);
  161.     }

  163.     // less preferred eventId (if not already set)
  164.     eventSource = gridXML.get(GridXMLHandler.SHAKEMAPGRID_ORIGINATOR_XML);
  165.     eventSourceCode = gridXML.get(GridXMLHandler.SHAKEMAPGRID_ID_XML);
  166.     eventId = eventSource + eventSourceCode;

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

  172.     // ShakeMap Metadata
  173.     processTimestamp = gridXML.get(GridXMLHandler.SHAKEMAPGRID_TIMESTAMP_XML);
  174.     if (valueIsEmpty(XmlUtils.formatDate(getProcessTimestamp()), processTimestamp)) {
  175.       setProcessTimestamp(XmlUtils.getDate(processTimestamp));
  176.     }

  178.     version = gridXML.get(GridXMLHandler.SHAKEMAPGRID_VERSION_XML);
  179.     if (valueIsEmpty(getVersion(), version)) {
  180.       setVersion(version);
  181.     }

  183.     eventType = gridXML.get(GridXMLHandler.SHAKEMAPGRID_EVENT_TYPE_XML);
  184.     if (valueIsEmpty(getEventType(), eventType)) {
  185.       setEventType(eventType);
  186.     }

  188.     mapStatus = gridXML.get(GridXMLHandler.SHAKEMAPGRID_EVENT_STATUS_XML);
  189.     if (valueIsEmpty(getMapStatus(), mapStatus)) {
  190.       setMapStatus(mapStatus);
  191.     }

  193.     // ShakeMap Grid
  194.     minimumLongitude = gridXML.get(GridXMLHandler.GRIDSPEC_LONMIN_XML);
  195.     if (valueIsEmpty(getString(getMinimumLongitude()), minimumLongitude)) {
  196.       setMinimumLongitude(getBigDecimal(minimumLongitude));
  197.     }

  199.     maximumLongitude = gridXML.get(GridXMLHandler.GRIDSPEC_LONMAX_XML);
  200.     if (valueIsEmpty(getString(getMaximumLongitude()), maximumLongitude)) {
  201.       setMaximumLongitude(getBigDecimal(maximumLongitude));
  202.     }

  204.     minimumLatitude = gridXML.get(GridXMLHandler.GRIDSPEC_LATMIN_XML);
  205.     if (valueIsEmpty(getString(getMinimumLatitude()), minimumLatitude)) {
  206.       setMinimumLatitude(getBigDecimal(minimumLatitude));
  207.     }

  209.     maximumLatitude = gridXML.get(GridXMLHandler.GRIDSPEC_LATMAX_XML);
  210.     if (valueIsEmpty(getString(getMaximumLatitude()), maximumLatitude)) {
  211.       setMaximumLatitude(getBigDecimal(maximumLatitude));
  212.     }

  214.     // Event
  215.     latitude = gridXML.get(GridXMLHandler.EVENT_LATITUDE_XML);
  216.     if (valueIsEmpty(getString(getLatitude()), latitude)) {
  217.       setLatitude(getBigDecimal(latitude));
  218.     }

  220.     longitude = gridXML.get(GridXMLHandler.EVENT_LONGITUDE_XML);
  221.     if (valueIsEmpty(getString(getLongitude()), longitude)) {
  222.       setLongitude(getBigDecimal(longitude));
  223.     }

  225.     magnitude = gridXML.get(GridXMLHandler.EVENT_MAGNITUDE_XML);
  226.     if (valueIsEmpty(getString(getMagnitude()), magnitude)) {
  227.       setMagnitude(getBigDecimal(magnitude));
  228.     }

  230.     depth = gridXML.get(GridXMLHandler.EVENT_DEPTH_XML);
  231.     if (valueIsEmpty(getString(getDepth()), depth)) {
  232.       setDepth(getBigDecimal(depth));
  233.     }

  235.     eventTime = gridXML.get(GridXMLHandler.EVENT_TIMESTAMP_XML).replace("GMT", "Z").replace("UTC", "Z");
  236.     if (valueIsEmpty(XmlUtils.formatDate(getEventTime()), eventTime)) {
  237.       setEventTime(XmlUtils.getDate(eventTime));
  238.     }

  240.     eventDescription = gridXML.get(GridXMLHandler.EVENT_DESCRIPTION_XML);
  241.     if (valueIsEmpty(getEventDescription(), eventDescription)) {
  242.       setEventDescription(eventDescription);
  243.     }

  245.   };

  247.   /**
  248.    * @param infoXML shakemap properties hash keyed by info.xml attribute name
  249.    */
  250.   public void setInfoXMLProperties(HashMap<String, String> infoXML) {
  251.     // read maxmmi from info.xml
  252.     if (infoXML.containsKey(MAXIMUM_MMI_INFO_KEY)) {
  253.       this.getProperties().put(MAXIMUM_MMI_PROPERTY, infoXML.get(MAXIMUM_MMI_INFO_KEY));
  254.     }
  255.   };

  257.   /**
  258.    * @param productValue the value from the PDL object
  259.    * @param xmlValue     the value from the XML document
  260.    * @return if the shakemap property is already set
  261.    */
  262.   public boolean valueIsEmpty(String productValue, String xmlValue) {
  263.     // nothing to be set
  264.     if (xmlValue == null) {
  265.       return false;
  266.     }
  267.     // no value has been set
  268.     if (productValue == null) {
  269.       return true;
  270.     }
  271.     // value is set and values are different, log warning
  272.     if (!productValue.equals(xmlValue)) {
  273.       LOGGER.log(Level.FINE, "The ShakeMap property value: \"" + xmlValue + "\""
  274.           + " does not match the product value: \"" + productValue + "\".");
  275.     }
  276.     return false;
  277.   }

  279.   /**
  280.    * @param mapStatus the map status to set
  281.    */
  282.   public void setMapStatus(String mapStatus) {
  283.     getProperties().put(MAP_STATUS_PROPERTY, mapStatus);
  284.   }

  286.   /**
  287.    * @return the status of this map
  288.    */
  289.   public String getMapStatus() {
  290.     return getProperties().get(MAP_STATUS_PROPERTY);
  291.   }

  293.   /**
  294.    * @param eventType the event type to set
  295.    */
  296.   public void setEventType(String eventType) {
  297.     getProperties().put(EVENT_TYPE_PROPERTY, eventType);
  298.   }

  300.   /**
  301.    * @return the event type of this product as defined in ShakeMap
  302.    */
  303.   public String getEventType() {
  304.     return getProperties().get(EVENT_TYPE_PROPERTY);
  305.   }

  307.   /**
  308.    * @param processTimestamp the process timestamp to set
  309.    */
  310.   public void setProcessTimestamp(Date processTimestamp) {
  311.     getProperties().put(PROCESS_TIMESTAMP_PROPERTY, XmlUtils.formatDate(processTimestamp));
  312.   }

  314.   /**
  315.    * @return the process timestamp of this ShakeMap
  316.    */
  317.   public Date getProcessTimestamp() {
  318.     return XmlUtils.getDate(getProperties().get(PROCESS_TIMESTAMP_PROPERTY));
  319.   }

  321.   /**
  322.    * @return the event description text for this ShakeMap
  323.    */
  324.   public String getEventDescription() {
  325.     return getProperties().get(EVENT_DESCRIPTION_PROPERTY);
  326.   }

  328.   /**
  329.    * @param eventDescription the event description to set
  330.    */
  331.   public void setEventDescription(String eventDescription) {
  332.     getProperties().put(EVENT_DESCRIPTION_PROPERTY, eventDescription);
  333.   }

  335.   /**
  336.    * @return the minimum longitude boundary of this ShakeMap
  337.    */
  338.   public BigDecimal getMinimumLongitude() {
  339.     return getBigDecimal(getProperties().get(MINIMUM_LONGITUDE_PROPERTY));
  340.   }

  342.   /**
  343.    * @param minimumLongitude the minimum longitude to set
  344.    */
  345.   public void setMinimumLongitude(BigDecimal minimumLongitude) {
  346.     getProperties().put(MINIMUM_LONGITUDE_PROPERTY, minimumLongitude.toPlainString());
  347.   }

  349.   /**
  350.    * @return the maximum longitude boundary of this ShakeMap
  351.    */
  352.   public BigDecimal getMaximumLongitude() {
  353.     return getBigDecimal(getProperties().get(MAXIMUM_LONGITUDE_PROPERTY));
  354.   }

  356.   /**
  357.    * @param maximumLongitude the maximum longitude to set
  358.    */
  359.   public void setMaximumLongitude(BigDecimal maximumLongitude) {
  360.     getProperties().put(MAXIMUM_LONGITUDE_PROPERTY, maximumLongitude.toPlainString());
  361.   }

  363.   /**
  364.    * @return the minimum latitude boundary of this ShakeMap
  365.    */
  366.   public BigDecimal getMinimumLatitude() {
  367.     return getBigDecimal(getProperties().get(MINIMUM_LATITUDE_PROPERTY));
  368.   }

  370.   /**
  371.    * @param minimumLatitude the minimum latitude to set
  372.    */
  373.   public void setMinimumLatitude(BigDecimal minimumLatitude) {
  374.     getProperties().put(MINIMUM_LATITUDE_PROPERTY, minimumLatitude.toPlainString());
  375.   }

  377.   /**
  378.    * @return the maximum latitude boundary of this ShakeMap
  379.    */
  380.   public BigDecimal getMaximumLatitude() {
  381.     return getBigDecimal(getProperties().get(MAXIMUM_LATITUDE_PROPERTY));
  382.   }

  384.   /**
  385.    * @param maximumLatitude the maximum latitude to set
  386.    */
  387.   public void setMaximumLatitude(BigDecimal maximumLatitude) {
  388.     getProperties().put(MAXIMUM_LATITUDE_PROPERTY, maximumLatitude.toPlainString());
  389.   }

  391.   /**
  392.    * Returns String value as BigDecimal
  393.    *
  394.    * @param value to return as BigDecimal
  395.    * @return a BigDecimal
  396.    */
  397.   protected BigDecimal getBigDecimal(String value) {
  398.     if (value == null) {
  399.       return null;
  400.     }
  401.     return new BigDecimal(value);
  402.   }

  404.   /**
  405.    * Returns BigDecimal value as String
  406.    *
  407.    * @param value a BigDecimal
  408.    * @return a string
  409.    */
  410.   protected String getString(BigDecimal value) {
  411.     if (value == null) {
  412.       return null;
  413.     }
  414.     return value.toString();
  415.   }

  417. }
Created with JaCoCo 0.8.8.202204050719