Granular query processing through planar data model

Abstract

One embodiment of the present invention proposes a technique for processing queries of a lifecycle evaluation database. The technique includes searching, in one or more hierarchies included in a lifecycle evaluation database, a first set of data nodes that match a first set of parameters included in a query, wherein the first set of parameters includes a set of primary data associated with an entity. The technique further includes calculating a first set of emissions associated with the first set of data nodes based on a first set of functional units included in the first set of data nodes. The technique further includes aggregating the first set of emissions into a result of the query and causing the result to be output in response to the query.

Description

[0001] Cross - Reference to Related Applications

[0002] This application claims the benefit of U.S. Provisional Application No. 63 / 398,734, filed on Aug. 17, 2022, entitled "LIFECYCLE ASSESSMENT SYSTEM UTILIZING A PLANAR DATA ARCHITECTURE". The subject matter of this application is hereby incorporated by reference in its entirety. TECHNICAL FIELD

[0003] Embodiments of the present disclosure generally relate to databases and query processing, and more particularly, to granular query processing via a flat data model. BACKGROUND ART

[0004] Life cycle assessment (LCA) is a framework for evaluating the environmental impacts of products, services, processes, organizations, and / or other entities over the life cycle of the entity. For example, LCA can be used to estimate pollutant emissions, water use, land use change, toxicity, resource depletion, acidification, ozone layer depletion, climate change impacts, and / or other types of environmental impacts associated with the extraction and processing of raw materials, energy creation, energy consumption, transportation, marketing or advertising, use and retail, travel, and / or end-of-life disposal of the entity. The results of the LCA can then be used to improve product development and research, supply chain management and procurement, strategic management, and / or other types of decision-making and actions associated with the entity.

[0005] LCA studies are typically conducted by LCA experts using specialized LCA software tools and LCA databases that contain environmental data related to various processes and materials. LCA experts typically follow a systematic and standardized sequence of steps, starting with the "goal and scope definition" step, which establishes the purpose, breadth, depth, and boundaries of the LCA study. Next, the LCA expert performs the "life cycle inventory" step, which involves collecting data related to the inputs (e.g., raw materials and energy) and outputs (e.g., emissions and waste) within the life cycle of the entity under discussion. This data forms the key to the assessment and is typically collected from a variety of sources, including direct measurements, literature, and LCA databases. Subsequently, the LCA expert uses the LCA tool to perform the "life cycle impact assessment" step, which aggregates and / or transforms the data into environmental impacts. Finally, the LCA expert conducts the "interpretation" step, which involves evaluating and validating the results, drawing conclusions, and providing recommendations for improving environmental impacts.

[0006] However, current LCA tools and databases often lack granularity and specificity, which can negatively impact the accuracy of the results. For example, inaccurate and / or incomplete data from LCA databases may cause LCA tools to calculate inaccurate emissions for a given entity. These inaccurate emissions may prevent LCA tools from identifying "hotspots" within the entity's life cycle that contribute more to emissions, energy consumption, and / or other environmental impacts. LCA studies may also inaccurately identify certain parts of the life cycle as hotspots that do not significantly contribute to the entity's environmental impact. In another example, inaccurate and / or incomplete data may cause LCA tools to generate results that indicate the environmental impact of a first process is lower than that of a second process, when in fact the environmental impact of the first process is higher than that of the second process. Decisions or actions that rely on these results may prioritize the use of the first process over the second process, resulting in an unexpected increase in environmental impact.

[0007] Newer LCA tools provide user interfaces that allow non-expert users to conduct LCA studies by inputting data and / or measurements related to different stages of the life cycles of various types of entities. However, these LCA tools operate using a predefined and rigid workflow and require certain data points to be provided in order to evaluate and assess the necessary environmental impacts. Thus, these LCA tools may lack the ability to perform an LCA on life cycles represented with different quantities, types, and / or granularities of data.

[0008] As previously mentioned, there is a need in the art for more effective techniques for performing LCA. Summary of the Invention

[0009] One embodiment of the present invention presents a technique for processing queries of a life cycle assessment database. The technique includes: searching for a first set of data nodes that match a first set of parameters included in the query within one or more hierarchies included in the life cycle assessment database, where the first set of parameters includes a set of primary data associated with an entity. The technique further includes: calculating a first set of emissions associated with the first set of data nodes based on a first set of functional units included in the first set of data nodes. The technique further includes: aggregating the first set of emissions into the result of the query and causing the result to be output in response to the query.

[0010] Relative to the prior art, one technical advantage of the disclosed technology is the ability to determine the environmental impact associated with the life cycle of an entity without requiring specific inputs, outputs, and / or measurement results within the life cycle of the entity. Thus, compared to conventional LCA tools that operate using predefined workflows and require the specification of certain data points, the disclosed technology can be used to define and execute LCA queries with greater granularity, flexibility, and efficiency. Another technical advantage of the disclosed technology is the ability to automate LCA by using search, similarity comparison, aggregation, and / or computational processing queries that utilize a database with a flat data model. These technical advantages provide one or more technical improvements over prior art methods. BRIEF DESCRIPTION OF THE DRAWINGS

[0011] To understand the above features of the various embodiments in detail, the inventive concepts outlined above briefly may be described in more detail with reference to the various embodiments, some of which are illustrated in the drawings. However, it should be noted that the drawings only illustrate typical embodiments of the inventive concepts and should not be considered to limit the scope in any way, and there are other equally effective embodiments.

[0012] Figure 1 Illustrates a computing device configured to implement one or more aspects of the various embodiments.

[0013] Figure 2 is according to the various embodiments Figure 1 a more detailed illustration of the database and the evaluation engine.

[0014] Figure 3 Illustrates an example schema associated with the Figure 2 ontology plane according to the various embodiments.

[0015] Figure 4A Illustrates according to the various embodiments Figure 1 how the evaluation engine processes queries.

[0016] Figure 4B Illustrates according to the various embodiments Figure 1 how the evaluation engine matches an unknown data node with a set of similar data nodes.

[0017] Figure 5 is a flowchart of method steps for processing queries of a life cycle assessment database according to the various embodiments. DETAILED DESCRIPTION

[0018] In the following description, numerous specific details are set forth to provide a more thorough understanding of the various embodiments. However, those skilled in the art will appreciate that the inventive concepts may be practiced without one or more of these specific details.

[0019] System Overview

[0020] Figure 1 Shown is a computing device 100 configured to implement one or more aspects of the various embodiments. In one embodiment, the computing device 100 includes a desktop computer, a laptop computer, a smart phone, a personal digital assistant (PDA), a tablet computer, or any other type of computing device configured to receive input, process data, and optionally display images, and suitable for practicing one or more embodiments. The computing device 100 is configured to run a database 122 and an evaluation engine 124 residing in a memory 116.

[0021] Note that the computing devices described herein are illustrative, and any other technically feasible configurations fall within the scope of the present disclosure. For example, multiple instances of the database 122 and the evaluation engine 124 may be executed on a set of nodes in a distributed and / or cloud computing system to implement the functions of the computing device 100. In another example, the database 122 and the evaluation engine 124 may be executed on various hardware sets, device types, or environments to adapt the database 122 and / or the evaluation engine 124 to different use cases or applications. In a third example, the database 122 and the evaluation engine 124 may be executed on different computing devices and / or different sets of computing devices.

[0022] In one embodiment, the computing device 100 includes, but is not limited to, an interconnect (bus) 112 connecting one or more processors 102, an input / output (I / O) device interface 104 coupled to one or more input / output (I / O) devices 108, a memory 116, a storage 114, and a network interface 106. The one or more processors 102 may be any suitable processor implemented as a central processing unit (CPU), a graphics processing unit (GPU), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), an artificial intelligence (AI) accelerator, any other type of processing unit, or a combination of different processing units, such as a CPU configured to operate in cooperation with a GPU. Generally, the one or more processors 102 may be any technically feasible hardware unit capable of processing data and / or executing software applications. Additionally, in the context of the present disclosure, the computing elements shown in the computing device 100 may correspond to a physical computing system (e.g., a system in a data center) or may be virtual computing instances executed in a computing cloud.

[0023] The I / O device 108 includes devices capable of providing input, such as a keyboard, a mouse, a touch screen, etc., and devices capable of providing output, such as a display device. In addition, the I / O device 108 may include devices capable of receiving input and providing output, such as a touch screen, a Universal Serial Bus (USB) port, etc. The I / O device 108 may be configured to receive various types of input from an end user (e.g., a designer) of the computing device 100 and also provide various types of output to the end user of the computing device 100, such as a displayed digital image or digital video or text. In some embodiments, one or more I / O devices 108 are configured to couple the computing device 100 to the network 110.

[0024] The network 110 is any technically feasible type of communication network that allows data to be exchanged between the computing device 100 and an external entity or device (e.g., a web server or another networked computing device). For example, the network 110 may include a Wide Area Network (WAN), a Local Area Network (LAN), a wireless (WiFi) network, and / or the Internet, etc.

