FDSNSNCL.py

from typing import Optional, Dict

from ..geomag_types import DataInterval, DataType
from .SNCL import SNCL, get_channel, get_location, get_channel_start


class FDSNSNCL(SNCL):
    @classmethod
    def get_sncl(
        cls,
        data_type: DataType,
        element: str,
        interval: DataInterval,
        station: str,
        network: str = "NT",
        location: Optional[str] = None,
    ) -> "FDSNSNCL":
        if (
            network == "IU"
            and location == "40"
            and data_type not in ["40", "variation"]  # ASL only supports variation data
        ):
            raise ValueError(f"Unsupported data type: {data_type}")
        location = location or get_location(element=element, data_type=data_type)
        return FDSNSNCL(
            station=station,
            network=network,
            channel=get_FDSN_channel(
                element=element,
                data_type=data_type,
                interval=interval,
                network=network,
                location=location,
            ),
            location=location,
        )

    @property
    def data_type(self) -> str:
        if self.location == "40" and self.network == "IU":
            return "variation"
        return super().data_type

    @property
    def element(self) -> str:
        if self.location == "40" and self.network == "IU":
            return _get_FDSN_element(channel=self.channel)
        return super().element


def _get_FDSN_element(channel: str) -> str:
    channel_end = channel[1:]
    if channel_end == "F1":
        return "V"
    elif channel_end == "F2":
        return "U"
    elif channel_end == "FZ":
        return "W"
    raise ValueError(f"Unsupported channel: {channel}")


def get_FDSN_channel(
    element: str,
    data_type: DataType,
    interval: DataInterval,
    network: Optional[str] = None,
    location: Optional[str] = None,
) -> str:
    if location == "40" and network == "IU":
        return _get_channel_start(
            interval=interval, data_type=data_type
        ) + _get_channel_end(element=element)
    return get_channel(element=element, interval=interval, data_type=data_type)


def _get_channel_end(element: str) -> str:
    if element in ["H", "U", "X"]:
        return "F2"
    elif element in ["E", "V", "Y"]:
        return "F1"
    elif element in ["Z", "W"]:
        return "FZ"
    elif element[0:2] == "LF":  # predefined element
        return element[1:]
    elif element[0:2] == "UF":  # predefined element
        return element[1:]
    raise ValueError(f"Unsupported element: {element}")


def _get_channel_start(interval: str, data_type: str) -> str:
    if interval == "tenhertz":
        return "B"
    if interval == "second":
        return "L"
    elif interval == "minute":
        return "U"
    elif interval == "hour":
        return "R"
    elif interval == "day":
        return "P"
    raise ValueError(f" Unexcepted interval: {interval}")