root/cdat/trunk/las/addXML/addXML.java

package gov.noaa.pmel.tmap.addxml;

/**
 * @todo add an institution tag for dods servers.  Bugzilla #272
 */

/**
 * @todo If a THREDDS <dataset> element has xlink documentation it's being lost.
 * Need to figure out how to move this information up into the LAS category that
 * contains the data set.
 */

/**
 * @todo Ever since rethinking the design (a lofty word for the process of
 * deciding what this code would look like) the main code
 * is pretty messy with the logic to combine netCDF data sets into one.
 * Creating a "full" <las_data> docuement and then extracting the pieces
 * seems silly.
 */

/**
 * @todo There seem to be a number of undue kludges in the time handling.
 * I think this should be cleaner, but then again I think most of the time
 * axis information the kludges are supporting should just get rejected out
 * of hand.  We can't do everything.  (Some cover an FDS bug that seems to
 * split the time units into things like:
 * units="days"
 * time_origin="1990-MAY-19 00:00")
 */

/**
 * @todo  Add a flag that will cause a <category> element to be created
 * for each LAS <dataset> created from a -n source so that netCDF and THREDDS
 * addXML output can be used together without modification.
 */

// Standard Java stuff.
import java.io.*;
import java.io.FileWriter;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.Iterator;

// www.jdom.org
import org.jdom.*;
import org.jdom.input.*;
import org.jdom.output.*;
//joda-time.sourceforge.net/
import org.joda.time.*;
import org.joda.time.format.*;
import com.martiansoftware.jsap.*;
// Unidata
import thredds.catalog.*;
import ucar.nc2.Attribute;
import ucar.nc2.dataset.*;
import ucar.nc2.dataset.grid.*;
import ucar.nc2.dods.*;
import ucar.nc2.units.*;
import ucar.unidata.geoloc.*;
import ucar.unidata.geoloc.projection.*;

/**
 * <p>Title: addXML</p>
 *
 * <p>Description: Reads local or OPeNDAP netCDF files and generates LAS XML
 * configuration information.</p>
 *
 * <p>Copyright: Copyright (c) 2005</p>
 *
 * <p>Company: NOAA/PMEL/TMAP</p>
 *
 * @author RHS
 * @version 1.0
 */

import java.net.Authenticator;
import java.net.PasswordAuthentication;
class TheAuthenticator extends Authenticator {
    private String username;
    private String password;
    public TheAuthenticator(String user, String pwd) {
        username = user;
        password = pwd;
    }
    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication(username, password.toCharArray());
    }
}

public class addXML {

  private static boolean verbose;
  private static int fileCount;
  private static HashMap forceAxes = new HashMap();
  private static String title;
  private static String version_string = "1.0.0.0";
  private static String global_title_attribute;
  private static boolean category;
  private static boolean use_suffix = false;