[0025] The storage 114 includes non-volatile storage for applications and data and may include fixed or removable disk drives, flash devices, and CD-ROM, DVD-ROM, Blu-Ray, HD-DVD, or other magnetic, optical, or solid-state storage devices. The database 122 and the evaluation engine 124 may be stored in the storage 114 and loaded into the memory 116 when executed.

[0026] The memory 116 includes Random Access Memory (RAM) modules, flash memory cells, or any other type of memory cells or a combination thereof. One or more processors 102, the I / O device interface 104, and the network interface 106 are configured to read data from the memory 116 and write data to the memory 116. The memory 116 includes various software programs executable by one or more processors 102 and application data associated with the software programs, including the database 122 and the evaluation engine 124.

[0027] In some embodiments, the database 122 stores life cycle assessment (LCA) data using a flat data model that includes multiple interconnected planes. The flat data model includes a data plane that stores data nodes representing products, processes, emissions, consumptions, and / or other entities used to perform an LCA. The data nodes can be organized in trees and / or other hierarchical data structures to represent dependencies and / or relationships between or among the corresponding entities. The flat data model also includes a separate ontology plane that stores metadata associated with the data nodes in the data plane. The metadata includes (but is not limited to) sources, time ranges, locations, classes, and / or attributes associated with the data in the data nodes. The ontology plane and the data plane are interconnected to allow emissions, consumptions, productions, and / or other quantities associated with entities to be aggregated, correlated, compared, and / or otherwise used to evaluate the environmental impacts associated with the entities.

[0028] The assessment engine 124 includes functionality to perform an LCA by evaluating queries to the database 122. Each query can be used to analyze the environmental impacts of products, processes, services, organizations, and / or another entity. To process a query, the assessment engine 124 uses the metadata stored in the ontology plane to match the parameters of the query to the data nodes in the data plane. The assessment engine 124 then calculates emissions, consumptions, productions, wastes, and / or other types of impact data associated with the entity by traversing the paths associated with the matching data nodes in the data plane and aggregating, scaling, and / or otherwise transforming the functional units stored in the matching data nodes. The operations of the database 122 and the assessment engine 124 will be described in further detail below.

[0029] Granular Query Processing via the Flat Data Model

[0030] Figure 2 is according to various embodiments Figure 1 is a more detailed illustration of the database 122 and the assessment engine 124 in. As described above, the database 122 includes a data plane 202 and an ontology plane 204. The data plane 204 stores LCA data points in data nodes 222(1)-222(3) and 222(N)-222(N + 2) (each node is referred to herein individually as data node 222), which are hierarchically organized in multiple trees 224(1)-224(X) (each tree is referred to herein individually as tree 224).

[0031] Within the data plane 202, the data nodes 222 store data that can be used to perform LCA. For example, each tree 224 of the data nodes 222 within the data plane 202 can store data from different data sets of secondary LCA data. Each data set can be obtained from a separate source, such as (but not limited to) LCA papers, LCA databases, energy grid portfolio databases, LCA studies, and / or surveys.

[0032] One type of data node 222 represents consumables that do not have direct emissions or product consumption, such as (but not limited to) products, by-products of processes, and / or items or materials used in product production. Another type of data node 222 represents a process that includes a series of steps for achieving a certain result, such as (but not limited to) producing physical objects, machines, textiles, goods, food, beverages, pharmaceuticals, ingredients, services, and / or experiences.

[0033] Within the tree 224, data nodes 222 representing processes can be connected to other data nodes 222 via edges representing various types of relationships. An edge from a first data node 222 to a second data node 222 can represent a consumption relationship, where the first data node 222 requires a certain quantity of the second data node 222. Since the consumption relationship represents the dependency of the first data node 222 on the second data node 222, the consumption relationship can be used to reason about the impact of a change in one data node 222 on another data node 222. For example, a shortage of a product, material, and / or another consumable represented by the second data node 222 may result in a decrease in different products produced by the process represented by the first data node 222. In another example, an increase in the demand for a product produced by the process represented by the first data node 222 may result in an increase in the consumption of the consumable represented by the second data node 222.

[0034] An edge from a first data node 222 to a second data node 222 within a given tree 224 can alternatively represent a production relationship, where the first data node 222 produces a certain quantity of the second data node 222. For example, a production relationship between a process represented by the first data node 222 and a product represented by the second data node 222 can indicate that the product is produced by the process.

[0035] A given data node 222 representing a process also includes one or more emission relationships representing the emissions of the process. Each emission relationship can be represented as an edge from the data node 222 to a different data node 222 and / or another element within the data plane 202 that represents a gas and / or another type of emission.

[0036] An example tree 224 of the data nodes 222 in the data plane 202 includes the following:

[0037] Cotton planting - [:consumption] -> Cotton seeds <- [:production] - Cotton gin - [:consumption] -> Cotton - [:consumption] -> Cotton planting. In the above example, the first data node 222 representing the "cotton planting" process has a consumption relationship with the second data node 222 representing the "cotton seeds" consumable. The third data node 222 representing the "cotton gin" process has a production relationship with the second data node 222 and a consumption relationship with the fourth data node 222 representing the "cotton" consumable. The fourth data node 222 also has a consumption relationship with the first data node 222 representing the "cotton planting" process. The "cotton planting" and "cotton gin" processes respectively represented by the first data node 222 and the third data node 222 may also include an emission relationship (not shown) representing the emission of various gases and / or by-products.

[0038] In some embodiments, the data nodes 222 and / or relationships in the data plane 202 are associated with functional units that can be used to quantify, characterize, and / or compare corresponding processes, consumptions, productions, and / or emissions. Each functional unit includes a unit and a numerical value representing the quantity of that unit. For example, the functional unit of vehicle emissions can be defined as traveling 1 kilometer.

[0039] Each type of functional unit can also be associated with a reference unit for normalization and / or standardization between different functional units of that type. For example, the reference unit for distance can be set to meters, such that consumptions specified in another distance unit (e.g., kilometers, centimeters, feet, miles, etc.) will be converted to meters. Additionally, mathematical operations involving two functional units with different reference units may return an error and / or failure.

[0040] Within the data plane 202, various types of probability distributions can be used to represent functional units. One type of probability distribution can include a triangular distribution with a minimum value, a maximum value, and a peak (i.e., most likely) value. Another type of probability distribution can include a rectangular or uniform distribution, where all values within the range between the minimum and maximum values have equal probability. Additional types of probability distributions can include (but are not limited to) normal distribution, lognormal distribution, binomial distribution, Poisson distribution, exponential distribution, and / or other types of distributions that can be used to represent different types of LCA functional units. This distribution-based representation of functional units allows for the description of corresponding emissions, consumptions, productions, and / or data nodes 222 with quantified uncertainty, which can in turn be used to determine the sources of uncertainty and / or techniques for reducing uncertainty in a given LCA and / or model.

[0041] The given data node 222 and / or relationship can also be associated with a multi-dimensional functional unit that includes multiple dimensions. For example, a delivery characterized using mass, volume, and distance can be represented using a one-dimensional functional unit (e.g., ton-kilometer). While such a one-dimensional representation can be used to model the environmental impact for a linear system, the same representation cannot produce accurate results for a non-linear system. Instead, the delivery can be represented using a single data node 222 with a multi-dimensional functional unit (1 kg, 0.5 L, 3 MJ) and a certain emission value.

[0042] One or more functional units can also be defined as non-standard or "custom" units. For example, custom units used by a washing machine can include "revolutions per minute", "washing temperature", and "number of washes". In another example, custom units for box dimensions can include width, height, and depth, each defined using centimeters. The custom units can then be used to normalize the functional unit of a given data node 222 specified in centimeters, with the consumption specified in meters.

[0043] The given data node 222 and / or relationship can be associated with a "probability" functional unit that specifies an explicit probability of a certain outcome. For example, a process for manufacturing semiconductor wafers can include a 20% probability of producing a defective wafer. In another example, a functional unit for a laundry washing process can include a 60% probability of using an electric dryer during the process. The probability is applied to the result of a given LCA assessment (e.g., emission calculation), rather than being combined with other functional units used to generate the result.

[0044] In one or more embodiments, a consumption relationship is associated with a transformation function that receives a first functional unit as input and generates a second functional unit as output. The transformation function can be used to specify a non-linear consumption relationship. For example, the transformation function can model the non-linear relationship between the distance traveled by an air freight flight and the amount of fuel consumed by the flight by calculating a higher fuel consumption per unit distance during takeoff and climb and a lower fuel consumption per unit distance during cruise.

[0045] The consumption relationship can also or alternatively specify an "unknown" consumption where specific data is lacking. For example, a process represented by a first data node 222 can have a consumption relationship that specifies a certain amount of power consumption from an unknown power source. The consumption relationship can be represented by a connection between the first data node 222 and an "unknown" data node 222 that represents the unknown power source.

[0046] The ontology plane 204 stores metadata associated with each data node 222. As Figure 2As shown, the ontology plane 204 includes nodes and / or elements representing instances 206, locations 208, time ranges 210, sources 212, classes 214, and attributes 216 associated with data nodes 222.

