source: SHX/trunk/src/SeismicHandler/modules/stations.py @ 312

# -*- coding: utf-8 -*-
#
# Copyright (C) 2008-2010 Marcus Walther (walther@szgrf.bgr.de)
#
# This file is part of Seismic Handler eXtended (SHX)
# Full details can be found at project website http://www.seismic-handler.org/
#
# SHX is free software; you can redistribute it and/or modify
# it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# SHX is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with SHX (see license.txt); if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

import sqlalchemy as sa
import sqlalchemy.orm as orm
from sqlalchemy.ext.declarative import declarative_base

from obspy.core.utcdatetime import UTCDateTime
from SeismicHandler.config import Settings
from SeismicHandler.basics import Singleton
from SeismicHandler.modules.log import getLogger

Base = declarative_base()

class ChannelMeta(Base):
    """
    Table holding stations inventory for single channels (e.g. GR.GRA1..BHZ).
    """
    __tablename__ = "meta"

    # internal use only
    id = sa.Column(sa.Integer, primary_key=True)

    # GR.GRA1..BHZ
    channel = sa.Column(sa.String(length=15))
    network = sa.Column(sa.String(length=2), index=True)
    station = sa.Column(sa.String(length=5), index=True)
    location = sa.Column(sa.String(length=2), index=True)
    stream = sa.Column(sa.String(length=2), index=True)
    component = sa.Column(sa.String(length=1), index=True)
    # SQL does not always support datetime with microseconds
    ondate = sa.Column(sa.DateTime, index=True)
    ondatems = sa.Column(sa.Integer, index=True)
    offdate = sa.Column(sa.DateTime, index=True)
    offdatems = sa.Column(sa.Integer, index=True)
    latitude = sa.Column(sa.Numeric(precision=13, length=10))
    longitude = sa.Column(sa.Numeric(precision=13, length=10))
    elevation = sa.Column(sa.Float(precision=2))
    depth = sa.Column(sa.Float(precision=2), default=0.)
    gain = sa.Column(sa.Float(precision=5))
    zeros = sa.Column(sa.Text)
    poles = sa.Column(sa.Text)

    # channel + start must be unique
    __table_args__ = (
        sa.UniqueConstraint("channel", "ondate"), {}
    )

    def __init__(self, network, station, location, stream, component, \
                       latitude, longitude, elevation, depth, gain, poles, \
                       zeros, start, end=None):

        self.channel = ".".join([network, station, location, \
                                                  "".join([stream, component])])

        keys = locals().keys()
        del keys[keys.index("self")]

        # must be handled separately
        del keys[keys.index("start")]
        del keys[keys.index("end")]

        for i in keys:
            setattr(self, i, locals()[i])

        # handle start & end
        # always cut off ms part since most systems do not support it
        self.ondate = (start - start.microsecond/1e6).datetime
        self.ondatems = start.microsecond

        if end:
            self.offdate = (end - end.microsecond/1e6).datetime
            self.offdatems = end.microsecond

    def __repr__(self):
        if self.offdate:
            return "<Channel:%s %s-%s>" % (
                self.channel,
                self.ondate.strftime("%Y-%m-%d"),
                self.offdate.strftime("%Y-%m-%d")
            )
        else:
            return "<Channel:%s %s-NOW>" % (
                self.channel,
                self.ondate.strftime("%Y-%m-%d")
            )

    def __getattr__(self, name):
        """
        Special handling for start and end date, combination of network and
        station (netstation) and location, stream and component (lsc).
        """
        if name.lower() not in ["start", "end", "netstation", "lsc"]:
            return self.__getattribute__(name)

        if name.lower() == "netstation":
            return ".".join([self.__dict__["network"], self.__dict__["station"]])

        if name.lower() == "lsc":
            return ".".join([
                self.__dict__["location"],
                self.__dict__["stream"],
                self.__dict__["component"]
            ])

        # build UTCDateTime from o[n|ff]date[ms]
        if name.lower() == "start":
            return UTCDateTime(self.__dict__["ondate"]) + \
                                                 self.__dict__["ondatems"] / 1e6
        
        if not self.__dict__["offdate"]:
            return None

        return UTCDateTime(self.__dict__["offdate"]) + \
                                                self.__dict__["offdatems"] / 1e6

    def __compare(self, other):
        """
        Compare station information. All fields except for id and those starting
        with underscore are compared.

        FIR information is optional and not included!
        """

        for i in self.__dict__:
            if i.startswith("_") or i == "id":
                continue

            if getattr(self, i) != getattr(other, i):
                return False

        # fir information is optional XXX
            
        return True

    def __eq__(self, other):
        return self.__compare(other)

    def __ne__(self, other):
        return not self.__compare(other)

