fram-core 0.0.0__py3-none-any.whl → 0.1.0a1__py3-none-any.whl

framcore/timeindexes/HourlyIndex.py

@@ -0,0 +1,21 @@
+from datetime import timedelta
+
+from framcore.timeindexes.ProfileTimeIndex import ProfileTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class HourlyIndex(ProfileTimeIndex):
+    """One or more whole years with hourly resolution."""
+
+    def __init__(
+        self,
+        start_year: int,
+        num_years: int,
+        is_52_week_years: bool = True,
+    ) -> None:
+        """One or more whole years with hourly resolution."""
+        super().__init__(
+            start_year=start_year,
+            num_years=num_years,
+            period_duration=timedelta(hours=1),
+            is_52_week_years=is_52_week_years,
+        )

framcore/timeindexes/IsoCalendarDay.py

@@ -0,0 +1,31 @@
+from datetime import datetime, timedelta
+
+from framcore.timeindexes.SinglePeriodTimeIndex import SinglePeriodTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class IsoCalendarDay(SinglePeriodTimeIndex):
+    """
+    Represents a single ISO calendar day using year, week, and day values.
+
+    Inherits from SinglePeriodTimeIndex and provides a time index for one day,
+    constructed from datetime.fromisocalendar(year, week, day).
+
+    """
+
+    def __init__(self, year: int, week: int, day: int) -> None:
+        """
+        IsoCalendarDay represent a day from datetime.fromisocalendar(year, week, day).
+
+        No extrapolation.
+
+        is_52_week_years=False
+
+        Useful for testing.
+        """
+        super().__init__(
+            start_time=datetime.fromisocalendar(year, week, day),
+            period_duration=timedelta(days=1),
+            is_52_week_years=False,
+            extrapolate_first_point=False,
+            extrapolate_last_point=False,
+        )

framcore/timeindexes/ListTimeIndex.py