[0047] The instance 206 corresponds to a metadata-based representation of each data node 222 in the data plane 202. More specifically, each data node 222 in the data plane 202 can be associated with a unique instance in the ontology plane 204. Each instance node also includes one or more locations 208, time ranges 210, sources 212, classes 214, and / or attributes 216 that describe the corresponding data node 222.

[0048] The location 208 includes the region of the corresponding data node 222 and / or other geographical descriptors. For example, each instance can specify a location for the corresponding data node 222. Additionally, the ontology plane 204 can store a tree and / or another type of hierarchy in which the locations 208 are organized. For example, the hierarchy can include a root node with the geographical identifier "world". This root node can include child nodes with geographical identifiers for different continents. Each node representing a continent can include child nodes representing different countries within that continent, and each node representing a country can include child nodes representing different states, provinces, and / or regions within that country. Thus, a given parent node in the hierarchy can represent a region that partially or fully encompasses the regions represented by all of its child nodes. To facilitate understanding and / or determination of similarities and / or relationships between data nodes 222, a single location assigned to multiple instances 206 can be indicated by having each instance point to the node representing that location in the hierarchy.

[0049] The time range 210 represents the range of time during which the data associated with the instance 206 is assumed to be correct. For example, each instance can include a time range specifying a "from" timestamp and a "until" timestamp. The "from" and "until" timestamps can be set to the same value to describe an instant in time. Alternatively, the "from" and "until" timestamps can be set to different values to indicate the period during which the data is considered valid (e.g., was collected, reported in a research paper, etc.).

[0050] The source 212 represents the source of the data in the data node 222. For example, each source can specify the author of the data, the location of the data (e.g., a Uniform Resource Locator (URL), a citation, etc.), and / or additional information associated with the source.

[0051] Class 214 forms a shared ontology on the entities represented by data nodes 222. More specifically, Class 214 is organized under one or more ontology trees, which can be used to determine similarities, differences, and / or other semantic relationships between the corresponding entities. For example, the Class 214 representing a process can be stored in one ontology tree, while the Class 214 representing a consumable can be stored in a different ontology tree. Each class can include a name and one or more aliases having the same semantic meaning as the name.

[0052] Each ontology tree can be constructed according to the "similarity principle", where a subclass shares the same essence with the corresponding parent class and represents a subset of the parent class. For example, the class "cotton T-shirt" can be a subclass of the class "T-shirt", the class "T-shirt" can be a subclass of the class "shirt", the class "shirt" can be a subclass of the class "wearable clothing", and the class "wearable clothing" can be a subclass of the class "textile".

[0053] Each ontology tree can also or alternatively be constructed according to the "specificity principle", where a subclass differs from all its direct and indirect parent classes in at least one attribute that is more specific than the corresponding attribute associated with the parent class. Continuing the above example, the class "cotton T-shirt" will be associated with a specific fabric that differentiates it from other fabrics that can be used to make T-shirts.

[0054] Each ontology tree can also or alternatively be constructed according to the "opposition principle", where sibling classes sharing the same direct parent class are at least partially incompatible and / or opposed to each other. Continuing the above example, the class "cotton T-shirt" can have sibling classes such as "polyester T-shirt", "wool T-shirt", and / or "cotton, polyester, and wool blend T-shirt".

[0055] Each ontology tree can also or alternatively be constructed according to the "unique semantic axis principle", where each class is found on a unique path through the ontology tree and appears only once in a given ontology tree. In an embodiment where processes and consumables are stored in separate ontology trees, a given class can appear in both ontology trees, but only once in each tree.

[0056] Attribute 216 describes the variations of individual instances 206 and / or individual classes 214. For example, the attributes 216 associated with the class "cotton T-shirt" can include (but are not limited to) size, color, brand, whether the T-shirt is made of organic cotton, whether the T-shirt is waterproof, whether the T-shirt is for pregnant women, and / or the way the T-shirt is made (e.g., handmade or machine-made).

[0057] Each attribute may include zero or more dimensions and continuous or discrete values for each dimension. For example, a zero-dimensional attribute of maternity clothing may be represented by a boolean value indicating whether a piece of clothing is considered maternity wear. A one-dimensional attribute of clothing size may include discrete values such as small, medium, or large. A multi-dimensional attribute of top size may include dimensions such as arm length, torso circumference, and chest circumference. Each of these dimensions may be specified using continuous values spanning a certain range (e.g., from a minimum length or circumference to a maximum length or circumference).

[0058] In some embodiments, the attribute 216 and the custom functional unit specify values used in different contexts. For example, the attribute 216 may be used to distinguish different variants and / or different instances 206 of class 214, while the custom functional unit may be used to store values that have a direct impact on the consumption, production, emissions, and / or other metrics calculated in the LCA.

[0059] Continuous attribute values may be related to emissions, functional units, categories of consumption relationships, and / or the ontology of consumption relationships. The attributes 216 may also be organized into groups, where the attributes 216 within a given group are mutually exclusive. For example, different clothing size systems may be stored under the same group of attributes so that a given clothing category can be associated with a single size from one size system.

[0060] The attribute 216 may also be verified in other ways. For example, the value assigned to a discrete attribute may be verified to be one of a set of possible attribute values for the discrete attribute. In another example, the value assigned to a continuous attribute may be verified to lie within the valid range of the continuous attribute. In a third example, one or more values assigned to an attribute may be verified to describe all dimensions of the attribute.

[0061] Figure 3 An example pattern associated with the ontology plane 204 according to various embodiments is shown Figure 2 is shown. As Figure 3 shown, the pattern includes nodes 302 representing instances. The nodes 302 include a "HAS_TIMEFRAME" relationship with another node 304 specifying the time frame of the instance. The nodes 302 also include a "HAS_SOURCE" relationship with a third node 306 specifying the source of the data associated with the instance.

[0062] The nodes 302 include an "IN" relationship with a fourth node 318 specifying the location of the data associated with the instance. The nodes 318 and a fifth node 322 specifying another location also include an "IN" relationship with a sixth node 320 specifying a third location, thereby indicating that the third location represented by the node 320 contains the locations represented by the nodes 318 and 322.

[0063] Node 302 includes an "IS" relationship with a seventh node 308 of a specified instance's class. Node 308 and an eighth node 312 representing another class also have an "IS" relationship with a ninth node 310 representing a third class, indicating that the classes represented by nodes 308 and 312 are subclasses of the class represented by node 310.

[0064] Node 308 includes a "HAS_ATTRIBUTE" relationship with a tenth node 314 representing an attribute. Node 302 similarly includes a "HAS_ATTRIBUTE" relationship with an eleventh node 316 representing a different attribute. The attribute represented by node 314 is used to modify the class represented by node 308, while the attribute represented by node 316 is used to modify the instance represented by node 302.

[0065] Returning to Figure 2 the discussion, the evaluation engine 124 uses the data nodes 222 in the data plane 202 stored in the database 122 and the metadata in the ontology plane 204 stored in the database 122 to process the query 232. As Figure 2 shown, the query 232 specifies one or more classes 242 and / or one or more constraints 244.

[0066] The classes 242 identify one or more entities for which to calculate their emissions, consumption, production, and / or other environmental impacts. For example, the classes 242 may include names and / or concepts to match one or more classes 214 in the ontology plane 204.

[0067] The constraints 244 include additional parameters that can be used to modify the assumptions and / or values associated with the LCA models and / or components stored in the database 122. More specifically, the constraints 244 may include primary data from sources external to the database 122 (e.g., the system querying the database 122). This primary data can be used to modify the location 208, time range 210, source 212, attribute 216, functional unit, and / or other data or metadata associated with the data node 222, the relationships associated with the data node 222, the instances 206 corresponding to the data node 222, production, emissions, and / or other components of the database 122. For example, each constraint may include a unit, a value of the unit (e.g., discrete value, continuous value, multi-dimensional value, etc.), and / or the type of node or record in the database 122 that the constraint pertains to (e.g., class 214, process, emission, consumption, etc.). Thus, constraints can be used to specify that a product includes a blend of 80% cotton and 20% polyester, contains cotton, contains organic cotton, contains cotton from a certain country, is manufactured in a certain country, includes a total of 20 grams of cotton, has a total weight of 200 grams, has a total precursor emission of 1 kg CO2e, and / or includes cotton yarn produced by ring spinning technology.

[0068] In some embodiments, the constraint 244 includes input constraints, location constraints, time constraints, and / or emission constraints. Input constraints can be used to change the consumption of a data node. A given input constraint defines a subject and a list of inputs, where each input can be used to add, delete, or replace consumption.

[0069] For example, the input constraint can include the following definitions:

[0070]

[0071]

[0072] In the above definition, the input constraint is defined as a struct data type. The struct includes a "SubjectSpecifier" that specifies the subject to which the input constraint belongs (e.g., the subject of consumption). The input constraint struct also includes a list of inputs. Each input is also defined as a struct and includes a "ClassSpecifier", a functional unit, and a set of boolean values that indicate whether the input is used to replace, delete, or add consumption. When the boolean value indicates that consumption is to be replaced, the class of the subject can be replaced with a different class associated with the "ReplaceSubject" field.

