Skip to content

Technology

Models can elucidate the role and value of technologies within the energy system and give modellers an indication for the optimal investment across a time horizon.

Examples of technologies include: Coal, Nuclear, Onshore Wind, Offshore Wind and Solar PV. Each technology is represented as a physical power plant in models.

Technologies have a set of properties that describe, for example, their capital or operational costs, their thermal efficiency, or emissions factors. Forward-looking views of these parameters are called projections.

To access data for technologies and their projections, you can use this Jupyter Notebook on Github.

Bases: TechnologyBase

Technologies can be loaded directly with their id:

coal = Technology.from_id("coal")
Source code in tz/client/technology.py 
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
class Technology(schemas.TechnologyBase):

    """
    <!--
    The Technology class enables access to technology data.
    Technologies are related hierarchically to one another via their parents / children properties.
    -->

    Technologies can be loaded directly with their id:

    ```python
    coal = Technology.from_id("coal")
    ```

    """

    _projections: Optional[ForwardRef("RecordCollection")] = None  # type: ignore[valid-type]
    _children: Optional[list["Technology"]] = None
    _parents: Optional[list["Technology"]] = None

    @classmethod
    def from_id(cls, id: str) -> "Technology":
        """
        Initialize the Technology object from an ID.

        Args:
            id (str): A technology ID, e.g. `coal`.

        Returns:
            Technology: A Technology object.
        """
        technology = api.technologies.get(slug=id)
        return cls(**technology.model_dump())

    @classmethod
    def search(
        cls,
        uuid: str | None = None,
        slug: str | None = None,
        name: str | None = None,
        owner_id: str | None = None,
        public: bool | None = None,
        limit: int = 10,
        page: int = 0,
    ) -> list["Technology"]:
        """
        Search for technologies.

        Args:
            uuid (str | None): The target technology UUID to search.
            slug (str | None): The target technology slug to search.
            names (str | None): The target technology name to search.
            owner_id (str | None): The owner of the technologiess to filter.
            public (bool | None): Filter technologies by public status.
            limit (int): The maximum number of search results to return.
            page (int): The page number of search results to return.

        Returns:
            List[Technology]: A list of Technology objects.
        """

        search_results = api.technologies.search(
            uuid=uuid,
            slug=slug,
            name=name,
            owner_id=owner_id,
            public=public,
            limit=limit,
            page=page,
        )

        return [cls(**technology.model_dump()) for technology in search_results]

    @property
    def id(self) -> str:
        """The ID of the technology."""
        return self.slug

    @classmethod
    def _get_children(cls, slug):
        technology = api.technologies.get(slug=slug, includes="children")
        return [cls(**child.model_dump()) for child in technology.children]

    @classmethod
    def _get_parents(cls, slug):
        technology = api.technologies.get(slug=slug, includes="parents")
        return [cls(**parent.model_dump()) for parent in technology.parents]

    @property
    def children(self) -> list["Technology"]:
        """A set of technologies which are the heirarchical children of this technology."""
        if self._children is None:
            self._children = self._get_children(self.slug)
            return self._children
        return self._children

    @property
    def parents(self) -> list["Technology"]:
        """A set of technology which are the heirarchical ancestors of this technology."""
        if self._parents is None:
            self._parents = self._get_parents(self.slug)
            return self._parents
        return self._parents

    @property
    def projections(self):
        """The RecordCollection associated with the technoogy"""
        if self._projections is None:
            collection = RecordCollection()
            self._projections = collection.search(technology=self.slug)
        return self._projections

    def __str__(self) -> str:
        return f"Technology: {self.name} (id={self.id})"

children: list[Technology] property

A set of technologies which are the heirarchical children of this technology.

id: str property

The ID of the technology.

parents: list[Technology] property

A set of technology which are the heirarchical ancestors of this technology.

projections property

The RecordCollection associated with the technoogy

from_id(id) classmethod

Initialize the Technology object from an ID.

Parameters:

Name Type Description Default
id str

A technology ID, e.g. coal.

 required

Returns:

Name Type Description
Technology Technology

A Technology object.
Source code in tz/client/technology.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
@classmethod
def from_id(cls, id: str) -> "Technology":
    """
    Initialize the Technology object from an ID.

    Args:
        id (str): A technology ID, e.g. `coal`.

    Returns:
        Technology: A Technology object.
    """
    technology = api.technologies.get(slug=id)
    return cls(**technology.model_dump())

search(uuid=None, slug=None, name=None, owner_id=None, public=None, limit=10, page=0) classmethod

Search for technologies.

Parameters:

Name Type Description Default
uuid str | None

The target technology UUID to search.

 None
slug str | None

The target technology slug to search.

 None
names str | None

The target technology name to search.

 required
owner_id str | None

The owner of the technologiess to filter.

 None
public bool | None

Filter technologies by public status.

 None
limit int

The maximum number of search results to return.

 10
page int

The page number of search results to return.

 0

Returns:

Type Description
list[Technology]

List[Technology]: A list of Technology objects.
Source code in tz/client/technology.py 
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
@classmethod
def search(
    cls,
    uuid: str | None = None,
    slug: str | None = None,
    name: str | None = None,
    owner_id: str | None = None,
    public: bool | None = None,
    limit: int = 10,
    page: int = 0,
) -> list["Technology"]:
    """
    Search for technologies.

    Args:
        uuid (str | None): The target technology UUID to search.
        slug (str | None): The target technology slug to search.
        names (str | None): The target technology name to search.
        owner_id (str | None): The owner of the technologiess to filter.
        public (bool | None): Filter technologies by public status.
        limit (int): The maximum number of search results to return.
        page (int): The page number of search results to return.

    Returns:
        List[Technology]: A list of Technology objects.
    """

    search_results = api.technologies.search(
        uuid=uuid,
        slug=slug,
        name=name,
        owner_id=owner_id,
        public=public,
        limit=limit,
        page=page,
    )

    return [cls(**technology.model_dump()) for technology in search_results]