@@ -0,0 +1,197 @@
+import functools
+import math
+from datetime import datetime, timedelta, tzinfo
+
+import numpy as np
+from numpy.typing import NDArray
+
+from framcore.fingerprints import Fingerprint
+from framcore.timeindexes import FixedFrequencyTimeIndex
+from framcore.timeindexes.TimeIndex import TimeIndex  # NB! full import path needed for inheritance to work
+
+
+class ListTimeIndex(TimeIndex):
+    """
+    ListTimeIndex class for TimeIndexes with a list of timestamps. Subclass of TimeIndex.
+
+    This TimeIndex is defined by a list of timestamps, with possible irregular intervals.The last timestamp is not
+    necessarily the end of the time vector, and the first timestamp is not necessarily the start of the time vector
+    if extrapolation is enabled.
+
+    ListTimeIndex is not recommended for large time vectors, as it is less efficient.
+    """
+
+    def __init__(
+        self,
+        datetime_list: list[datetime],
+        is_52_week_years: bool,
+        extrapolate_first_point: bool,
+        extrapolate_last_point: bool,
+    ) -> None:
+        """Initialize the ListTimeIndex class."""
+        dts = datetime_list
+        if len(dts) <= 1:
+            message = f"datetime_list must contain more than one element. Got {datetime_list}"
+            raise ValueError(message)
+        if not all(dts[i] < dts[i + 1] for i in range(len(dts) - 1)):
+            message = f"All elements of datetime_list must be smaller/lower than the succeeding element. Dates must be ordered. Got {datetime_list}."
+            raise ValueError(message)
+        assert len(set(dt.tzinfo for dt in dts if dt is not None)) <= 1
+        self._datetime_list = datetime_list
+        self._is_52_week_years = is_52_week_years
+        self._extrapolate_first_point = extrapolate_first_point
+        self._extrapolate_last_point = extrapolate_last_point
+
+    def __eq__(self, other) -> bool:  # noqa: ANN001
+        """Check if two ListTimeIndexes are equal."""
+        if not isinstance(other, type(self)):
+            return False
+        return (
+            self._datetime_list == other._datetime_list
+            and self._extrapolate_first_point == other._extrapolate_first_point
+            and self._extrapolate_last_point == other._extrapolate_last_point
+        )
+
+    def __hash__(self) -> int:
+        """Return the hash of the ListTimeIndex."""
+        return hash(
+            (
+                tuple(self._datetime_list),
+                self._extrapolate_first_point,
+                self._extrapolate_last_point,
+            ),
+        )
+
+    def __repr__(self) -> str:
+        """Return the string representation of the ListTimeIndex."""
+        return (
+            "ListTimeIndex("
+            f"datetimelist={self._datetime_list}, "
+            f"extrapolate_first_point={self._extrapolate_first_point}, "
+            f"extrapolate_last_point={self._extrapolate_last_point})"
+        )
+
+    def get_fingerprint(self) -> Fingerprint:
+        """Get the fingerprint of the ListTimeIndex."""
+        fingerprint = Fingerprint()
+        fingerprint.add("datetime_list", self._datetime_list)
+        fingerprint.add("is_52_week_years", self._is_52_week_years)
+        fingerprint.add("extrapolate_first_point", self._extrapolate_first_point)
+        fingerprint.add("extrapolate_last_point", self._extrapolate_last_point)
+        return fingerprint
+
+    def get_datetime_list(self) -> list[datetime]:
+        """Get a list of all periods (num_periods + 1 datetimes)."""
+        return self._datetime_list.copy()
+
+    def get_timezone(self) -> tzinfo | None:
+        """Get the timezone of the TimeIndex."""
+        return self._datetime_list[0].tzinfo
+
+    def get_num_periods(self) -> int:
+        """Get the number of periods in the TimeIndex."""
+        return len(self._datetime_list) - 1
+
+    def is_52_week_years(self) -> bool:
+        """Check if the TimeIndex is based on 52-week years."""
+        return self._is_52_week_years
+
+    def is_one_year(self) -> bool:
+        """Return True if exactly one whole year."""
+        if self._extrapolate_first_point or self._extrapolate_last_point:
+            return False
+        start_time = self._datetime_list[0]
+        stop_time = self._datetime_list[-1]
+        start_year, start_week, start_weekday = start_time.isocalendar()
+        if self._is_52_week_years:
+            return (start_weekday == 1) and (start_week == 1) and (stop_time == start_time + timedelta(weeks=52))
+        stop_year, stop_week, stop_weekday = stop_time.isocalendar()
+        return (start_year + 1 == stop_year) and (start_weekday == stop_weekday == 1) and (start_week == stop_week == 1)
+
+    def is_whole_years(self) -> bool:
+        """Return True if index covers one or more full years."""
+        start_time = self._datetime_list[0]
+        start_year, start_week, start_weekday = start_time.isocalendar()
+        if not start_week == start_weekday == 1:
+            return False
+
+        stop_time = self._datetime_list[-1]
+        if not self.is_52_week_years():
+            stop_year, stop_week, stop_weekday = stop_time.isocalendar()
+            assert stop_year >= start_year
+            return stop_week == stop_weekday == 1
+
+        seconds_52_week_year = 52 * 168 * 3600
+        num_years = (stop_time - start_time).total_seconds() / seconds_52_week_year
+        return num_years.is_integer()
+
+    def extrapolate_first_point(self) -> bool:
+        """Check if the TimeIndex should extrapolate the first point."""
+        return self._extrapolate_first_point
+
+    def extrapolate_last_point(self) -> bool:
+        """Check if the TimeIndex should extrapolate the last point."""
+        return self._extrapolate_last_point
+
+    def get_period_average(self, vector: NDArray, start_time: datetime, duration: timedelta, is_52_week_years: bool) -> float:
+        """Get the average over the period from the vector."""
+        # assert vector.shape == (self.get_num_periods(),), f"Vector shape {vector.shape} does not match timeindex {self}"
+        target_timeindex = FixedFrequencyTimeIndex(
+            start_time=start_time,
+            period_duration=duration,
+            num_periods=1,
+            is_52_week_years=is_52_week_years,
+            extrapolate_first_point=self.extrapolate_first_point(),
+            extrapolate_last_point=self.extrapolate_last_point(),
+        )
+        target_vector = np.zeros(1, dtype=vector.dtype)
+        self.write_into_fixed_frequency(
+            target_vector=target_vector,
+            target_timeindex=target_timeindex,
+            input_vector=vector,
+        )
+        return target_vector[0]
+
+    def write_into_fixed_frequency(
+        self,
+        target_vector: NDArray,
+        target_timeindex: FixedFrequencyTimeIndex,
+        input_vector: NDArray,
+    ) -> None:
+        """Write the input vector into the target vector using the target timeindex."""
+        dts: list[datetime] = self._datetime_list
+
+        durations = set(self._microseconds(dts[i + 1] - dts[i]) for i in range(len(dts) - 1))
+        smallest_common_period_duration = functools.reduce(math.gcd, durations)
+
+        num_periods_ff = self._microseconds(dts[-1] - dts[0]) // smallest_common_period_duration
+        input_vector_ff = np.zeros(num_periods_ff, dtype=target_vector.dtype)
+
+        i_start_ff = 0
+        for i in range(len(dts) - 1):
+            num_periods = self._microseconds(dts[i + 1] - dts[i]) // smallest_common_period_duration
+            i_stop_ff = i_start_ff + num_periods
+            input_vector_ff[i_start_ff:i_stop_ff] = input_vector[i]
+            i_start_ff = i_stop_ff
+
+        input_timeindex_ff = FixedFrequencyTimeIndex(
+            start_time=dts[0],
+            num_periods=num_periods_ff,
+            period_duration=timedelta(microseconds=smallest_common_period_duration),
+            is_52_week_years=self.is_52_week_years(),
+            extrapolate_first_point=self.extrapolate_first_point(),
+            extrapolate_last_point=self.extrapolate_last_point(),
+        )
+
+        input_timeindex_ff.write_into_fixed_frequency(
+            target_vector=target_vector,
+            target_timeindex=target_timeindex,
+            input_vector=input_vector_ff,
+        )
+
+    def _microseconds(self, duration: timedelta) -> int:
+        return int(duration.total_seconds() * 1e6)
+
+    def is_constant(self) -> bool:
+        """Check if the time index is constant."""
+        return super().is_constant()