[0073] Location constraints can be used to change the location associated with a given data node 222. For example, location constraints can be used to set the location to a different region, a more specific region, and / or a less specific region.

[0074] Time constraints can be used to update the time of a given data node 222. For example, time constraints can specify a start time, an end time, and / or a time instance associated with the data node.

[0075] Emission constraints can be used to override the emissions of a given data node 222 and the dependencies of the data node. For example, the emission constraint can include the following definitions:

[0076]

[0077] In the above definition, the emission constraint is defined as a struct data type. The struct includes a "SubjectSpecifier" that specifies the subject to which the emission constraint belongs (e.g., the data node whose emissions are to be overridden). The emission constraint struct also includes a list of emissions.

[0078] Example emission constraints in the list can include the following representations:

[0079]

[0080]

[0081] This representation specifies the class "Example" to which the emission constraint applies, as well as the "CO2e" gas and the emission value "12". Thus, this emission constraint indicates that the "CO2e" emissions of data nodes with the class "Example" should be overridden by the value 12.

[0082] In some embodiments, a flexible query language is used to specify classes 242 and / or constraints 244 within query 232. This query language allows complex constraints 244 to be defined for various queries and / or use cases.

[0083] For example, the query language may include the following specifications:

[0084]

[0085]

[0086] In the above definition, a given query 232 includes a "Specifier" property that identifies the criteria associated with the query, as described by the "Specifier" type. The "Specifier" includes an "Is" array that describes one or more classes representing the entity, an "In" array that describes one or more locations of the entity, an "At" field that describes the time or time range associated with the entity, and a functional unit. The query also includes a list of constraints 244. Each constraint in the array can be described by the "Constraint" type.

[0087] The above definition indicates that a given constraint can represent an "Input" constraint, a "Process" constraint, an "Emission" constraint, and / or another type of constraint. Each type of constraint includes a property named "ForPath" that is a locator for the "path" within the tree (e.g., tree 224) to which the constraint should be applied. For example, a constraint to change the power consumption of the process of assembling a T-shirt may include a path that includes the class named "T-shirt" and the class named "Assembly":

[0088] {segment: [{class: ["T-shirt"]}, {class: ["Assembly"]}]}

[0089] Each type of constraint may also or alternatively include a "For" property that specifies one or more classes 214 to which the constraint should be applied.

[0090] The above definition also indicates that each type of constraint is associated with a different specifier. The "Emission" constraint includes an "EmissionSpecifier" which indicates the type of gas emitted and the functional unit used to measure the emission. The "Input" and "Process" constraints include the same "Specifier" as the query. The "Specifier" includes multiple arrays that describe the identity (e.g., class), location, time, functional unit, and / or other properties associated with the corresponding entity and / or constraint.

[0091] The above definition also indicates that the functional unit includes an array of measurement units with associated values. Each element in the array includes a "Unit" that describes the type or name of the unit and a "Value" that specifies the numerical value of the unit.

[0092] An example query 232 using the above specification includes the following:

[0093] Specifier:

[0094]

[0095]

[0096] The above example query includes a "Specifier" which indicates the class of "cotton T-shirts" at the location "China" at the time "2020-01-01". The query also includes a functional unit which specifies the unit as grams and the value as 200. The query also includes five constraints. The first constraint is an input constraint for consumption associated with the "cotton T-shirts" data node 222. The first constraint indicates that the consumption is related to one or more consumables represented by "organic cotton", "cotton", and / or "material". The first constraint also includes a fractional functional unit of 0.8 which is multiplied by the functional unit associated with the consumable.

[0097] The second constraint is an input constraint for consumption associated with the "garment manufacturing" data node 222. The second constraint indicates that the consumption is related to the consumable "electricity" with two functional units of 1000 kWh and one year respectively.

[0098] The third constraint is a process constraint for the "cotton cultivation" data node 222. The third constraint specifies that the process represented by this data node has the location "India".

[0099] The fourth constraint is an emission constraint for emissions associated with the "cotton weaving" data node 222. The fourth constraint includes the gas "CO2e" and a functional unit of 1 kg for the emitted gas.

[0100] The fifth constraint is a process constraint for the "cotton yarn spinning" data node 222. The fifth constraint indicates that the process represented by this data node can be classified as "ring spinning" and / or "cotton yarn spinning".

[0101] As Figure 2 shown, the evaluation engine 124 executes the query 232 by creating virtual nodes included in a set of unknown nodes 238. The virtual nodes are stored in the memory and represent unknown consumption to be resolved using the database 122. The virtual nodes include the same properties as the query 232 (e.g., class 242 and constraint 244) and are identified as "query nodes" representing the query 232.

[0102] The evaluation engine 124 also matches the virtual nodes with a set of similar data nodes 240 in the database 122. In one or more embodiments, the similar data nodes 240 are determined by a similar node search technique that traverses one or more trees 224 of the data nodes 222 within the database 122 and / or searches within the one or more trees 224, as described in further detail below with respect to Figure 4A and Figure 4B Further described in detail.

[0103] The evaluation engine 124 uses the set of similar data nodes 240 to perform calculations 248 related to the query 232. For example, the evaluation engine 124 can calculate emissions, production, emissions, waste distribution, and / or other values representing the environmental impact of the entity represented by the query 232. During the calculation 248, the evaluation engine 124 can create additional unknown nodes 238 when encountering corresponding unknown consumption during the traversal to determine the similar data nodes 240. The evaluation engine 124 can also repeat the process of matching these unknown nodes 238 with the similar data nodes 240 and performing calculations 248 on these similar data nodes 240 until all unknown nodes 238 have been resolved to similar data nodes 240 with known consumption.

[0104] The evaluation engine 124 also performs an aggregation 250 of the calculations 248 associated with the similar data nodes 240 to generate the result 246 of the query 232. These results 246 can include a tree structure that represents the emission breakdown associated with the similar data nodes 240 selected during the processing of the query 232. These results 246 can also or alternatively include total emissions, production, waste distribution, and / or other values generated during the calculations 248 on the similar data nodes 240.

[0105] Figure 4A Illustrates how the evaluation engine 124 of Figure 1 handles queries according to various embodiments. As Figure 4A shown, the evaluation engine 124 executes by receiving a query (e.g.,Figure 2 The query starts with step 402 of 232). Next, the evaluation engine 124 performs step 404 of creating an unknown node representing the query. This unknown node can be stored in the memory and includes one or more classes, one or more constraints, and / or other parameters of the query. The unknown data node can represent unknown consumption and / or unknown emissions.

[0106] Then, the evaluation engine 124 performs step 406 of calculating the emissions of the current node, which corresponds to the unknown node created in step 404. To this end, the evaluation engine 124 performs step 408 of scaling the functional unit of the current node to match the current context of the query. Since the functional unit of the current node is the same as the functional unit associated with the current context of the query (i.e., the functional unit specified in the query), no scaling is required at this time.

[0107] Then, the evaluation engine 124 performs step 410 of determining whether the current node is unknown. This step 410 evaluates to true, so the evaluation engine 124 performs step 412 of applying the matcher constraints to the current node, where the current node is changed using the relevant constraints specified in the query. Then, the evaluation engine 124 performs step 414 of using the retrieved matcher constraints to find the most similar data node.

[0108] Figure 4B illustrates how the evaluation engine 124 of Figure 1 matches an unknown data node with a set of similar data nodes according to various embodiments. As Figure 4B shown, the matching process is initiated using step 414. Next, the evaluation engine 124 performs step 452 of matching the classes in the unknown data node with the data nodes 222 in the database 122. For example, the evaluation engine 124 can perform step 452 by searching for names and / or aliases in the data nodes 222 that exactly match, substantially match, and / or semantically match the classes specified in the query.

[0109] Then the evaluation engine 124 performs step 454 of matching the attributes in the unknown data node with the data nodes 222 in the database 122. For example, the evaluation engine 124 can perform step 454 by filtering the nodes retrieved in step 452 by attribute.

[0110] The evaluation engine 124 also performs step 456 to match the time in the unknown data node with the data node 222 in the database 122, and then performs step 458 to match the location in the unknown data node with the data node 222 in the database 122. In each of steps 456 and 458, the evaluation engine 124 can further filter the data node 222 determined in the previous step by the corresponding constraint value. If the matcher constraint does not specify an attribute, time, and / or location, the evaluation engine 124 can also omit steps 454, 456, and / or 458 accordingly.

[0111] Subsequently, the evaluation engine 124 performs step 460 to determine whether any matching data nodes are found. For example, if the class of a given data node 222 in the database 122 matches the class in the unknown data node and / or is a direct or indirect subclass of the class in the unknown data node, the evaluation engine 124 can determine that the data node is a match. If the location specified in a given data node 222 in the database 122 matches the location in the unknown data node and / or is a direct or indirect sub-location of the location in the unknown data node, the evaluation engine 124 can also or alternatively determine that the data node is a match. If the attribute associated with a given data node 222 in the database 122 matches the attribute specified in the unknown data node, the evaluation engine 124 can also or alternatively determine that the data node is a match. If no data node 222 in the database 122 matches the attribute in the unknown data node, the evaluation engine 124 can determine that all data nodes that match the class and location in the unknown data node are matching data nodes. If the time range in the data node is closest to the time specified in the unknown data node, the evaluation engine 124 can also or alternatively determine that the data node is a match.