  public addXML() {
    try {
      jbInit();
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
  }

  public static void main(String[] args) {

    forceAxes.put("x", new Boolean(false));
    forceAxes.put("y", new Boolean(false));
    forceAxes.put("z", new Boolean(false));
    forceAxes.put("t", new Boolean(false));

    LAS_JSAP command_parser = new LAS_JSAP();

    JSAPResult command_parameters = command_parser.parse(args);

    if (!command_parameters.success()) {
      command_parser.errorout(command_parameters);
    }

    String[] data = command_parameters.getStringArray("in_netcdf");
    String[] thredds = command_parameters.getStringArray("in_thredds");
    String in_xml = command_parameters.getString("in_xml");
    String basename = command_parameters.getString("basename");
    global_title_attribute = command_parameters.getString(
        "title_attribute");
    boolean oneDataset = command_parameters.getBoolean("dataset");
    title = command_parameters.getString("dataset");
    category = command_parameters.getBoolean("category");
    String username = command_parameters.getString("username");
    String password = command_parameters.getString("password");

    boolean forceArange = command_parameters.getBoolean("arange");
    String aranges;
    if (forceArange) {
      String ax[] = command_parameters.getStringArray("arange");
      for (int a = 0; a < ax.length; a++) {
        if (ax[a].equals("x") || ax[a].equals("y") ||
            ax[a].equals("z") || ax[a].equals("t")) {
          forceAxes.put(ax[a], new Boolean(true));
        }
        else {
          System.err.println("Ignoring axis " + ax[a] +
                             " on the --arange option. Unknown axis.  Must be x,y,z or t.");
        }
      }
    }

    verbose = command_parameters.getBoolean("verbose");
    boolean version = command_parameters.getBoolean("version");

    int total = data.length + thredds.length;
    if (!oneDataset && total > 1) {
      use_suffix = true;
    }
    else if (oneDataset && thredds.length >= 1) {
      use_suffix = true;
    }

    // If there will only be one dataset for all netCDF arguments
    // accumulate them in here.
    DatasetsGridsAxesBean oneDgab = new DatasetsGridsAxesBean();
    DatasetBean oneDb = new DatasetBean();
    // If we are creating categories and we are creating only
    // one dataset for the netCDF data, we'll use this category bean.
    CategoryBean oneCat = new CategoryBean();

    oneDb.setCreator(addXML.class.getName());
    oneDb.setVersion(version_string);
    // Every variable in this dataset object will have it's own fully qualified
    // data URL.  Set the data set URL to null.
    oneDb.setUrl(null);
    if (title != null && title != "") {
      oneDb.setName(title);
      oneCat.setName(title);
    }

    if (version) {
      System.out.println("Version: " + version_string);
    }

    java.net.Authenticator.setDefault(new TheAuthenticator(username, password));

    if (data.length == 0 && thredds.length == 0) {
      System.err.println("");
      System.err.println("You must specify either");
      System.err.println("\ta THREDDS catalog with the -t option or ");
      System.err.println("\ta netCDF data source with the -n option.");
      System.err.println("");
      System.err.print("Usage: addXML.sh ");
      System.err.print(command_parser.getUsage());
      System.err.println("");
      System.err.println("");
      System.err.print(command_parser.getHelp());
      System.exit(1);
    }

    Document inputLasDoc = null;
    if (in_xml != null && in_xml != "") {
      SAXBuilder builder = new SAXBuilder();
      builder.setExpandEntities(false);
      builder.setEntityResolver(new MyEntityResolver());
      try {
        inputLasDoc = builder.build(in_xml);
      }
      // Failed to read input XML.  Go on without it.
      catch (IOException ex) {
        System.out.println(ex.getMessage());
        inputLasDoc = null;
      }
      catch (JDOMException ex) {
        System.out.println(ex.getMessage());
        inputLasDoc = null;
      }
    }

    int numThredds = 0;
    int numNetcdf = 0;

    for (int id = 0; id < data.length; id++) {

      DatasetsGridsAxesBean dgab = null;
      try {
        String url = DODSNetcdfFile.canonicalURL(data[id]);
        NetcdfDataset ncds = ucar.nc2.dataset.NetcdfDataset.openDataset(url);
        dgab = createBeansFromNetcdfDataset(ncds, data[id]);
        ncds.close();
      }
      catch (IOException e) {
        System.out.println("IO error = " + e);
      }
      Vector db = (Vector) dgab.getDatasets();
      if (db != null && db.size() > 0) {

        if (oneDataset) {
          // We're only going to use one data set.  Accumulate all the info
          // into that one data set.
          DatasetBean databean = (DatasetBean) dgab.getDatasets().get(0);

          // Check to see if the name has been set.
          if (oneDb.getName() == null || oneDb.getName() == "") {
            oneDb.setName(databean.getName());
            // If the data set name wasn't set neither was the category
            oneCat.setName(databean.getName());
          }
          // Set the category filter to include this data set.
          FilterBean filter = new FilterBean();
          filter.setAction("apply-dataset");
          filter.setContainstag(databean.getElement());
          oneCat.addFilter(filter);

          Vector variables = (Vector) databean.getVariables();
          // All the URL's must be fixed to not be relative to the data set
          // URL
          Iterator vit = variables.iterator();
          while (vit.hasNext()) {
            VariableBean vb = (VariableBean) vit.next();
            String url = databean.getUrl() + vb.getUrl();
            vb.setUrl(url);
          }
          oneDb.addAllVariables(variables);
          if (oneDb.getElement() == null || oneDb.getElement() == "") {
            oneDb.setElement(databean.getElement());
          }

          Vector grids = dgab.getGrids();
          Vector existingGrids = oneDgab.getGrids();
          if (existingGrids == null) {
            existingGrids = new Vector();
          }
          existingGrids.addAll(grids);
          oneDgab.setGrids(existingGrids);

          Vector axes = dgab.getAxes();
          Vector existingAxes = oneDgab.getAxes();
          if (existingAxes == null) {
            existingAxes = new Vector();
          }
          existingAxes.addAll(axes);
          oneDgab.setAxes(existingAxes);

        }
        else {

          Document lasdoc = createXMLfromDatasetsGridsAxesBean(dgab);

          String ofile = getOutfileName(basename);
          if (inputLasDoc != null) {

            String entityName = getEntityName(ofile);

            // Add an entity reference to the input document if it exists.
            EntityRef entityReference = new EntityRef(entityName, ofile);
            addEntityRef(inputLasDoc, entityName, ofile, entityReference);
          }
          Element lasdata = lasdoc.getRootElement();
          Element datasets = lasdata.getChild("datasets");
          numNetcdf = datasets.getChildren().size();

          if (numNetcdf > 0) {
            outputXML(ofile, datasets, false);
            Element grids = lasdata.getChild("grids");
            outputXML(ofile, grids, true);
            Element axes = lasdata.getChild("axes");
            outputXML(ofile, axes, true);
            if (category) {
              for (Iterator cit = datasets.getChildren().iterator();
                   cit.hasNext(); ) {
                Element datasetElem = (Element) cit.next();
                CategoryBean ds_category = new CategoryBean();
                ds_category.setName(datasetElem.getAttribute("name").getValue());
                FilterBean filter = new FilterBean();
                filter.setAction("apply-dataset");
                filter.setContainstag(datasetElem.getName());
                ds_category.addFilter(filter);
                Element lc = new Element("las_categories");
                lc.addContent(ds_category.toXml());
                outputXML(ofile, lc, true);
              }
            }
          }
        }
      }
    }

    if (oneDataset) {
      // We lumped all the netCDF arguements into one data set.  Now we
      // need to print them to an entity and fix up the --xml file if
      // it exists.

      // Edit the entity string of the existing document and print it out.

      // We've been stuffing in the dataset info into oneDb.  Stuff it into
      // oneDgab and print it.
      Vector dsets = new Vector();
      dsets.add(oneDb);
      oneDgab.setDatasets(dsets);

      Document lasdoc = createXMLfromDatasetsGridsAxesBean(oneDgab);
      String ofile = getOutfileName(basename);
      if (inputLasDoc != null) {

        String entityName = getEntityName(ofile);

        // Add an entity reference to the input document if it exists.
        EntityRef entityReference = new EntityRef(entityName, ofile);
        addEntityRef(inputLasDoc, entityName, ofile, entityReference);
      }
      Element lasdata = lasdoc.getRootElement();
      Element datasets = lasdata.getChild("datasets");
      numNetcdf = datasets.getChildren().size();
      if (numNetcdf > 0) {
        outputXML(ofile, datasets, false);
        Element grids = lasdata.getChild("grids");
        outputXML(ofile, grids, true);
        Element axes = lasdata.getChild("axes");
        outputXML(ofile, axes, true);
        if (category) {
          Element lc = new Element("las_categories");
          lc.addContent(oneCat.toXml());
          outputXML(ofile, lc, true);
        }
      }

    }

    for (int it = 0; it < thredds.length; it++) {
            
      Document lasdoc = LASConfig(thredds[it], "thredds");
      if (lasdoc != null) {
        String ofile = getOutfileName(basename);
        if (inputLasDoc != null) {
          String entityName = getEntityName(ofile);

          // Add an entity reference to the input document if it exists.
          EntityRef entityReference = new EntityRef(entityName, ofile);
          addEntityRef(inputLasDoc, entityName, ofile, entityReference);
        }

        
        Element lasdata = lasdoc.getRootElement();
        Element datasets = lasdata.getChild("datasets");

        numThredds = datasets.getChildren().size();
        if (numThredds > 0) {
          outputXML(ofile, datasets, false);
          Element grids = lasdata.getChild("grids");
          outputXML(ofile, grids, true);
          Element axes = lasdata.getChild("axes");
          outputXML(ofile, axes, true);
          Element categories = lasdata.getChild("las_categories");
          outputXML(ofile, categories, true);
        }
      }
    }

    if (numThredds == 0 && numNetcdf == 0) {
      System.err.println("");
      System.err.println("No grids were found in the input data sets.");
      System.err.println(
          "Check to see if the OPeNDAP servers being referenced are running.");
      System.err.println(
          "Verify that the netCDF files referenced are COARDS or CF compliant.");
      System.err.println("");
    }

    if (inputLasDoc != null) {
      String newXmlFile;
      if (basename.endsWith(".xml")) {
        newXmlFile = basename.substring(0, basename.length() - 4) +
            "_las.xml";
      }
      else {
        newXmlFile = basename + "_las.xml";
      }
      outputXML(newXmlFile, inputLasDoc);
    }
  }

  public static Document LASConfig(String data, String type) {

    // Try to read this as a netCDF file or OPeNDAP netCDF data source.
    if (type.equals("netcdf")) {

    }
    // Try to read this as a THREDDS Dataset Inventory Catalog
    if (type.equals("thredds")) {
      InvCatalogFactory factory = new InvCatalogFactory("default", false);
      InvCatalog catalog = (InvCatalog) factory.readXML(data);
      StringBuffer buff = new StringBuffer();
      boolean show = false;
      if (verbose) {
        show = true;
      }
      if (!catalog.check(buff, show)) {
        System.out.println("Invalid catalog <" + data + ">\n" + buff.toString());
      }
      else {
        return createXMLfromTHREDDSCatalog(catalog);
      }
    }
    // Try to read this as a THREDDS Catalog Generator Configuration file.
    // If this works, then generate the catalog and then generate the LAS
    // configuration.

    // Skip this for now...
    /*
         URL url=null;
         try {
      url = new URL(data);
         }
         catch (MalformedURLException ex) {
      System.out.println(ex.getMessage()+" "+data);
         }
         CatalogGen catGen = new CatalogGen(url);
         StringBuffer log = new StringBuffer();
         if (catGen.isValid(log)) {
      catGen.expand();
      catalog = catGen.getCatalog();
      return createXMLfromTHREDDSCatalog(catalog);
         }
     */

    return null;

  }

  // end of LASConfigFactory
  /**
   * addEntityRef
   *
   * @param inputLasDoc Document
   * @param entityReference EntityRef
   */
  public static void addEntityRef(Document inputLasDoc,
                                  String entityName,
                                  String ofile,
                                  EntityRef entityReference) {

    DocType docType = inputLasDoc.getDocType();
    String entityString = docType.getInternalSubset();
    // Get rid of the file:/// references to the existing entities
    String shortEntityString = "";
    StringTokenizer tokenizer = new StringTokenizer(entityString, "\n");
    while (tokenizer.hasMoreTokens()) {
      String entity = tokenizer.nextToken();
      if (entity.indexOf("file:/") >= 0) {
        entity = entity.substring(0, entity.indexOf("file")) +
            entity.substring(entity.lastIndexOf("/") + 1, entity.length());
        shortEntityString += entity + "\n";
      }
      else {
        shortEntityString += entity + "\n";
      }
    }
    entityString = shortEntityString +
        "  <!ENTITY " + entityName + " SYSTEM \"" + ofile + "\">\n";
    docType.setInternalSubset(entityString);
    Element lasdata = inputLasDoc.getRootElement();
    lasdata.addContent(entityReference);
    lasdata.addContent("\n");

  }

  public static String getEntityName(String ofile) {
    // Get rid of c:\ on PC file names.
    String entityName = ofile;
    if (entityName.startsWith(":\\", 1)) {
      entityName = entityName.substring(3, ofile.length());
      // Get rid of the ".xml" in the name.
    }
    entityName = entityName.substring(0, entityName.length() - 4);
    return entityName;
  }

  /**
   * getOutfileName
   *
   * @param basename String
   * @param b boolean
   * @return String
   */

  public static String getOutfileName(String basename) {

    String ofile;
    String countString = "";

    if (use_suffix) {
      countString = "_000";
      if (fileCount < 10) {
        countString = "_00" + String.valueOf(fileCount);
      }
      else if (fileCount >= 10 && fileCount < 99) {
        countString = "_0" + String.valueOf(fileCount);
      }
      else if (fileCount >= 100 && fileCount < 1000) {
        countString = String.valueOf(fileCount);
      }
      else {
        System.err.println("No more that 999 data sets to process.  Please.");
        System.exit(1);
      }
    }

    if (basename.endsWith(".xml")) {
      ofile = basename.substring(0, basename.length() - 4) +
          countString +
          ".xml";
    }
    else {
      ofile = basename + countString + ".xml";
    }

    fileCount++;
    return ofile;
  }

  /**
   * createXMLfromTHREDDSCatalog
   *
   * @param catalog InvCatalog
   * @return Document
   */
  private static Document createXMLfromTHREDDSCatalog(InvCatalog catalog) {

    CategoryBean top = new CategoryBean();
    String topName = catalog.getName();
    if (topName != null) {
      top.setName(catalog.getName());
    }
    else {
      top.setName(catalog.getUriString());
    }
    Vector DGABeans = new Vector();
    Vector CategoryBeans = new Vector();

    List ThreddsDatasets = catalog.getDatasets();
    Iterator di = ThreddsDatasets.iterator();
    while (di.hasNext()) {
      InvDataset ThreddsDataset = (InvDataset) di.next();
      if (ThreddsDataset.hasNestedDatasets()) {
        CategoryBean cb = processCategories(ThreddsDataset);
        CategoryBeans.add(cb);
      }
    }

    // Discover and process all the THREDDS dataset elements that actually
    // connect to a data source.

    ThreddsDatasets = catalog.getDatasets();
    di = ThreddsDatasets.iterator();

    while (di.hasNext()) {
      InvDataset ThreddsDataset = (InvDataset) di.next();
      DGABeans.addAll(processDatasets(ThreddsDataset));
    }

    top.setCategories(CategoryBeans);
    // create las_categories and datasets elements at this level
    Document doc = new Document();
    Element lasdata = new Element("lasdata");
    Element datasetsElement = new Element("datasets");
    Element gridsElement = new Element("grids");
    Element axesElement = new Element("axes");

    Iterator dgabit = DGABeans.iterator();
    while (dgabit.hasNext()) {
      DatasetsGridsAxesBean dgab_temp = (DatasetsGridsAxesBean) dgabit.next();
      if (dgab_temp.getError() != null) {
        lasdata.addContent(new Comment(dgab_temp.getError()));
      }
      else {
        Vector datasets = dgab_temp.getDatasets();
        Iterator dsit = datasets.iterator();
        while (dsit.hasNext()) {
          DatasetBean db = (DatasetBean) dsit.next();
          Element dsE = db.toXml();
          datasetsElement.addContent(dsE);
        }
        Vector grids = dgab_temp.getGrids();
        Iterator git = grids.iterator();
        while (git.hasNext()) {
          GridBean gb = (GridBean) git.next();
          Element gE = gb.toXml();
          gridsElement.addContent(gE);
        }
        Vector axes = dgab_temp.getAxes();
        Iterator ait = axes.iterator();
        while (ait.hasNext()) {
          AxisBean ab = (AxisBean) ait.next();
          Element aE = ab.toXml();
          axesElement.addContent(aE);
        }
      }
    }

    Element las_categories = new Element("las_categories");
    Element topElement = top.toXml();
    las_categories.addContent(topElement);
    lasdata.addContent(datasetsElement);
    lasdata.addContent(gridsElement);
    lasdata.addContent(axesElement);
    lasdata.addContent(las_categories);
    doc.setRootElement(lasdata);
    return doc;
  }

  /**
   * processDataset
   *
   * @param ThreddsDataset InvDataset
   * @return DatasetBean
   */
  private static Vector processDatasets(InvDataset ThreddsDataset) {
      
    Vector beans = new Vector();
    if (ThreddsDataset.hasAccess()) {
      boolean done = false;
      for (Iterator iter = ThreddsDataset.getAccess().iterator();
           iter.hasNext(); ) {
        InvAccess access = (InvAccess) iter.next();
        if ( (access.getService().getServiceType() == ServiceType.DODS ||
              access.getService().getServiceType() == ServiceType.NETCDF ||
              access.getService().getServiceType() == ServiceType.OPENDAP) &&
            !done) {
          done = true;
          DatasetsGridsAxesBean dgab =
              createBeansFromThreddsDataset(ThreddsDataset, access);
          beans.add(dgab);
        }
      }
    }
    for (Iterator iter = ThreddsDataset.getDatasets().iterator();
         iter.hasNext(); ) {
      beans.addAll(processDatasets( (InvDataset) iter.next()));
    }
    return beans;
  }

  /**
   * createDatasetBeanFromThreddsDataset
   *
   * @param ThreddsDataset InvDataset
   * @return DatasetBean
   */
  private static DatasetsGridsAxesBean createBeansFromThreddsDataset(
      InvDataset ThreddsDataset, InvAccess access) {
    DatasetsGridsAxesBean dgab = new DatasetsGridsAxesBean();
    ThreddsMetadata.GeospatialCoverage gc = ThreddsDataset.
        getGeospatialCoverage();
    ThreddsMetadata.TimeCoverage tc = ThreddsDataset.getTimeCoverage();
    if (gc == null || tc == null) {
      // The geospatial informaiton or time coverage information
      // is not included in the catalog, so we'll have to pull it out
      // of the data source ourselves.
      String url = access.getStandardUrlName();
      try {
        String dods = url.replaceAll("http", "dods");
        NetcdfDataset ncds = ucar.nc2.dataset.NetcdfDataset.openDataset(dods);
        dgab = createBeansFromNetcdfDataset(ncds, url);
        ncds.close();
      }
      catch (IOException e) {
        dgab.setError(e.getMessage());
        System.out.println("IO error = " + e.getMessage());
      }

    }
    else {
      // Create the LAS geo axes from the gc object.
    }
    return dgab;
  }

  /**
   * processCategories
   *
   * @param ThreddsDataset InvDataset
   * @return CategoryBean
   */
  private static CategoryBean processCategories(InvDataset ThreddsDataset) {
    
    CategoryBean cb = new CategoryBean();
    // Make any THREDDS documentation links into LAS contributor links.
    List docs = ThreddsDataset.getDocumentation();
    Vector contribs = new Vector();
    for (Iterator dit = docs.iterator(); dit.hasNext(); ) {
      InvDocumentation doc = (InvDocumentation) dit.next();
      if (doc.hasXlink()) {
        ContributorBean contributor = new ContributorBean();
        contributor.setRole("THREDDS Metadata");
        contributor.setUrl(doc.getXlinkHref());
        contributor.setName(doc.getXlinkTitle());
        contribs.add(contributor);
      }
    }
    cb.setContributors(contribs);

    String name = ThreddsDataset.getName();
    if (name != null) {
      cb.setName(ThreddsDataset.getName());
    }
    else {
      cb.setName("THREDDS Dataset");
    }
    if (ThreddsDataset.hasAccess()) {
      // Make the filter.
      FilterBean filter = new FilterBean();
      filter.setAction("apply-dataset");
      /**
       * @todo  We're doing this work twice.  If we were smarter we
       * wouldn't be.
       */

      // This will create a filter that doesn't match anything.
      // The LAS interface generator will ignore this category.
      String url = "yadayada";

      for (Iterator ait = ThreddsDataset.getAccess().iterator();
           ait.hasNext(); ) {
        InvAccess access = (InvAccess) ait.next();
        if (access.getService().getServiceType() == ServiceType.DODS ||
            access.getService().getServiceType() == ServiceType.OPENDAP ||
            access.getService().getServiceType() == ServiceType.NETCDF) {
          url = access.getStandardUrlName();
        }
      }

      String tag;
      try {
        MessageDigest md;
        md = MessageDigest.getInstance("SHA-1");
        byte[] result = md.digest(url.getBytes());
        tag =
            "id-" +
            hexEncode(result).substring(result.length / 2, result.length);
      }
      catch (NoSuchAlgorithmException e) {
        System.out.println("Cannot create SHA-1 hash." + e.getMessage());
        tag = "id-12345";
      }

      filter.setContainstag(tag);
      cb.addFilter(filter);
    }
      
    Vector subCats = new Vector();
    for (Iterator subDatasetsIt = ThreddsDataset.getDatasets().iterator();
         subDatasetsIt.hasNext(); ) {
      InvDataset subDataset = (InvDataset) subDatasetsIt.next();
      // Process the sub-categories
      CategoryBean subCat = processCategories(subDataset);
      subCats.add(subCat);
    }
    cb.setCategories(subCats);

    return cb;
  }

  /**
   * createXMLfromNetcdfDataset
   *
   * @param ncds NetcdfDataset
   * @param url String
   * @return Document
   */
  public static DatasetsGridsAxesBean createBeansFromNetcdfDataset(
      NetcdfDataset ncds,
      String url) {

    DatasetsGridsAxesBean dagb = new DatasetsGridsAxesBean();
    Vector DatasetBeans = new Vector();
    DatasetBean dataset = new DatasetBean();
    UniqueVector GridBeans = new UniqueVector();
    UniqueVector AxisBeans = new UniqueVector();

    dataset.setVersion(version_string);
    dataset.setCreator(addXML.class.getName());

    if (verbose) {
      System.out.println("Processing netCDF dataset: " + url);
    }

    // Get a list of grids

    Attribute nameAttribute = null;
    if (global_title_attribute == null) {
      nameAttribute = ncds.findGlobalAttributeIgnoreCase("long_name");
      if (nameAttribute == null) {
        nameAttribute = ncds.findGlobalAttributeIgnoreCase("title");
      }
    }
    else {
      nameAttribute = ncds.findGlobalAttributeIgnoreCase(global_title_attribute);
    }
    String name = null;

    if (nameAttribute != null) {
      if (nameAttribute.isString()) {
        name = nameAttribute.getStringValue();
      }
    }
    GridDataset gridDs = new GridDataset(ncds);
    if (name == null) {
      name = url;
    }

    String elementName = name;

    try {
      MessageDigest md;
      md = MessageDigest.getInstance("SHA-1");
      byte[] result = md.digest(url.getBytes());
      elementName =
          "id-" +
          hexEncode(result).substring(result.length / 2, result.length);
    }
    catch (NoSuchAlgorithmException e) {
      System.out.println("Cannot create SHA-1 hash." + e.getMessage());
      elementName = "id-12345";
    }

    dataset.setName(name);
    dataset.setElement(elementName);
    dataset.setUrl(url);

    List grids = gridDs.getGrids();

    if (grids.size() == 0) {
      dataset.setComment(
          "This data source has no lat/lon grids that follow a known convention.");
      System.err.println("File parsed.  No Lat/Lon grids found.");
    }
    for (int i = 0; i < grids.size(); i++) {
      /*
       * A GridDataset can contain one or more GeoGrid objects each
       * potentially defined on its own axes.
       *
       * A Java netCDF GeoGrid contains the same information the combination
       * of an LAS variable, grid, and assoicated axes.
       *
       * To make the resulting XML fragment as compact as possible,
       * this code attempts to get the smallest set of LAS grids
       * necessary.
       */

      UniqueVector GridAxisBeans = new UniqueVector();

      GeoGrid geogrid = (GeoGrid) grids.get(i);

      VariableBean variable = new VariableBean();
      variable.setUrl("#" + geogrid.getName());
      if (!geogrid.getDescription().equals(geogrid.getName())) {
        variable.setName(geogrid.getDescription());
      }
      else {
        variable.setName(geogrid.getName());
      }
      variable.setElement(geogrid.getName() + "-" + elementName);
      variable.setUnits(geogrid.getUnitsString());

      GridCoordSys gcs = geogrid.getCoordinateSystem();

      GridBean grid = new GridBean();

      String grid_name = "grid";
      CoordinateAxis1D xAxis = (CoordinateAxis1D) gcs.getXHorizAxis();
      grid_name = grid_name + "-" + xAxis.getShortName();
      if (verbose) {
        System.out.println("\t Variable: " + geogrid.getName());
        System.out.print("\t\t Longitude axis: ");
      }
      AxisBean xaxis = makeGeoAxis(xAxis, "x", elementName);
      GridAxisBeans.addUnique(xaxis);
      if (verbose) {
        System.out.println(xaxis.toString());
      }
      CoordinateAxis1D yAxis = (CoordinateAxis1D) gcs.getYHorizAxis();
      grid_name = grid_name + "-" + yAxis.getShortName();
      if (verbose) {
        System.out.print("\t\t Latitude axis: ");
      }
      AxisBean yaxis = makeGeoAxis(yAxis, "y", elementName);
      GridAxisBeans.addUnique(yaxis);
      if (verbose) {
        System.out.println(yaxis.toString());
      }
      if (gcs.hasVerticalAxis()) {
        CoordinateAxis1D zAxis = gcs.getVerticalAxis();
        grid_name = grid_name + "-" + zAxis.getShortName();
        if (verbose) {
          System.out.print("\t\t Vertical axis: ");
        }
        AxisBean zaxis = makeGeoAxis(zAxis, "z", elementName);
        GridAxisBeans.addUnique(zaxis);
        if (verbose) {
          System.out.println(zaxis.toString());
        }

      }
      else {
        if (verbose) {
          System.out.println("\t\t No vertical axis");
        }
      }

      CoordinateAxis1D tAxis = gcs.getTimeAxis();

      if (tAxis != null) {
        grid_name = grid_name + "-" + tAxis.getShortName();
        if (verbose) {
          System.out.print("\t\t Time axis: ");
        }
        AxisBean taxis = makeTimeAxis(tAxis, elementName);
        GridAxisBeans.addUnique(taxis);
        if (verbose) {
          System.out.println(taxis.toString());
        }
      }
      else {
        System.out.println("\t\t No time axis");
      }

      grid.setElement(grid_name + "-" + elementName);
      grid.setAxes(GridAxisBeans);
      variable.setGrid(grid);
      dataset.addVariable(variable);
      ProjectionImpl proj = geogrid.getProjection();

      if (verbose) {
        if (proj instanceof LatLonProjection) {
          System.out.println("\t\t Grid has LatLonProjection.");
        }
        else if (proj instanceof LambertConformal) {
          System.out.println("\t\t Grid has Lambert Conformal projection...");
        }
        else if (proj instanceof Stereographic) {
          System.out.println("\t\t Grid has Stereographic projection...");
        }
        else if (proj instanceof TransverseMercator) {
          System.out.println("\t\t Grid has Transvers Mercator projection...");
        }
        else {
          System.out.println("\t\t Grid has unknown projection...");
        }
      }

      // Add the axis beans for this grid to the list of axis in this data source.
      for (Iterator abit = GridAxisBeans.iterator(); abit.hasNext(); ) {
        AxisBean ab = (AxisBean)abit.next();
        AxisBeans.addUnique(ab);
      }
      GridBeans.addUnique(grid);

    } // Loop over Grids
    DatasetBeans.add(dataset);
    dagb.setDatasets(DatasetBeans);
    dagb.setGrids(GridBeans);
    dagb.setAxes(AxisBeans);
    return dagb;
  }

  public static org.jdom.Document createXMLfromNetcdfDataset(NetcdfDataset
      ncds,
      String url) {
    DatasetsGridsAxesBean beans = createBeansFromNetcdfDataset(ncds, url);
    DatasetBean dataset = (DatasetBean) beans.getDatasets().get(0);
    Vector GridBeans = (Vector) beans.getGrids();
    Vector AxisBeans = (Vector) beans.getAxes();

    Document doc = new Document();
    Element lasdata = new Element("lasdata");
    doc.setRootElement(lasdata);
    Element datasetsElement = new Element("datasets");
    Element thisDataset = dataset.toXml();
    datasetsElement.addContent(thisDataset);
    lasdata.addContent(datasetsElement);
    Element gridsElement = new Element("grids");
    Iterator git = GridBeans.iterator();
    while (git.hasNext()) {
      GridBean gb = (GridBean) git.next();
      Element gridElement = gb.toXml();
      gridsElement.addContent(gridElement);
    }
    lasdata.addContent(gridsElement);

    Element axesElement = new Element("axes");
    Iterator ait = AxisBeans.iterator();
    while (ait.hasNext()) {
      AxisBean ab = (AxisBean) ait.next();
      Element axisElement = ab.toXml();
      axesElement.addContent(axisElement);
    }

    lasdata.addContent(axesElement);
    return doc;

  } // end of createXMLfromNetcdfDataset

  public static org.jdom.Document createXMLfromDatasetsGridsAxesBean(
      DatasetsGridsAxesBean beans) {

    Vector dataset = (Vector) beans.getDatasets();
    Vector GridBeans = (Vector) beans.getGrids();
    Vector AxisBeans = (Vector) beans.getAxes();

    Document doc = new Document();
    Element lasdata = new Element("lasdata");
    doc.setRootElement(lasdata);
    Element datasetsElement = new Element("datasets");
    Iterator dit = dataset.iterator();
    while (dit.hasNext()) {
      DatasetBean d = (DatasetBean) dit.next();
      Element thisDataset = d.toXml();
      datasetsElement.addContent(thisDataset);
    }
    lasdata.addContent(datasetsElement);
    Element gridsElement = new Element("grids");
    Iterator git = GridBeans.iterator();
    while (git.hasNext()) {
      GridBean gb = (GridBean) git.next();
      Element gridElement = gb.toXml();
      gridsElement.addContent(gridElement);
    }
    lasdata.addContent(gridsElement);

    Element axesElement = new Element("axes");
    Iterator ait = AxisBeans.iterator();
    while (ait.hasNext()) {
      AxisBean ab = (AxisBean) ait.next();
      Element axisElement = ab.toXml();
      axesElement.addContent(axisElement);
    }

    lasdata.addContent(axesElement);
    return doc;

  } // end of createXMLfromDatasetsGridsAxesBean

  static private AxisBean makeTimeAxis(CoordinateAxis1D axis, String id) {

    // LAS only understands time units of: 'year', 'month', 'day', and 'hour'

    String patterns[] = {
        "yyyy", "yyyy-MM-dd", "yyyy-MM-dd", "yyyy-MM-dd",
        "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm:ss",
        "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm:ss"};
    String type = "t";
    AxisBean axisbean = new AxisBean();
    axisbean.setType(type);
    axisbean.setElement(axis.getShortName() + "-" + type + "-" + id);
    ArangeBean arange = new ArangeBean();

    // Do a bunch of extra work to make this time axis into what LAS needs.

    boolean zeroOrigin = false;
    boolean useV = false;

    // Get a Java UDUNITS unit representation of this date string.
    String unitsString = axis.getUnitsString().toLowerCase();

    unitsString = unitsString.trim();

    // If the units contains year 0000, we're going to have to
    // boost the dates over into year 1 so we don't have to deal
    // with negative years.  (There is no year 0 in the chronology
    // we're using.

    if (unitsString.indexOf("0000") >= 0) {
      unitsString.replaceFirst("0000", "0001");
      zeroOrigin = true;
    }

    // If it doesn't contain the word "since" and some ":" we probably can't
    // decode the times, so we're just going to dump them into the file.
    if (unitsString.indexOf("since") < 0 && unitsString.indexOf(":") < 0  ) {
      useV = true;
    }
    // This if test checks to see if this units string ends in an alpha character
    // If it does, we're thinking there is some time zone stuff at the end that
    // should be chopped off.  It's probably a bug in SimpleUnit that should
    // be reported.
    String last = unitsString.toLowerCase().substring(unitsString.length()-1,unitsString.length());
    if (unitsString.substring(unitsString.length()-1,unitsString.length()).matches("[a-zA-Z]")) {
          unitsString = unitsString.substring(0, unitsString.lastIndexOf(" "));
    }

    double t[] = axis.getCoordValues();

    // Units sting is one of the bogus "day", "month", etc and there
    // is no time_origin attribute so just dump it out as <v> elements.
    if (useV) {
      // In this case do not attempt to decode the time elements
      axisbean.setUnits(unitsString);
      axisbean.setArange(null);
      String ts[] = new String[t.length];
      for (int i = 0; i < t.length; i++) {
        ts[i] = String.valueOf(t[i]);
      }
      axisbean.setV(ts);
      return axisbean;
    }

    DateUnit dateUnit = (DateUnit) SimpleUnit.factory(unitsString);

    if (dateUnit == null) {
      System.out.println("Not a date Unit String: " + unitsString);
    }

    // This is the Joda Time Chronology that cooresponds to the
    // Java Gregorian Calendar and the Udunits Calendar.

    // Always use this chronology and the UTC Time Zone.
    Chronology chrono = Chronology.getGJ();

    if (t.length > 2) {

      Date date1 = dateUnit.getStandardDate(t[0]);
      Date date2 = dateUnit.getStandardDate(t[1]);
      DateTime jodaDate1 = new DateTime(date1, chrono);
      DateTime jodaDate2 = new DateTime(date2, chrono);
      Period period =
          new Period(jodaDate1.withZone(DateTimeZone.UTC),
                     jodaDate2.withZone(DateTimeZone.UTC));

      // Returns the number of years, months, weeks, days,
      // hours, minutes, seconds, and millis between these
      // two dates.

      // Only one should be greater than 0.
      int numPeriods = 0;
      String periods = "";
      int values[] = period.getValues();
      DurationFieldType types[] = period.getFieldTypes();
      DateTimeFormatter fmt = null;
      for (int i = 0; i < values.length; i++) {
        if (values[i] > 0) {
          numPeriods++;
          fmt = DateTimeFormat.forPattern(patterns[i]);
          int step = values[i];
          String typeName = types[i].getName();
          // Get rid of the "s" in the plural form of the name.
          typeName = typeName.substring(0, typeName.length() - 1);
          // LAS doesn't understand "week" so make it "day" and
          // multiply the step by 7.
          periods = periods + " " + typeName;
          if (typeName.equals("week")) {
            typeName = "day";
            step = step * 7;
          }
          axisbean.setUnits(typeName);
          arange.setStep(String.valueOf(step));
        }
      }
      if (numPeriods > 1) {

        // This is special code to deal with climatology files that define
        // the time axis in the "middle" of the month.  Since there is no
        // "middle" of months (but there is certainly always a
        // first of the month, geez-o) so we are left to figure this out by
        // looking at the period values and guessing that this really means
        // climo months.

        // Is the gap in years and months 0?
        // Are the values 4 weeks apart?
        if ( (values[0] == 0 && values[1] == 0) &&
            (values[2] == 4)) {
          // We're guessing these are months
          axisbean.setUnits("month");
          arange.setStep("1");
        }
        else {
          System.out.println("Too many periods: " + periods);
          //Try just dumping out the formatted times
          axisbean.setArange(null);
          String ts[] = new String[t.length];
          for (int i = 0; i < t.length; i++) {
            DateTime dt =
                new DateTime(dateUnit.getStandardDate(t[i]), chrono);
            ts[i] = fmt.print(dt.withZone(DateTimeZone.UTC));
          }
          axisbean.setV(ts);

        }
      }
      Boolean forceAxis = (Boolean) forceAxes.get("t");
      if ( (axis.isRegular() || axisbean.getUnits().equals("month")) ||
          forceAxis.booleanValue()) {

        // Months are "regular" according to LAS, but not according
        // to the isRegular() test, so we need special code for
        // months.

        /** @todo Check to make sure that if it's months it really is regular. */

        arange.setSize(String.valueOf(axis.getSize()));
        arange.setStart(fmt.print(jodaDate1.withZone(DateTimeZone.UTC)));
        axisbean.setArange(arange);
      }
      else {
        // Layout the time axis using "v" elements.

        axisbean.setArange(null);
        String ts[] = new String[t.length];
        for (int i = 0; i < t.length; i++) {
          DateTime dt =
              new DateTime(dateUnit.getStandardDate(t[i]), chrono);
          ts[i] = fmt.print(dt.withZone(DateTimeZone.UTC));
        }
        axisbean.setV(ts);

      }
    }
    else {
      // Time axis has only one time step.
      // We have no idea what this single time point looks like so,
      // format it for all year, month, day, hours, minutes, seconds
      DateTimeFormatter fmt = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");
      Date date1 = dateUnit.getStandardDate(t[0]);
      DateTime jodaDate1 = new DateTime(date1, DateTimeZone.UTC);
      arange.setSize("1");
      arange.setStep("1");
      arange.setStart(fmt.print(jodaDate1));
      // The UI will eliminate this axis.  I think it's safe to set
      // the units to anything.  !?!?
      axisbean.setUnits("day");
      axisbean.setArange(arange);
    }

    return axisbean;
  }

  static private AxisBean
      makeGeoAxis(CoordinateAxis1D axis, String type, String id) {
    DecimalFormat fmt = new DecimalFormat("####.####");
    AxisBean axisbean = new AxisBean();
    axisbean.setType(type);
    axisbean.setElement(axis.getShortName() + "-" + type + "-" + id);
    ArangeBean arange = new ArangeBean();
    axisbean.setUnits(axis.getUnitsString());
    Boolean forceAxis = (Boolean) forceAxes.get(type);
    if ( (axis.isRegular() && axis.getSize() > 1) || forceAxis.booleanValue()) {
      arange.setSize(String.valueOf(axis.getSize()));
      double delta = axis.getIncrement();
      double start = axis.getStart();
      // Flip so that the axis is South to North
      if (delta < 0 && type.equals("y")) {
        start = start + (axis.getSize() - 1) * delta;
        delta = -delta;
      }
      arange.setStep(fmt.format(delta));
      arange.setStart(fmt.format(start));
      axisbean.setArange(arange);
    }
    else {
      double[] v = axis.getCoordValues();

      // List Latitude south to north
      if (v[0] > v[v.length - 1] && type.equals("y")) {
        reverse(v);
      }
      axisbean.setArange(null);

      /** @todo we want to use 4-log[base10](max-min). */
      String[] vs = new String[v.length];
      for (int i = 0; i < v.length; i++) {
        vs[i] = fmt.format(v[i]);
      }
      axisbean.setV(vs);

    }
    return axisbean;

  }

  /**
   * The byte[] returned by MessageDigest does not have a nice
   * textual representation, so some form of encoding is usually performed.
   *
   * This implementation follows the example of David Flanagan's book
   * "Java In A Nutshell", and converts a byte array into a String
   * of hex characters.
   *
   * Another popular alternative is to use a "Base64" encoding.
   */
  static private String hexEncode(byte[] aInput) {
    StringBuffer result = new StringBuffer();
    char[] digits = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
        'e', 'f'};
    for (int idx = 0; idx < aInput.length; ++idx) {
      byte b = aInput[idx];
      result.append(digits[ (b & 0xf0) >> 4]);
      result.append(digits[b & 0x0f]);
    }
    return result.toString();
  }

//========================================================= reverse
// Stolen directly off the web from:
// http://leepoint.net/notes-java/data/arrays/34arrayreverse.html
// Converted from int array to double...
  public static void reverse(double[] b) {
    int left = 0; // index of leftmost element
    int right = b.length - 1; // index of rightmost element

    while (left < right) {
      // exchange the left and right elements
      double temp = b[left];
      b[left] = b[right];
      b[right] = temp;

      // move the bounds toward the center
      left++;
      right--;
    }
  } //endmethod reverse

  static public void outputXML(String outfile, Document doc) {
    try {
      File outputFile = new File(outfile);
      FileWriter xmlout = new FileWriter(outputFile);
      org.jdom.output.Format format = org.jdom.output.Format.getPrettyFormat();
      format.setLineSeparator(System.getProperty("line.separator"));
      XMLOutputter outputter =
          new XMLOutputter(format);
      outputter.output(doc, xmlout);
      // Close the FileWriter
      xmlout.close();
    }
    catch (java.io.IOException e) {
      System.out.println(e.getMessage());
      e.printStackTrace();
    }
  }

  static public void outputXML(String outfile, Element element, boolean append) {
    try {
      File outputFile = new File(outfile);
      FileWriter xmlout = new FileWriter(outputFile, append);
      org.jdom.output.Format format = org.jdom.output.Format.getPrettyFormat();
      format.setLineSeparator(System.getProperty("line.separator"));
      XMLOutputter outputter =
          new XMLOutputter(format);
      outputter.output(element, xmlout);
      xmlout.write("\n");
      // Close the FileWriter
      xmlout.close();
    }
    catch (java.io.IOException e) {
      System.out.println(e.getMessage());
      e.printStackTrace();
    }
  }

  private void jbInit() throws Exception {
  }

} // end of class