framcore/timeindexes/ModelYear.py

@@ -0,0 +1,17 @@
+from datetime import datetime, timedelta
+
+from framcore.timeindexes.SinglePeriodTimeIndex import SinglePeriodTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class ModelYear(SinglePeriodTimeIndex):
+    """ModelYear represent one 52-week-year. No extrapolation."""
+
+    def __init__(self, year: int) -> None:
+        """Represent a specified year. Use 52-week-year starting on monday in week 1. No extrapolation."""
+        super().__init__(
+            start_time=datetime.fromisocalendar(year, 1, 1),
+            period_duration=timedelta(weeks=52),
+            is_52_week_years=True,
+            extrapolate_first_point=False,
+            extrapolate_last_point=False,
+        )

framcore/timeindexes/ModelYears.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+
+from framcore.timeindexes.ListTimeIndex import ListTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class ModelYears(ListTimeIndex):
+    """ModelYears represents a collection of years as a ListTimeIndex."""
+
+    def __init__(self, years: list[int]) -> None:
+        """Initialize ModelYears with a list of years."""
+        datetime_list = [datetime.fromisocalendar(year, 1, 1) for year in years]
+        datetime_list.append(datetime.fromisocalendar(years[-1] + 1, 1, 1))
+        super().__init__(
+            datetime_list=datetime_list,
+            is_52_week_years=False,
+            extrapolate_first_point=True,
+            extrapolate_last_point=True,
+        )

framcore/timeindexes/OneYearProfileTimeIndex.py

@@ -0,0 +1,21 @@
+from datetime import timedelta
+
+from framcore.timeindexes.ProfileTimeIndex import ProfileTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class OneYearProfileTimeIndex(ProfileTimeIndex):
+    """Fixed frequency over one year."""
+
+    def __init__(self, period_duration: timedelta, is_52_week_years: bool) -> None:
+        """
+        Initialize a OneYearProfileTimeIndex with a fixed frequency over one year.
+
+        We use 1982 for 52-week years and 1981 for 53-week years.
+
+        Args:
+            period_duration (timedelta): Duration of each period.
+            is_52_week_years (bool): Whether to use 52-week years.
+
+        """
+        year = 1982 if is_52_week_years else 1981
+        super().__init__(year, 1, period_duration, is_52_week_years)

framcore/timeindexes/ProfileTimeIndex.py