[0112] If one or more matching data nodes are found, the evaluation engine 124 performs step 464 to return the matching data nodes. For example, the evaluation engine 124 may store the matching data nodes and the corresponding relationships in one or more in-memory data structures. The matching data nodes may be stored under the root node corresponding to the query node and correspond to one or more subtrees and / or paths in the tree 224. Each subtree and / or path may include one or more data nodes that match the class, location, property, and / or time specified in the unknown data node. Each subtree and / or path may also or alternatively include one or more data nodes whose class and / or location "indirectly" match the class and / or location specified in the unknown data node (e.g., data nodes whose class and / or location are direct or indirect subclasses of the class and / or location specified in the unknown data node). Each subtree and / or path may also or alternatively include additional data nodes that are dependencies (e.g., consumption, production, emissions, etc.) of data nodes that directly or indirectly match the class, location, property, and / or time specified in the unknown data node.

[0113] If no matching node is found, the evaluation engine 124 performs step 462 to match with the parent class and / or location associated with the unknown data node. For example, if the hierarchy of the location 208 in the ontology plane 204 includes the parent location of the location in the unknown data node, the evaluation engine 124 may change the location used to find the matching data node to the parent location of the location in the unknown data node. If the ontology tree of the class 214 in the ontology plane 204 includes the parent class of the class in the unknown data node, the evaluation engine 124 may also or alternatively change the class used to find the matching data node to the parent class of the class in the unknown data node.

[0114] Then, the evaluation engine 124 repeats steps 452, 454, 456, 458, and 460 using the parent class and / or location. The evaluation engine 124 may also repeat step 462 to further reduce the granularity associated with the match until a matching node is found. Then, the evaluation engine 124 may perform step 464 to return the matching data nodes.

[0115] Alternatively, if the evaluation engine 124 cannot find any matching data nodes and cannot further change the class and / or location used to find the matching data nodes, the evaluation engine 124 may return an error indicating that no matching node was found. This error may then be returned in response to the query instead of performing additional processing on the query.

[0116] Although the operations of the evaluation engine 124 matching a given data node with similar data nodes have been described above with respect to steps 452, 454, 456, 458, 460, 462, and 464, it is understood that the evaluation engine 124 can use other techniques to determine similar data nodes for a given unknown data node. For example, the evaluation engine 124 can calculate a similarity score between the unknown data node and some or all of the data nodes 222 in the database 122. A given similarity score between the unknown data node and another data node can include a weighted combination of similarity measures between the nature of this data node (e.g., class, attribute, time, location, etc.) and the corresponding nature of another data node. These similarity measures can include (but are not limited to) vector similarity between embeddings of the nature, measures of semantic similarity between the nature, measures of similarity between tokens and / or strings in the nature, binary values representing exact matches between the nature, and / or other measures calculated between the nature of the data node and the corresponding nature of other data nodes. The evaluation engine 124 can rank the data nodes 222 in descending order of similarity score and return a set of the highest-ranked data nodes 222 as the most similar nodes. In another example, the evaluation engine 124 can use clustering techniques and / or machine learning models to identify the most similar nodes based on the nature of the unknown data node and the corresponding nature of other data nodes. In a third example, the evaluation engine 124 can use one or more natures of the unknown data node as search terms and / or filters for other data nodes in the database 122.

[0117] Returning to Figure 4A the discussion of, after the evaluation engine 124 finds a set of similar nodes in step 414, the evaluation engine 124 performs step 416, scaling the attributes associated with the similar nodes. For example, the evaluation engine 124 can determine a scaling factor that can be used to convert the yarn density value specified in the attributes of the similar nodes to the yarn density value specified in the corresponding attributes of the unknown data node. Then, these scaling factors can be applied to the energy consumption and / or other calculations associated with the similar nodes.

[0118] Then, the evaluation engine 124 performs step 418, which iterates over the similar nodes and repeats steps 406, 408, and 410 for each similar data node. If the evaluation engine 124 determines at step 410 that the data node is not unknown, the evaluation engine 124 performs step 422, applying any relevant data node constraints specified in the query to this data node. Then, the evaluation engine 124 performs various types of calculations associated with this data node.

[0119] As Figure 4AAs shown, the evaluation engine 124 performs step 424 to calculate the consumption associated with the data node. For example, the evaluation engine 124 can calculate the emissions of all data nodes that have a consumption relationship with this data node. While calculating the consumption, if a transformation function is defined for a given consumption relationship, the evaluation engine 124 can also perform step 426 to run the transformation function on the functional unit associated with this consumption relationship. The evaluation engine 124 can also perform step 428 to scale the functional units obtained from steps 424 and 426 to match the current context of the query. Then, the evaluation engine 124 can perform step 430 to determine whether any consumption is unknown. If this step 430 evaluates to true, the evaluation engine 124 returns to step 412 so that each unknown consumption (such as represented by an unknown data node) can be matched with a similar data node with known consumption.

[0120] The evaluation engine 124 also performs step 432 to calculate the production associated with the data node. For example, the evaluation engine 124 can identify all data nodes that have a production relationship with this data node.

[0121] The evaluation engine 124 can also perform step 434 to calculate the product allocation associated with the production. In step 434, the evaluation engine 124 can assign an economic value to one or more data nodes that have a production relationship with this data node.

[0122] For example, the evaluation engine 124 can retrieve the associated economic value of each product of the process represented by this data node as a price from another data node. The evaluation engine 124 can use this economic value to allocate the emissions of this process among all products of this process so that the emissions allocated to a given product are proportional to the economic value of this product. The evaluation engine 124 can also or alternatively allocate the emissions of this process evenly among the products and / or allocate the emissions of this process based on another technology. After calculating the production and product allocation for the data node, the evaluation engine 124 can perform step 436 to scale the functional units obtained from steps 432 and 434 to match the current context of the query.

[0123] The evaluation engine 124 also performs step 438 to determine whether the production associated with the data node has a negative economic value. Continuing with the above example, when a product is considered a waste product of the process represented by the data node, a negative economic value (e.g., value -1) can be assigned to the production relationship between this data node and another data node representing the product.

[0124] When the production associated with a data node has a negative economic value, the evaluation engine 124 performs step 440 to calculate the waste allocation of the product. In step 440, the evaluation engine 124 can allocate the emissions of any process that consumes the product to the data node representing the production process of the product.

[0125] Finally, the evaluation engine 124 can perform step 442 to calculate the emissions of the data node. For example, the evaluation engine 124 can aggregate the emissions of the data node and all data nodes that have a production or consumption relationship with that data node. Then, the evaluation engine 124 can return to step 406 to repeat the process for additional data nodes.

[0126] After all unknown data nodes have been resolved into similar data nodes with known emissions and / or consumption, and emissions have been calculated for these data nodes, the evaluation engine 124 performs step 444 to report the results including these emissions. For example, the evaluation engine 124 can aggregate the calculations associated with multiple data nodes into the total emissions, consumption, production, and / or other values of the entity represented by the query. The evaluation engine 124 can also or alternatively calculate a breakdown of the total value into the contributions of the individual data nodes that match the entity represented by the query.

[0127] The following example queries can be used to illustrate Figure 4A and Figure 4B the operation of the evaluation engine 124 in

[0128]

[0129]

[0130] The above query includes a specifier that specifies two classes, "Fuel Combustion" and "Diesel Combustion". The specifier also includes an attribute named "Terrain" with a value of "Urban" and a functional unit with a unit of liters and a value of 2.5. The query also includes a time constraint that specifies the time as "2022-01-01T20:00:00Z" for the "Fuel" class. Thus, the example query can be used to determine the environmental impact of the entity represented by the combustion of 2.5 liters of diesel in an urban terrain, given the production time of the fuel as 2022.

[0131] After receiving the query in step 402, the evaluation engine 124 executes step 404 to create an in-memory virtual unknown data node representing the query. The unknown data node corresponds to a query node that includes the same properties as the query (e.g., class, attribute, functional unit, time constraint), and indicates that the consumption and / or emissions associated with the entity are unknown.

[0132] The evaluation engine 124 executes step 406 to begin the process of calculating the emissions of the newly created "current" node. Specifically, the evaluation engine 124 executes step 408 to scale the functional unit of the current node to the functional unit specified in the query. Since the functional unit of the current node is the same as the functional unit specified in the query, the functional unit of the current node is not changed by step 406.

[0133] The evaluation engine 124 executes step 410 to determine whether the current node is unknown. Since the evaluation in step 410 is true, the evaluation engine 124 executes step 412 to apply the matcher constraints in the query to the unknown data node. To execute step 412, the evaluation engine 124 iterates over the constraints and determines whether a "For" field is defined in each constraint. The evaluation engine 124 checks whether the class of the current unknown data node matches the class specification in the "For" field. If a match is found, the evaluation engine 124 applies the constraint. Since the time constraint specified in the query only includes a "ForPath" field, the constraint related to the "For" field is not applied.

