source: nappy/trunk/naToCdms.py @ 347

"""
naToCdms.py
===========

Container module for mixin class NAToCdms that is sub-classed
by NAFile classes.

"""

# Imports from python standard library
import sys
sys.path.append(r"..")
import os
import re
import time

# Import from nappy package
import cdmsMap
from naError import *
import version

# Import external packages (if available)
if sys.platform.find("win")>-1:
    pass
else:
    try:
        import cdms, Numeric
        cdms.setAutoBounds("off") 
    except:
        print "Cannot import cdms package, CDAT-dependent features will not work."

# Define global variables
safe_nc_id=re.compile("[\s\[()\]=+-?#~@&$%!*{}\^]+")
time_units_pattn=re.compile("\w+\s+since\s+\d{4}-\d{1,2}-\d{1,2}\s+\d+:\d+:\d+")

class NAToCdms:

    def toCdmsFile(self, filename, time_units=None, variables="all", aux_variable="all", global_attributes={"Conventions":"CF-1.0"}, ffi=None):
        if sys.platform.find("win")>-1:
            raise NAPlatformError

        self.time_units=time_units
        # Read the data section of the NASA Ames file
        self.readData()
        self.cdmsFilename=filename
        self.cdmsFile=cdms.open(self.cdmsFilename, 'w')
        
        # at file level: write global attributes
        for key in global_attributes.keys():
            setattr(self.cdmsFile, key, global_attributes[key])

        for key in cdmsMap.fromNA.keys():
            if type(key)==tuple:
                if key==("SCOM", "NCOM"):
                    # Map special and normal comments into the global comments section
                    
                    commentline=""
                    if self.NSCOML>0:
                        commentline=commentline+"###NASA Ames Special Comments follow###\n"
                        for i in self.SCOM: 
                            if i.strip() not in ("###NASA Ames Special Comments follow###", "###NASA Ames Special Comments end###",
                                    "Additional Variable Attributes defined in the source file and not translated elsewhere:",
                                    "Additional Global Attributes defined in the source file and not translated elsewhere:", "\n"):
                                commentline=commentline+"\n"+i
                        commentline=commentline+"\n###NASA Ames Special Comments end###\n"
                    if self.NNCOML>0:
                        commentline=commentline+"###NASA Ames Normal Comments follow###\n"
                        for i in self.NCOM: 
                            if i.strip() not in ("###NASA Ames Normal Comments follow###", "###NASA Ames Normal Comments end###", "###Data Section begins on the next line###",
                                    "Additional Variable Attributes defined in the source file and not translated elsewhere:",
                                    "Additional Global Attributes defined in the source file and not translated elsewhere:", "\n"):
                                commentline=commentline+"\n"+i
                        commentline=commentline+"\n###NASA Ames Normal Comments end###"
                        commentline=commentline.replace("\n\n", "\n")
                    self.cdmsFile.comment=commentline
                elif key==("ONAME", "ORG"):
                    # Map the two organisation NA files to the institution field in CDMS (NetCDF)
                    self.cdmsFile.institution="%s (ONAME from NASA Ames file); %s (ORG from NASA Ames file)." % (self.ONAME, self.ORG)
                else:
                    item=(getattr(self, key[0]))+"\n"+(getattr(self, key[1]))
                    setattr(self.cdmsFile, cdmsMap.fromNA[key], item)
            elif key=="RDATE":
                dateparts=getattr(self, "RDATE")
                datestring="%.4d-%.2d-%.2d" % tuple(dateparts)
                item=datestring+" - NASA Ames File created/revised.\n"
                timestring=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
                item=item+"\n"+timestring+" - Converted to CDMS (NetCDF) format using nappy-%s." % version.version
            else:
                setattr(self.cdmsFile, cdmsMap.fromNA[key], getattr(self, key))

        # Then do dimensions
        if not hasattr(self, 'cdmsAxes'):  self.createCdmsAxes()

        # Then do variables
        if not hasattr(self, 'cdmsVariables'):  self.createCdmsVariables()
        for var in self.cdmsVariables:
            self.cdmsFile.write(var)

        # Then do auxiliary variables
        if hasattr(self, "NAUXV") and type(self.NAUXV)==int:   # Are there any auxiliary variables?
            if not hasattr(self, 'cdmsAuxVariables'):  self.createCdmsAuxVariables()
            for avar in self.cdmsAuxVariables:
                self.cdmsFile.write(avar)

        self.cdmsFile.close()
        return "Cdmsfile '%s' written successfully." % self.cdmsFilename

    def createCdmsVariables(self):
        self.cdmsVariables=[]
        for var_number in range(self.NV):
            self.cdmsVariables.append(self.toCdmsVariable(var_number))


    def toCdmsVariable(self, var_number, attributes={}):
        if sys.platform.find("win")>-1:
            raise NAPlatformError
        (varname, units, miss, scal)=self.getVariable(var_number)
        print self.V
        array=Numeric.array(self.V[var_number])
        array=array*scal
        # Set up axes
        if not hasattr(self, 'cdmsAxes'):
            self.createCdmsAxes()

        # Set up variable
        var=cdms.createVariable(array, axes=self.cdmsAxes, fill_value=miss, attributes=attributes)

        # Sort units etc
        if units:   var.units=units
        
        # Add the best variable name
        if len(varname)<20:
            var.id=safe_nc_id.sub("_", varname).lower()
        else:
            var.id="naVariable_%s" % (var_number)

        var.long_name=var.name=varname

        # If we have a standard name list then compare to it
        if varname in ("standard_name_list",) or varname in ("badc_list",):
            var.standard_name="name from the list###**"

        # Add a NASA Ames variable number (for mapping correctly back to NASA Ames)
        var.nasa_ames_var_number=var_number

        return var

    def createCdmsAuxVariables(self):
        self.cdmsAuxVariables=[]
        for avar_number in range(self.NAUXV):
            self.cdmsAuxVariables.append(self.auxToCdmsVariable(avar_number))

    def auxToCdmsVariable(self, avar_number, attributes={}):
        if sys.platform.find("win")>-1:
            raise NAPlatformError
        (varname, units, miss, scal)=self.getAuxVariable(avar_number)
        array=Numeric.array(self.A[avar_number])
        array=array*scal

        # Set up axes
        if not hasattr(self, 'cdmsAxes'):
            self.createCdmsAxes()

        # Set up variable
        var=cdms.createVariable(array, axes=[self.cdmsAxes[0]], fill_value=miss, attributes=attributes)

        # Sort units etc
        if units:   var.units=units
        if len(varname)<20:
            var.id=safe_nc_id.sub("_", varname).lower()
        else:
            var.id="naAuxVariable_%s" % (avar_number)

        var.long_name=var.name=varname
        if varname in ("standard_name_list",) or varname in ("badc_list",):
            var.standard_name="name from the list***"


        # Add a NASA Ames auxiliary variable number (for mapping correctly back to NASA Ames)
        var.nasa_ames_aux_var_number=avar_number

        return var        

    def createCdmsAxes(self):
        if sys.platform.find("win")>-1:
            raise NAPlatformError
        if not hasattr(self, 'cdmsAxes'):        
            self.cdmsAxes=[]
        for ivar_number in range(self.NIV):
            self.cdmsAxes.append(self.toCdmsAxis(ivar_number))

    def toCdmsAxis(self, ivar_number):
        if sys.platform.find("win")>-1:
            raise NAPlatformError

        if self._normalizedX=="no": self._normalizeIndVars()

        if self.NIV==1:
            array=self.X
        else:
            array=self.X[ivar_number]
        axis=cdms.createAxis(array)
        axis.id=axis.name=axis.long_name=self.XNAME[ivar_number]
        (varname, units)=self.getIndependentVariable(ivar_number)
        # Sort units etc
        if units:   axis.units=units
        if len(varname)<20:
            axis.id=safe_nc_id.sub("_", varname).lower()
        else:
            axis.id="naAuxVariable_%s" % (ivar_number)

        if units: axis.units=units
        axis_types=("longitude", "latitude", "level", "time")
        designators={"longitude":axis.designateLongitude, "latitude":axis.designateLatitude,
                     "level":axis.designateLevel, "time":axis.designateTime}
        for axis_type in axis_types:
            if re.search(axis_type, varname, re.IGNORECASE):
                axis.standard_name=axis.id=axis_type
                apply(designators[axis_type.lower()])
                # Check warning for time units pattern
                if axis.isTime() and (not hasattr(axis, "units") or not time_units_pattn.match(axis.units)):
                    if self.time_units==None:
                        print """\nWARNING: Could not recognise time units. For true NetCDF compability
please insert the correct time unit string below in the format:
    
    <units> since <YYYY>-<MM>-<DD> <hh>-<mm>-<ss>
    
Where:
    <units> is a known time interval such as years, months, days, etc.
    <YYYY> is the year, <MM> is the month, <DD> is the day,
    <hh> is the hour, <mm> is minutes, <ss> is seconds.
"""
                        timeUnitsInput="I WON'T MATCH"
                        while timeUnitsInput!="" and not time_units_pattn.match(timeUnitsInput):
                            timeUnitsInput=raw_input("Please insert your time unit string here (or leave blank):").strip()
                        if timeUnitsInput!="":
                            self.time_units=timeUnitsInput
                    axis.units=self.time_units
                    axis.long_name=axis.name="time (%s)" % self.time_units
                
        return axis


class NA2Cdms(NAToCdms):
    """
    Pseudonym for NAToCdms class.
    """
    pass