@@ -0,0 +1,32 @@
+from datetime import datetime, timedelta
+
+from framcore.timeindexes.FixedFrequencyTimeIndex import FixedFrequencyTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class ProfileTimeIndex(FixedFrequencyTimeIndex):
+    """ProfileTimeIndex represent one or more whole years with fixed time resolution standard."""
+
+    def __init__(
+        self,
+        start_year: int,
+        num_years: int,
+        period_duration: timedelta,
+        is_52_week_years: bool,
+    ) -> None:
+        """Initialize the ProfileTimeIndex."""
+        start_time = datetime.fromisocalendar(start_year, 1, 1)
+        if not is_52_week_years:
+            stop_time = datetime.fromisocalendar(start_year + num_years, 1, 1)
+            num_periods = (stop_time - start_time).total_seconds() / period_duration.total_seconds()
+        else:
+            num_periods = timedelta(weeks=52 * num_years).total_seconds() / period_duration.total_seconds()
+        assert num_periods.is_integer()
+        num_periods = int(num_periods)
+        super().__init__(
+            start_time=start_time,
+            period_duration=period_duration,
+            num_periods=num_periods,
+            is_52_week_years=is_52_week_years,
+            extrapolate_first_point=False,
+            extrapolate_last_point=False,
+        )

framcore/timeindexes/SinglePeriodTimeIndex.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+from framcore.timeindexes.FixedFrequencyTimeIndex import FixedFrequencyTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class SinglePeriodTimeIndex(FixedFrequencyTimeIndex):
+    """FrequencyTimeIndex with just one single step."""
+
+    def __init__(
+        self,
+        start_time: datetime,
+        period_duration: timedelta,
+        is_52_week_years: bool = False,
+        extrapolate_first_point: bool = False,
+        extrapolate_last_point: bool = False,
+    ) -> None:
+        """
+        Initialize a SinglePeriodTimeIndex with a single time period.
+
+        Args:
+            start_time (datetime): The start time of the period.
+            period_duration (timedelta): The duration of the period.
+            is_52_week_years (bool, optional): Whether to use 52-week years. Defaults to False.
+            extrapolate_first_point (bool, optional): Whether to extrapolate the first point. Defaults to False.
+            extrapolate_last_point (bool, optional): Whether to extrapolate the last point. Defaults to False.
+
+        """
+        super().__init__(
+            start_time=start_time,
+            period_duration=period_duration,
+            num_periods=1,
+            is_52_week_years=is_52_week_years,
+            extrapolate_first_point=extrapolate_first_point,
+            extrapolate_last_point=extrapolate_last_point,
+        )

framcore/timeindexes/TimeIndex.py

@@ -0,0 +1,90 @@
+# from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from datetime import datetime, timedelta, tzinfo
+
+from numpy.typing import NDArray
+
+from framcore import Base
+from framcore.fingerprints.fingerprint import Fingerprint
+from framcore.timeindexes import FixedFrequencyTimeIndex
+
+
+class TimeIndex(Base, ABC):
+    """TimeIndex interface for TimeVectors."""
+
+    @abstractmethod
+    def __eq__(self, other) -> bool:  # noqa: ANN001
+        """Check if two TimeIndexes are equal."""
+        pass
+
+    @abstractmethod
+    def __hash__(self) -> int:
+        """Compute hash value.."""
+        pass
+
+    @abstractmethod
+    def get_fingerprint(self) -> Fingerprint:
+        """Get the fingerprint of the TimeIndex."""
+        pass
+
+    @abstractmethod
+    def get_timezone(self) -> tzinfo | None:
+        """Get the timezone of the TimeIndex."""
+        pass
+
+    @abstractmethod
+    def get_num_periods(self) -> bool:
+        """Get the number of periods in the TimeIndex."""
+        pass
+
+    @abstractmethod
+    def is_52_week_years(self) -> bool:
+        """Check if the TimeIndex is based on 52-week years."""
+        pass
+
+    @abstractmethod
+    def is_one_year(self) -> bool:
+        """
+        Check if the TimeIndex represents a single year.
+
+        Must be False if
+        extrapolate_first_point and or extrapolate_last_point is True.
+
+        When True, can be repeted in profiles.
+        """
+        pass
+
+    @abstractmethod
+    def is_whole_years(self) -> bool:
+        pass
+
+    @abstractmethod
+    def extrapolate_first_point(self) -> bool:
+        """Check if the TimeIndex should extrapolate the first point. Must be False if is_one_year is True."""
+        pass
+
+    @abstractmethod
+    def extrapolate_last_point(self) -> bool:
+        """Check if the TimeIndex should extrapolate the last point. Must be False if is_one_year is True."""
+        pass
+
+    @abstractmethod
+    def get_period_average(self, vector: NDArray, start_time: datetime, duration: timedelta, is_52_week_years: bool) -> float:
+        """Get the average over the period from the vector."""
+        pass
+
+    @abstractmethod
+    def write_into_fixed_frequency(
+        self,
+        target_vector: NDArray,
+        target_timeindex: FixedFrequencyTimeIndex,
+        input_vector: NDArray,
+    ) -> None:
+        """Write the input vector into the target vector based on the target FixedFrequencyTimeIndex."""
+        pass
+
+    @abstractmethod
+    def is_constant(self) -> bool:
+        """Check if the TimeIndex is constant."""
+        pass