[0134] Next, the evaluation engine 124 checks whether each constraint includes a "ForPath" field. If a given constraint includes a "ForPath" field, the evaluation engine 124 determines whether the path defined in the "ForPath" field matches the current context associated with the unknown data node. In this example, the time constraint includes a "ForPath" field that specifies a "Segment" (e.g., a subtree in the data plane 202) that includes the class name "Fuel". The evaluation engine 124 determines whether the current unknown node matches the segment by determining whether the class of the current unknown node matches the class name "Fuel". If a match is found, the evaluation engine 124 applies the constraint to the current unknown data node. Since the current unknown node has a "Diesel combustion" class, no match is found, and therefore the constraint is ignored.

[0135] Then, the evaluation engine 124 performs step 414 to match the current node with the most similar node in the database 122. During this matching process, the evaluation engine 124 performs step 452 to search the database 122 for nodes that match the "Diesel combustion" class or any subclass of the "Diesel combustion" class. The evaluation engine 124 determines (as a result of the search) that each of the two subclasses "1,600cc engine diesel operation" and "2,000cc engine diesel operation" is assigned to three data nodes 222, and these three data nodes include attributes representing different terrains "countryside", "city", and "mountainous area". Since the search returns similar nodes, the evaluation engine 124 does not ascend to the parent class of the "Diesel combustion" class to find a less accurate match. Additionally, since all matches are equidistant from the desired class (i.e., all matching nodes are one level away from the "Diesel combustion" class), all classes of the matching data nodes are considered equally relevant. Therefore, no additional filtering of the matching nodes is performed using classes.

[0136] Next, the evaluation engine 124 performs step 454 to match the attributes of the matching data nodes with the attributes in the current node. For each of the six matching data nodes returned by the search, the evaluation engine 124 calculates a score that represents the degree to which the attributes associated with that data node match the attributes of the current unknown data node. Here, the evaluation engine 124 calculates the score based on the similarity between the terrain attribute of each returned data node and the "city" terrain attribute of the current unknown data node. In this example, the evaluation engine 124 calculates non-zero scores for two data nodes that have the same "city" terrain attribute as the current node and belong to the "1,600cc engine diesel operation" and "2,000cc engine diesel operation" classes respectively. The evaluation engine 124 also calculates a score of 0 for the remaining four data nodes returned in the search.

[0137] The evaluation engine 124 performs step 456 to match the time ranges of the two matching data nodes with the time associated with the unknown data node. Since the unknown data node does not specify a time or time range, the two matching data nodes are considered equally good matches in step 456.

[0138] The evaluation engine 124 also performs step 458 to match the locations of the two matching data nodes with the location associated with the unknown data node. Since the unknown data node does not specify a location, the two matching data nodes are considered equally good matches in step 458.

[0139] The evaluation engine 124 performs step 460 to determine that two data nodes with the "city" terrain attribute and the classes of "1,600 cc engine diesel operation" and "2,000 cc engine diesel operation" respectively are both a match. Then, the evaluation engine 124 performs step 464 to return the two matching nodes.

[0140] After returning the two matching data nodes in step 414, the evaluation engine 124 performs step 416 to scale the attributes of the returned data nodes. Since these data nodes do not include numerical attributes that can be scaled, this step 416 is skipped.

[0141] Then the evaluation engine 124 performs step 418 to iterate over the two matching data nodes. Starting from step 406, the evaluation engine 124 calculates the emissions of the data node with the class of "1,600 cc engine diesel operation". The evaluation engine 124 continues to step 408 to scale the functional unit of this data node to the 2.5-liter functional unit of the query. In this example, the functional unit of the "1,600 cc engine diesel operation" data node is set to 1 liter. Therefore, the evaluation engine 124 calculates the scaling factor as the ratio of the functional unit of the query to the functional unit of the "1,600 cc engine diesel operation" data node, or 2.5. Then this scaling factor can be applied to the emissions, consumption, and production associated with the "1,600 cc engine diesel operation" data node.

[0142] The evaluation engine 124 performs step 410 to determine that the "1,600 cc engine diesel operation" data node is a known data node. Since the "1,600 cc engine diesel operation" data node is known, the evaluation engine 124 continues to perform step 422 to apply data node constraints. In this example, step 422 can be skipped because the query does not specify any constraints for this data node.

[0143] The evaluation engine 124 also performs steps 438 and 440 based on the economic value of the production associated with the "1,600 cc engine diesel operation" data node. In this example, the "1,600 cc engine diesel operation" data node does not include production with a negative economic value, so waste allocation is not calculated.

[0144] The evaluation engine 124 also performs steps 424, 426, and 428 to determine the consumption associated with the "1,600 cc engine diesel operation" data node. In this example, this data node includes a consumption relationship with the "diesel" class with unknown consumption, so the evaluation engine 124 determines in step 424 that the consumption should be calculated for this data node. The evaluation engine 124 also skips step 426 because there is no transformation function for the unknown consumption. Then, the evaluation engine 124 performs step 428 using the previously calculated scaling factor of 2.5 to convert the 1 liter functional unit of the "1,600 cc engine diesel operation" data node to 2.5 liter functional units for this query.

[0145] The evaluation engine 124 determines in step 430 that the "diesel" consumption associated with the "1,600 cc engine diesel operation" data node is unknown, so it creates another unknown data node representing the unknown consumption. This unknown data node includes the properties (such as location and time) from the consuming "1,600 cc engine diesel operation" data node.

[0146] The evaluation engine 124 performs step 412 to apply the matcher constraints to the newly created unknown data node. Here, the "diesel" class of the unknown data node matches the "diesel" class of the time constraint in this query. Therefore, the evaluation engine 124 applies the time constraint to the unknown data node by setting the time of the unknown data node to "2022-01-01T20:00:00Z".

[0147] The evaluation engine 124 performs step 414 to find data nodes similar to the unknown data node. Specifically, the evaluation engine 124 performs step 452 to retrieve two data nodes with the same "Diesel" class as the unknown data node. Both data nodes lack attributes, so they are determined to be equally similar to the unknown data node in step 454. In step 456, the evaluation engine 124 determines that the time of the first data node is set to "2021-01-01", while the time of the second data node is set to "2020-01-01". Since the timestamp of the first data node is closer to the time specified in the time constraint, the evaluation engine 124 determines that the first data node is more similar to the unknown data node.

[0148] In some embodiments, if the time difference between data nodes is within 10% of the time difference between the time constraint and the time in the data node that is furthest from the distance time constraint, the evaluation engine 124 matches the time constraint with the plurality of nodes. This allows for the continuity of the time dimension to be considered when determining similar nodes and also prevents the processing of queries from being overly sensitive to small differences in time. In this example, the times associated with two data nodes are not within 10% of the two-year time difference between the time specified in the time constraint and the time in the second data node. Therefore, the evaluation engine 124 determines that only the first data node matches the time constraint.

[0149] In step 458, the evaluation engine 124 determines that two data nodes have the same "world" location. Accordingly, the evaluation engine 124 does not make additional changes to the similarity of the data nodes to the unknown data node in step 458. The evaluation engine 124 then performs steps 460 and 464 to return the first data node as a matching data node.

[0150] The evaluation engine 124 skips step 416 for the returned data node because attribute scaling is not required. The evaluation engine 124 then performs step 418 to process the single returned data node. For this data node, the evaluation engine performs steps 406, 408, 410, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, and 442. This data node does not include direct consumption and specifies emissions of 100 g CO2e per liter. The emissions are scaled by a factor of 2.5 to 250 g CO2e per liter to complete the calculation for the "1,600 cc engine diesel operation" data node.

[0151] The evaluation engine 124 repeats the process for the "2,000 cc engine diesel operation" data node. More specifically, the evaluation engine also performs steps 406, 408, 410, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, and 442 to calculate the emissions for this data node as 2,700 g CO2e.

[0152] Because the evaluation engine 124 has now computed the emissions of all data nodes that match the query node (i.e., the "1,600 cc engine diesel operation" data node and the "2,000 cc engine diesel operation" data node), the evaluation engine 124 performs step 420 to average the emissions of the data nodes into the overall emissions of the entity represented by the query. In this step, the evaluation engine 124 can use the linear opinion pool technique to combine the emission distributions associated with the data nodes into a single distribution. For example, the evaluation engine 124 can transform each distribution into a percentile distribution that stores 101 numbers between the 0th percentile and the 1st percentile. The evaluation engine 124 can transform each percentile distribution into a cumulative density function (CDF) and iterate over the CDFs of the two distributions. During each iteration, the evaluation engine 124 computes the arithmetic mean of the CDF densities and sets the density of the combined distribution at the corresponding point to the arithmetic mean. Then, the evaluation engine 124 can transform the CDF of the combined distribution back into a percentile distribution.

[0153] After combining the emission distributions associated with similar data nodes into a combined emission distribution for the query node, the evaluation engine 124 determines that the expected value of the combined distribution is 2,650 g CO2e. Then, the evaluation engine 124 performs step 444 to report the result that includes the expected value and / or the combined distribution. The result can also or alternatively include decomposing the 2,650 g CO2e into the emission values for each of the two similar data nodes.