class FiR(Base):
    """
    Table holding finite impulse responses.
    """
    __tablename__ = "fir"

    # internal use only
    id = sa.Column(sa.Integer, primary_key=True)
    channel_id = sa.Column(sa.Integer, sa.ForeignKey('meta.id'))

    stage = sa.Column(sa.Integer, index=True)
    coefficients = sa.Column(sa.Text)

    channel = orm.relation(ChannelMeta, backref=orm.backref('fir', order_by=stage))

    # ChannelMeta_id + stage must be unique
    __table_args__ = (
        sa.UniqueConstraint("channel_id", "stage"), {}
    )

    def __init__(self, stage, coefficients):
        self.stage = stage
        self.coefficients = coefficients

    def __repr__(self):
        return "<FIR:%s>" % self.channel

class Stations(object):
    """
    Supply station read/write access.
    """
    __metaclass__ = Singleton
    
    stations = {}

    dbsessions = {}

    def __init__(self):
        self.logger = getLogger("stations")
        
        self.read()

    def __getitem__(self, name):
        """
        """
        pass

    def __setitem__(self, name, data):
        """
        Save or update channel information.
        """
        if not isinstance(data, ChannelMeta):
            raise Exception("Only channel specific information can be updated "
                            "or saved!")

    def read(self):
        """
        Init / refresh station information.
        """
        # read only information
        data = []
        for db in Settings.config.inventory.readonly:
            data += self.__readDB(db)

        # data base access r/w
        self.dbreadwrite = Settings.config.inventory.database[0]
        data += self.__readDB()
        
        for i in data:
            if not i.netstation in self.stations:
                self.stations[i.netstation] = {}

            try:
                self.stations[i.netstation][i.lsc].append(i)
            except KeyError:
                self.stations[i.netstation][i.lsc] = [i]

#        print self.stations

    def __readDB(self, db=None):
        """
        Read raw channel data from given database.
        """
        if not db:
            db = self.dbreadwrite

        # init db session only if necessary
        if not self.dbsessions.get(db, None):
            engine = sa.create_engine(db)

            tabledata = Base.metadata
            tabledata.create_all(engine)

            Session = orm.sessionmaker(bind=engine)
            self.dbsessions[db] = Session()

        return self.dbsessions[db].query(ChannelMeta).order_by("ondate").all()

    def __getitem__(self, channeldate):
        """
        Return channel meta data from channel code and time information.
        """
        channel, dt = channeldate
        print "xxx", channel
        # check for overlapping data from rw to readonly db
        # first: identical datasets
#        double = set(data) & set(data_read)
#        print double
#        for i in double:
#            if data[i] != data_read[i]:
#                self.logger.critital("Concurrent data found for channel: %s "
#                                     "WARNING: It's very likely that you use "
#                                     "outdated channel information!",
#                                     i
#                                    )
#            if data_read[i].fir and data_read[i].fir != data[i].fir:
#                self.logger.warning("Concurrent FIR data for channel: %s ",
#                                     i
#                                    )


    def add(self, station):
        """
        Add station to database.
        """
        # XXX check for update -> dirty session

        GRA1 = ChannelMeta(
            network="GR",
            station="GRA1",
            location="",
            stream="BH",
            component="Z",
            latitude=49.691888,
            longitude=11.221720,
            elevation=499.5,
            depth=0,
            gain=0.6e9,
            zeros="(0.0,0.0) (0.0,0.0)",
            poles="(-0.037004,0.037016) (-0.037004,-0.037016)",
            start=UTCDateTime("2006-05-10T16:00:00.000"),
        )
        # GRA1.fir = [FiR(0, "0 1 2 3 4 5 6"), FiR(1, "1 2 3 4 5")]

        session = self.dbsessions[self.dbreadwrite]
        session.add(station)

        try:
            session.commit()
        except:
            session.rollback()

if __name__ == "__main__":
    stations = Stations()
    print stations[("GR.GRA1..BHZ", UTCDateTime())]