framcore/timeindexes/WeeklyIndex.py

@@ -0,0 +1,21 @@
+from datetime import timedelta
+
+from framcore.timeindexes.ProfileTimeIndex import ProfileTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class WeeklyIndex(ProfileTimeIndex):
+    """One or more whole years with weekly resolution."""
+
+    def __init__(
+        self,
+        start_year: int,
+        num_years: int,
+        is_52_week_years: bool = True,
+    ) -> None:
+        """One or more whole years with weekly resolution."""
+        super().__init__(
+            start_year=start_year,
+            num_years=num_years,
+            period_duration=timedelta(weeks=1),
+            is_52_week_years=is_52_week_years,
+        )

framcore/timeindexes/__init__.py

@@ -0,0 +1,36 @@
+# framcore/timeindexes/__init__.py
+
+"""FRAM time indexes package provides functionality for handling time-related data."""
+
+from framcore.timeindexes.FixedFrequencyTimeIndex import FixedFrequencyTimeIndex
+from framcore.timeindexes.TimeIndex import TimeIndex
+from framcore.timeindexes.SinglePeriodTimeIndex import SinglePeriodTimeIndex
+from framcore.timeindexes.ListTimeIndex import ListTimeIndex
+from framcore.timeindexes.ProfileTimeIndex import ProfileTimeIndex
+from framcore.timeindexes.AverageYearRange import AverageYearRange
+from framcore.timeindexes.ConstantTimeIndex import ConstantTimeIndex
+from framcore.timeindexes.DailyIndex import DailyIndex
+from framcore.timeindexes.HourlyIndex import HourlyIndex
+from framcore.timeindexes.ModelYear import ModelYear
+from framcore.timeindexes.ModelYears import ModelYears
+from framcore.timeindexes.OneYearProfileTimeIndex import OneYearProfileTimeIndex
+from framcore.timeindexes.WeeklyIndex import WeeklyIndex
+from framcore.timeindexes.IsoCalendarDay import IsoCalendarDay
+
+
+__all__ = [
+    "AverageYearRange",
+    "ConstantTimeIndex",
+    "DailyIndex",
+    "FixedFrequencyTimeIndex",
+    "HourlyIndex",
+    "IsoCalendarDay",
+    "ListTimeIndex",
+    "ModelYear",
+    "ModelYears",
+    "OneYearProfileTimeIndex",
+    "ProfileTimeIndex",
+    "SinglePeriodTimeIndex",
+    "TimeIndex",
+    "WeeklyIndex",
+]

framcore/timevectors/ConstantTimeVector.py