[0154] Figure 5 is a flowchart of method steps for processing queries of an LCA database according to various embodiments. Although the method steps are described in connection with Figures 1 to 2 a system, those skilled in the art will understand that any system configured to perform the method steps in any order falls within the scope of the present disclosure.

[0155] In step 502, the evaluation engine 124 receives a query that includes parameters specifying the nature of the entity. For example, the evaluation engine 124 can receive a query that specifies one or more classes associated with the entity and / or one or more constraints associated with the nature and / or dependencies of the entity. The classes and / or constraints can represent primary data associated with the entity.

[0156] In step 504, the evaluation engine 124 stores the unknown data node representing the query in an in-memory tree structure. For example, the evaluation engine 124 can create a "virtual" data node with unknown consumption and / or unknown emissions and initialize the tree structure with the virtual data node as the root. The evaluation engine 124 can also set the nature of the virtual data node to the nature specified in the query.

[0157] In step 506, the evaluation engine 124 searches for data nodes in one or more hierarchies in the LCA database that match some or all of the properties of the unknown data node. For example, the evaluation engine 124 can determine the matching nodes based on an exact match, an inexact match, a semantic match, a weighted combination of matches, and / or other types of matches between the properties of the data nodes in the LCA database and the properties of the unknown data node. The evaluation engine 124 can also or alternatively prioritize the matches of certain properties over the matches of other properties.

[0158] In step 508, the evaluation engine 124 stores the matching data nodes in a tree structure. For example, the evaluation engine 124 can store the matching data nodes in one or more subtrees under the root node representing the query.

[0159] In step 510, the evaluation engine 124 calculates the emissions associated with the matching data nodes. For example, the evaluation engine 124 can use the functional unit, transformation functions, economic value, and / or other components of the matching data nodes and / or query nodes to calculate the emissions. During step 510, the evaluation engine 124 may encounter additional data nodes and / or relationships associated with unknown consumption and / or unknown emissions. When unknown consumption and / or unknown emissions are encountered, the evaluation engine creates another unknown data node representing the unknown consumption and / or unknown emissions and adds the unknown data node to the tree.

[0160] In step 512, the evaluation engine 124 determines whether there are still unknown data nodes in the tree. For example, if one or more unknown data nodes are added to the tree during step 510, the evaluation engine 124 can determine that there are still unknown data nodes in the tree. When there are still unknown data nodes in the tree, the evaluation engine 124 repeats steps 506, 508, and 510 for each unknown data node to resolve the corresponding unknown consumption and / or unknown emissions using similar data nodes in the hierarchy. Then, the evaluation engine 124 repeats step 510 to determine whether there are additional unknown data nodes in the tree.

[0161] Once the evaluation engine 124 determines that all unknown data nodes in the tree have been resolved into similar data nodes with known emissions and / or consumption, the evaluation engine 124 performs step 514, where the evaluation engine 124 aggregates the emissions associated with the matching data nodes into the result of the query. For example, the evaluation engine 124 may combine the distributions of emissions, production, consumption, and / or other values calculated from the matching data nodes into the corresponding distribution of the entity represented by the query. The evaluation engine 124 may return the combined distribution, representative values in the combined distribution (e.g., mean, median, quantiles, minimum, maximum, etc.), and / or other representations of the combined distribution in the result. The evaluation engine 124 may also or alternatively decompose the calculated values and / or distributions into the corresponding contributions of some or all of the nodes in the tree.

[0162] Finally, in step 516, the evaluation engine 124 causes the result to be output in response to the query. For example, the evaluation engine 124 may transmit the result to the source of the query. The evaluation engine 124 may also or alternatively output the result to a user interface, a file, a report, and / or other representations. The results of this query and / or other queries of the database can then be analyzed to determine the overall emissions, consumption, and / or production associated with the entity; identify "hot spots" that disproportionately contribute to emissions, consumption, and / or production; determine product design, manufacturing processes, material traceability, policies, regulations, and / or other strategies or actions to reduce negative environmental impacts; conduct simulations and / or studies to evaluate and / or compare the environmental impacts of different processes, products, consumption, and / or entities; and / or otherwise understand and / or improve the environmental impacts associated with the entity.

[0163] In summary, the disclosed technology uses a database to process LCA queries, the database storing LCA data on multiple interconnected planes of a flat data model. The flat data model includes a data plane that stores data nodes representing products, processes, emissions, consumption, and / or other entities for performing an LCA. The data nodes may be organized within one or more trees to represent dependencies and / or relationships between or among the data nodes. The flat data model also includes a separate ontology plane that stores metadata associated with the data nodes in the data plane. The metadata includes (but is not limited to) the source, time range, location, class, and / or attributes associated with the data in the data nodes. The ontology plane and the data plane are interconnected to allow emissions, consumption, production, and / or other quantities associated with an entity to be aggregated, correlated, compared, and / or otherwise used to evaluate the environmental impact associated with the entity.

[0164] The LCA of a given entity can be performed by executing a query on the properties of a specified entity in a database. For example, the query can be used to analyze the environmental impact of a product, process, service, organization, and / or another entity. To process the query, the metadata stored in the ontology plane is used to match the parameters of the query with the data nodes in the data plane. Then, the emissions, consumption, production, waste, and / or other types of environmental impact data associated with the entity can be calculated by traversing the paths associated with the matching data nodes in the data plane and aggregating, scaling, and / or otherwise transforming the functional units stored in the matching data nodes.

[0165] Relative to the prior art, one technical advantage of the disclosed technology is the ability to determine the environmental impact associated with the life cycle of an entity without providing specific inputs, outputs, and / or measurement results in the life cycle of the entity. Thus, compared with conventional LCA tools that operate using predefined workflows and require the specification of certain data points, the disclosed technology can be used to define and execute LCA queries with greater granularity, flexibility, and efficiency. Another technical advantage of the disclosed technology is the ability to automate LCA by processing queries using searches, similarity comparisons, aggregations, and / or computations that utilize a database with a flat data model. These technical advantages provide one or more technical improvements over prior art methods.

[0166] 1. In some embodiments, a computer-implemented method for processing a query of a life cycle assessment database includes: searching for a first set of data nodes that match a first set of parameters included in the query in one or more hierarchies included in the life cycle assessment database, where the first set of parameters includes a set of primary data associated with an entity; calculating a first set of emissions associated with the first set of data nodes based on a first set of functional units included in the first set of data nodes; aggregating the first set of emissions into the result of the query; and causing the result to be output in response to the query.

[0167] 2. The computer-implemented method according to clause 1, wherein searching in the one or more hierarchies includes: matching one or more parameters included in the first set of parameters with a second set of data nodes in the one or more hierarchies; and filtering the second set of data nodes based on one or more additional parameters included in the first set of parameters.

[0168] 3. The computer-implemented method according to any one of clauses 1-2, wherein the one or more parameters include a class associated with the entity, and the one or more additional parameters include attributes associated with the class.

[0169] 4. The computer-implemented method as described in any one of clauses 1-3 further includes: determining that the data nodes included in the first set of data nodes are associated with unknown consumption or unknown emissions; searching in the one or more hierarchies for a second set of data nodes that match a second set of parameters associated with the data nodes; and generating the result of the query based on the second set of functional units included in the second set of data nodes.

[0170] 5. The computer-implemented method as described in any one of clauses 1-4 further includes: storing a first unknown data node representing the query and including the first set of parameters, and a second unknown data node representing the unknown consumption or the unknown emissions and including the second set of parameters in a memory.

[0171] 6. The computer-implemented method as described in any one of clauses 1-5, wherein calculating the first set of emissions includes: combining a distributed combination of a plurality of values associated with the first set of functional units into the emissions included in the first set of emissions.

[0172] 7. The computer-implemented method as described in any one of clauses 1-6, wherein calculating the first set of emissions includes: calculating the emissions using a non-linear transformation of one or more functional units included in the first set of functional units.

[0173] 8. The computer-implemented method as described in any one of clauses 1-7, wherein the first set of emissions is calculated based on one or more constraints specified in the query.

[0174] 9. The computer-implemented method as described in any one of clauses 1-8, wherein the result includes decomposing the first set of emissions into one or more paths including the first set of data nodes.

[0175] 10. The computer-implemented method as described in any one of clauses 1-9, wherein the one or more hierarchies are included in the ontology plane of the life cycle assessment database, and the first set of data nodes are included in the data plane of the life cycle assessment database.

[0176] 11. In some embodiments, one or more non-transitory computer-readable media store instructions that, when executed by one or more processors, cause the one or more processors to perform the following steps: search for a first set of data nodes that match a first set of parameters included in a query in one or more hierarchies included in a life cycle assessment database, where the first set of parameters includes a set of primary data associated with an entity; calculate a first set of emissions associated with the first set of data nodes based on a first set of functional units included in the first set of data nodes; aggregate the first set of emissions into the result of the query; and cause the result to be output in response to the query.

[0177] 12. The one or more non-transitory computer-readable media of clause 11, wherein the instructions further cause the one or more processors to perform the following steps: determine that a data node included in the first set of data nodes is associated with an unknown consumption or an unknown emission; search for a second set of data nodes that match a second set of parameters associated with the data node in the one or more hierarchies; and generate the result of the query based on a second set of functional units included in the second set of data nodes.

[0178] 13. The one or more non-transitory computer-readable media of any one of clauses 11-12, wherein the second set of parameters includes at least one of class, location, time, and attribute.

[0179] 14. The one or more non-transitory computer-readable media of any one of clauses 11-13, wherein searching in the one or more hierarchies includes: determining that a class included in the first set of parameters does not match a second set of data nodes included in the one or more hierarchies; using the one or more hierarchies to determine a parent class of the class; and matching the parent class with the first set of data nodes.

[0180] 15. The one or more non-transitory computer-readable media of any one of clauses 11-14, wherein calculating the first set of emissions includes: scaling a first functional unit included in the first set of functional units to match a second functional unit included in the query.

[0181] 16. The one or more non-transitory computer-readable media of any one of clauses 11-15, wherein calculating the first set of emissions includes: determining one or more scaling factors between one or more attributes included in the first set of data nodes and constraints included in the query; and calculating the first set of emissions based on the one or more scaling factors and one or more functional units associated with the one or more attributes.

[0182] 17. One or more non-transitory computer-readable media as described in any one of clauses 11-16, wherein the one or more hierarchies specify consumption, production, or emissions associated with the first set of data nodes.

[0183] 18. One or more non-transitory computer-readable media as described in any one of clauses 11-17, wherein the one or more hierarchies include at least one of an ontology tree representing classes of entities or a set of locations associated with the entities.

[0184] 19. One or more non-transitory computer-readable media as described in any one of clauses 11-18, wherein the one or more hierarchies include one or more secondary life cycle assessment data sets.

[0185] 20. In some embodiments, a system includes: one or more memories that store instructions, and one or more processors coupled to the one or more memories, and the one or more processors are configured to perform the following steps when executing the instructions: searching for a first set of data nodes that match a first set of parameters included in a query in one or more hierarchies included in a life cycle assessment database, wherein the first set of parameters includes a set of primary data associated with an entity; calculating a first set of emissions associated with the first set of data nodes based on a set of functional units included in the first set of data nodes; aggregating the first set of emissions into a result of the query; and causing the result to be output in response to the query.

[0186] Any and all combinations, in any way, of any claim elements described in any claim and / or any elements described in this application fall within the intended scope of the invention and protection.

[0187] For purposes of illustration, descriptions of various embodiments are given, but these descriptions are not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments.

[0188] Aspects of the present embodiment may be embodied as a system, method, or computer program product. Accordingly, aspects of the present disclosure may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, microcode, etc.), or an embodiment combining software and hardware aspects, which may generally be referred to herein as a "module", "system", or "computer". Additionally, any hardware and / or software technologies, processes, functions, components, engines, modules, or systems described in the present disclosure may be implemented as a circuit or a group of circuits. Further, aspects of the present disclosure may take the form of a computer program product embodied in one or more computer-readable media having computer-readable program code thereon.

[0189] Any combination of one or more computer-readable media may be used. A computer-readable media may be a computer-readable signal medium or a computer-readable storage medium. A computer-readable storage medium may be, for example but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer-readable storage medium include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing devices. In the context of this document, a computer-readable storage medium may be any tangible medium that can contain or store a program for use by or in connection with an instruction execution system, apparatus, or device.

[0190] Aspects of the present disclosure have been described above with reference to flowcharts and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the present disclosure. It should be understood that each block in the flowcharts and / or block diagrams, and combinations of blocks in the flowcharts and / or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine. When executed by the processor of a computer or other programmable data processing apparatus, the instructions enable the functions / actions specified in one or more blocks of the flowchart and / or block diagram to be implemented. Such a processor may be, but is not limited to, a general purpose processor, a special purpose processor, an application specific processor, or a field programmable gate array.

[0191] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagram may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function. It should also be noted that, in some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or sometimes in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and / or flowchart diagrams, and combinations of blocks in the block diagrams and / or flowchart diagrams, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

[0192] Although the foregoing has been directed to embodiments of the present disclosure, other and further embodiments of the present disclosure may be devised without departing from its basic scope, the scope thereof being determined by the appended claims.

Claims

1. A computer-implemented method for processing queries of a life cycle assessment database, the method comprises: searching for a first set of data nodes that match a first set of parameters included in the query in one or more hierarchies included in the life cycle assessment database, wherein the first set of parameters includes a set of primary data associated with an entity; calculating a first set of emissions associated with the first set of data nodes based on a first set of functional units included in the first set of data nodes; aggregating the first set of emissions into the result of the query; and causing the result to be output in response to the query.

2. The computer-implemented method according to claim 1, wherein searching in the one or more hierarchies comprises: matching one or more parameters included in the first set of parameters with a second set of data nodes in the one or more hierarchies; and filtering the second set of data nodes based on one or more additional parameters included in the first set of parameters.

3. The computer-implemented method according to claim 2, wherein the one or more parameters include a class associated with the entity, and the one or more additional parameters include attributes associated with the class.

4. The computer-implemented method according to claim 1, further comprises: determining that data nodes included in the first set of data nodes are associated with unknown consumption or unknown emissions; searching for a second set of data nodes that match a second set of parameters associated with the data nodes in the one or more hierarchies; and generating the result of the query based on a second set of functional units included in the second set of data nodes.

5. The computer-implemented method according to claim 4, further comprises: storing a first unknown data node representing the query and including the first set of parameters and a second unknown data node representing the unknown consumption or the unknown emissions and including the second set of parameters in a memory.

6. The computer-implemented method according to claim 1, wherein calculating the first set of emissions comprises: combining distributed combinations of multiple values associated with the first set of functional units into the emissions included in the first set of emissions.

7. The computer-implemented method according to claim 1, wherein calculating the first set of emissions comprises: calculating emissions using a non-linear transformation of one or more functional units included in the first set of functional units.

8. The computer-implemented method according to claim 1, wherein the first set of emissions is calculated based on one or more constraints specified in the query.

9. The computer-implemented method according to claim 1, wherein the result comprises: decomposing the first set of emissions into one or more paths including the first set of data nodes.

10. The computer-implemented method according to claim 1, wherein the one or more hierarchies are included in an ontology plane of the life cycle assessment database, and the first set of data nodes are included in a data plane of the life cycle assessment database.

11. One or more non-transitory computer-readable media storing instructions that, when executed by one or more processors, cause the one or more processors to perform the following steps: Search for a first set of data nodes that match a first set of parameters included in a query in one or more hierarchies included in a life cycle assessment database, wherein the first set of parameters includes a set of primary data associated with an entity; Calculate a first set of emissions associated with the first set of data nodes based on a first set of functional units included in the first set of data nodes; Aggregate the first set of emissions into the result of the query; And Cause the result to be output in response to the query.

12. The one or more non-transitory computer-readable media according to claim 11, wherein the instructions further cause the one or more processors to perform the following steps: Determine that data nodes included in the first set of data nodes are associated with unknown consumption or unknown emissions; Search for a second set of data nodes that match a second set of parameters associated with the data nodes in the one or more hierarchies; and Generate the result of the query based on a second set of functional units included in the second set of data nodes.

13. The one or more non-transitory computer-readable media according to claim 12, wherein the second set of parameters includes at least one of class, location, time, and attribute.

14. The one or more non-transitory computer-readable media according to claim 11, wherein searching in the one or more hierarchies Comprises: Determine that the class included in the first set of parameters does not match a second set of data nodes included in the one or more hierarchies; Use the one or more hierarchies to determine the parent class of the class; and Match the parent class with the first set of data nodes.

15. The one or more non-transitory computer-readable media according to claim 11, wherein calculating the first set of emissions Comprises: Scale a first functional unit included in the first set of functional units to match a second functional unit included in the query.

16. The one or more non-transitory computer-readable media according to claim 11, wherein calculating the first set of emissions Comprises: Determine one or more scaling factors between one or more attributes included in the first set of data nodes and constraints included in the query; And Calculate the first set of emissions based on the one or more scaling factors and one or more functional units associated with the one or more attributes.

17. The one or more non-transitory computer-readable media according to claim 11, wherein the one or more hierarchies specify consumption, production, or emissions associated with the first set of data nodes.

18. The one or more non-transitory computer-readable media according to claim 11, wherein the one or more hierarchies include at least one of an ontology tree representing classes of entities or a set of locations associated with the entity.

19. The one or more non-transitory computer-readable media according to claim 11, wherein the one or more hierarchies include one or more secondary life cycle assessment data sets.

20. A system, comprising: one or more memories that store instructions, and one or more processors coupled to the one or more memories, and the one or more processors are configured to perform the following steps when executing the instructions: searching for a first set of data nodes that match a first set of parameters included in a query in one or more hierarchies included in a life cycle assessment database, wherein the first set of parameters includes a set of primary data associated with an entity; calculating a first set of emissions associated with the first set of data nodes based on a set of functional units included in the first set of data nodes; aggregating the first set of emissions into the result of the query; and causing the result to be output in response to the query.

Images