@@ -0,0 +1,135 @@
+import numpy as np
+from numpy.typing import NDArray
+
+from framcore.fingerprints import Fingerprint
+from framcore.timeindexes import ConstantTimeIndex
+from framcore.timevectors import ReferencePeriod
+from framcore.timevectors.TimeVector import TimeVector  # NB! full import path needed for inheritance to work
+
+
+class ConstantTimeVector(TimeVector):
+    """ConstantTimeVector class for TimeVectors that are constant over time. Subclass of TimeVector."""
+
+    def __init__(
+        self,
+        scalar: float,
+        unit: str | None = None,
+        is_max_level: bool | None = None,
+        is_zero_one_profile: bool | None = None,
+        reference_period: ReferencePeriod | None = None,
+    ) -> None:
+        """
+        Initialize the ListTimeVector class.
+
+        Args:
+            scalar (float): Constant float value of the timevector.
+            unit (str | None): Unit of the value in the vector.
+            is_max_level (bool | None): Whether the vector represents the maximum level, average level given a
+                                        reference period, or not a level at all.
+            is_zero_one_profile (bool | None): Whether the vector represents aprofile with values between 0 and 1, a
+                                               profile with values averaging to 1 over a given reference period, or is
+                                               not a profile.
+            reference_period (ReferencePeriod | None, optional): Given reference period if the vector represents average
+                                                                 level or mean one profile. Defaults to None.
+
+        Raises:
+            ValueError: When both is_max_level and is_zero_one_profile is not None. This would mean the TimeVector
+                        represents both a level and a profile, which is not allowed.
+
+        """
+        self._scalar = float(scalar)
+        self._unit = unit
+
+        if (is_max_level is not None and is_zero_one_profile is not None) or (is_max_level is None and is_zero_one_profile is None):
+            message = (
+                f"Input arguments for {self}: Must have exactly one 'non-None'"
+                "value for is_max_level and is_zero_one_profile. "
+                "A TimeVector is either a level or a profile."
+            )
+            raise ValueError(message)
+        self._is_max_level = is_max_level
+        self._is_zero_one_profile = is_zero_one_profile
+        self._reference_period = reference_period
+
+        self._check_type(scalar, (float, np.float32))  # TODO: Accept np.float32 elsewhere aswell
+        self._check_type(unit, (str, type(None)))
+        self._check_type(is_max_level, (bool, type(None)))
+        self._check_type(is_zero_one_profile, (bool, type(None)))
+        self._check_type(reference_period, (ReferencePeriod, type(None)))
+
+    def __repr__(self) -> str:
+        """Return the string representation of the ConstantTimeVector."""
+        ref_period = None
+        if self._reference_period is not None:
+            start_year = self._reference_period.get_start_year()
+            num_years = self._reference_period.get_num_years()
+            assert num_years > 0
+            ref_period = f"{start_year}-{start_year + num_years - 1}"
+        unit = f", unit={self._unit}" if self._unit is not None else ""
+        ref_period = f", reference_period={ref_period}" if ref_period is not None else ""
+        is_max_level = f", is_max_level={self._is_max_level}"
+        return f"ConstantTimeVector({self._scalar}{unit}{ref_period}{is_max_level})"
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality between two ConstantTimeVector objects."""
+        if not isinstance(other, ConstantTimeVector):
+            return NotImplemented
+        return (
+            self._scalar == other._scalar
+            and self._unit == other._unit
+            and self._is_max_level == other._is_max_level
+            and self._is_zero_one_profile == other._is_zero_one_profile
+            and self._reference_period == other._reference_period
+        )
+
+    def __hash__(self) -> int:
+        """Compute the hash of the ConstantTimeVector."""
+        return hash((self._scalar, self._unit, self._is_max_level, self._is_zero_one_profile, self._reference_period))
+
+    def get_expr_str(self) -> str:
+        """Simpler representation of self to show in Expr."""
+        return f"{self._scalar} {self._unit if self._unit else ''}"
+
+    def get_vector(self, is_float32: bool) -> NDArray:
+        """Get the values of the TimeVector."""
+        dtype = np.float32 if is_float32 else np.float64
+        out = np.zeros(1, dtype=dtype)
+        out[0] = self._scalar
+        return out
+
+    def get_timeindex(self) -> ConstantTimeIndex:
+        """Get the TimeIndex of the TimeVector."""
+        return ConstantTimeIndex()
+
+    def is_constant(self) -> bool:
+        """Check if the TimeVector is constant."""
+        return True
+
+    def is_max_level(self) -> bool:
+        """Check if TimeVector is a level representing maximum Volume/Capacity."""
+        return self._is_max_level
+
+    def is_zero_one_profile(self) -> bool:
+        """Check if TimeVector is a profile with values between zero and one."""
+        return self._is_zero_one_profile
+
+    def get_unit(self) -> str | None:
+        """Get the unit of the TimeVector."""
+        return self._unit
+
+    def get_reference_period(self) -> ReferencePeriod | None:
+        """Get the reference period of the TimeVector."""
+        if self._reference_period is not None:
+            return self._reference_period
+        if self.is_zero_one_profile() is False:
+            timeindex = self.get_timeindex()
+            return timeindex.get_reference_period()
+        return None
+
+    def get_fingerprint(self) -> Fingerprint:
+        """Get the Fingerprint of the TimeVector."""
+        return self.get_fingerprint_default()
+
+    def get_loader(self) -> None:
+        """Interface method Not applicable for this type. Return None."""
+        return