Caching for query processing via a planar data model

Abstract

One embodiment of the present invention sets forth a technique for processing a query of a life cycle assessment (LCA) database. The technique includes searching one or more hierarchical structures included in the LCA database for data nodes that match a set of parameters that is (i) included in the query and (ii) specifies one or more properties of an entity. The technique also includes upon determining that a data node includes an unknown consumption or an unknown emission, matching a second set of parameters associated with the data node to an entry in a cache and computing one or more environmental impacts based on a functional unit that is (i) included in the entry and (ii) includes a quantity associated with the unknown consumption or the unknown emission. The technique further includes causing the one or more environmental impacts to be outputted in a response to the query.

Description

PATENTAttorney Docket No.: VAYU0004PCCACHING FOR QUERY PROCESSING VIA A PLANAR DATA MODELCROSS-REFERENCE TO RELATED APPLICATIONS

[0001] This application claims the benefit of the U.S. Provisional Application titled “CACHING FOR QUERY PROCESSING VIA A PLANAR DATA MODEL,” filed on January 16, 2025, and having Serial No. 63 / 746,023. The subject matter of this application is hereby incorporated herein by reference in its entirety.BACKGROUNDField of the Various Embodiments

[0002] The present invention relates generally to databases and query processing and, more specifically, to caching for query processing via a planar data model.Description of the Related Art

[0003] Life Cycle Assessment (LCA) is a framework for assessing the environmental impacts of a product, service, process, organization, and / or another entity across the life cycle of the entity. For example, LCA can be used to estimate pollutant emissions, water use, land use change, toxicity, depletion of resources, acidification, ozone layer depletion, climate change impacts, and / or other types of environmental impacts associated with raw material extraction and processing, energy creation, energy expenditure, transportation, marketing or advertising, usage and retail, travel, and / or end-of-life disposal for the entity. The results of an LCA can then be used to improve product development and research, supply chain management and procurement, strategic management, and / or other types of decisions and actions related to the entity.

[0004] The process of computing environmental impacts for an entity can involve traversing complex hierarchical data structures (e.g., trees, graphs, etc.) within an LCA database that represent dependencies and / or relationships across processes, materials, consumptions, and / or emissions within the life cycle of the entity. For example, a supply chain for a product may include multiple transport steps, manufacturing processes, material inputs, and / or other high-level components with consumptions and / or emissions. Each high-level component may be represented withinPATENTAttorney Docket No.: VAYU0004PCthe LCA database by a node in a tree and include a sub-tree of additional nodes representing dependencies and / or sub-components of the component. As a result, computing the environmental impact of the product may involve retrieval, aggregation, and / or other types of processing associated with more than 100,000 nodes in the LCA database. This computational complexity can lead to substantial resource overhead and latency when processing queries against LCA databases.

[0005] Existing approaches for reducing computational overhead in database query processing include caching mechanisms that store previously computed results for reuse. However, conventional database caching techniques cannot be used with LCA computations due to the context-dependent nature of environmental impact calculations. For example, an environmental impact associated with a sub-tree of data nodes in an LCA database may be computed differently depending on groupings of environmental impacts into life cycle stages, changes to values associated with LCA models and / or components in the LCA database, and / or quantitative measures associated with the corresponding components and / or environmental impacts.Consequently, a cached result from a previous query that is associated with a given node in the LCA database may or may not be usable with subsequent queries involving the same node.

[0006] As the foregoing illustrates, what is needed in the art are more effective techniques for improving the processing of queries of LCA databases.SUMMARY

[0007] One embodiment of the present invention sets forth a technique for processing a query of a life cycle assessment (LCA) database. The technique includes searching one or more hierarchical structures included in the LCA database for data nodes that match a set of parameters that is (i) included in the query and (ii) specifies one or more properties of an entity. The technique also includes upon determining that a data node includes an unknown consumption or an unknown emission, matching a second set of parameters associated with the data node to an entry in a cache and computing one or more environmental impacts based on a functional unit that is (i)PATENTAttorney Docket No.: VAYU0004PCincluded in the entry and (ii) includes a quantity associated with the unknown consumption or the unknown emission. The technique further includes causing the one or more environmental impacts to be outputted in a response to the query.

[0008] One technical advantage of the disclosed techniques relative to the prior art is a reduction in resource overhead and latency over conventional approaches that process LCA queries by retrieving, aggregating, and / or otherwise processing data associated with a large number of nodes in an LCA database. Another technical advantage of the disclosed techniques is the ability to match parameters of a query to entries in a cache in a context-dependent manner. In particular, the disclosed techniques can be used to determine whether or not a cached environmental impact can be reused with a subsequent query involving the same data node and / or sub-tree, thereby allowing caching techniques to be used with LCA databases that include planar data models and / or complex hierarchical structures. These technical advantages provide one or more technological improvements over prior art approaches.BRIEF DESCRIPTION OF THE DRAWINGS

[0009] So that the manner in which the above recited features of the various embodiments can be understood in detail, a more particular description of the inventive concepts, briefly summarized above, may be had by reference to various embodiments, some of which are illustrated in the appended drawings. It is to be noted, however, that the appended drawings illustrate only typical embodiments of the inventive concepts and are therefore not to be considered limiting of scope in any way, and that there are other equally effective embodiments.

[0010] Figure 1 illustrates a computing device configured to implement one or more aspects of various embodiments.

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

[0012] Figure 3 illustrates an example schema associated with the ontological plane of Figure 2, according to various embodiments.PATENTAttorney Docket No.: VAYU0004PC

[0013] Figure 4A illustrates how the evaluation engine of Figure 1 processes a query, according to various embodiments.

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

[0015] Figure 5 is a flow diagram of method steps for processing a query of a life cycle assessment database, according to various embodiments.

[0016] Figure 6 illustrates a caching system for the database of Figure 1 , according to various embodiments.

[0017] Figure 7 illustrates different types of sub-tree caches for the database of Figure 1, according to various embodiments.

[0018] Figure 8 illustrates how parameters associated with a query are used to perform a lookup of a sub-tree cache, according to various embodiments.

[0019] Figure 9 is a flowchart of method steps for processing a query of a life cycle assessment database, according to various embodiments.DETAILED DESCRIPTION

[0020] In the following description, numerous specific details are set forth to provide a more thorough understanding of the various embodiments. However, it will be apparent to one of skill in the art that the inventive concepts may be practiced without one or more of these specific details.System Overview

[0021] Figure 1 illustrates a computing device 100 configured to implement one or more aspects of various embodiments. In one embodiment, computing device 100 includes a desktop computer, a laptop computer, a smart phone, a personal digital assistant (PDA), tablet computer, or any other type of computing device configured to receive input, process data, and optionally display images, and is suitable for practicingPATENTAttorney Docket No.: VAYU0004PCone or more embodiments. Computing device 100 is configured to run a database 122 and an evaluation engine 124 that reside in a memory 116.

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

[0023] In one embodiment, computing device 100 includes, without limitation, an interconnect (bus) 112 that connects one or more processors 102, an input / output (I / O) device interface 104 coupled to one or more input / output (I / O) devices 108, memory 116, a storage 114, and a network interface 106. Processor(s) 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 (Al) accelerator, any other type of processing unit, ora combination of different processing units, such as a CPU configured to operate in conjunction with a GPU. In general, processor(s) 102 may be any technically feasible hardware unit capable of processing data and / or executing software applications.Further, in the context of this disclosure, the computing elements shown in computing device 100 may correspond to a physical computing system (e.g., a system in a data center) or may be a virtual computing instance executing within a computing cloud.

[0024] I / O devices 108 include devices capable of providing input, such as a keyboard, a mouse, a touch-sensitive screen, and so forth, as well as devices capable of providing output, such as a display device. Additionally, I / O devices 108 may include devices capable of both receiving input and providing output, such as a touchscreen, aPATENTAttorney Docket No.: VAYU0004PCuniversal serial bus (USB) port, and so forth. I / O devices 108 may be configured to receive various types of input from an end-user (e.q., a designer) of computing device 100, and to also provide various types of output to the end-user of computing device 100, such as displayed digital images or digital videos or text. In some embodiments, one or more of I / O devices 108 are configured to couple computing device 100 to a network 110.

[0025] Network 110 is any technically feasible type of communications network that allows data to be exchanged between computing device 100 and external entities or devices, such as a web server or another networked computing device. For example, network 110 may include a wide area network (WAN), a local area network (LAN), a wireless (WiFi) network, and / or the Internet, among others.

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

[0027] Memory 116 includes a random-access memory (RAM) module, a flash memory unit, or any other type of memory unit or combination thereof. Processor(s) 102, I / O device interface 104, and network interface 106 are configured to read data from and write data to memory 116. Memory 116 includes various software programs that can be executed by processor(s) 102 and application data associated with said software programs, including database 122 and evaluation engine 124.

[0028] In some embodiments, database 122 stores life cycle assessment (LCA) data using a planar data model that includes multiple interconnected planes. The planar data model includes a data plane that stores data nodes representing products, processes, emissions, consumptions, and / or other entities that are used to perform LCA. The data nodes can be organized within trees and / or other hierarchical data structures to represent dependencies and / or relationships between or among the corresponding entities. The planar data model also includes a separate ontologicalPATENTAttorney Docket No.: VAYU0004PCplane that stores metadata associated with data nodes in the data plane. This metadata includes (but is not limited to) sources, timeframes, locations, classes, and / or attributes associated with data in the data nodes. The ontological plane and data plane are interconnected to allow emissions, consumptions, productions, and / or other quantities associated with the entities to be aggregated, related to one another, compared, and / or otherwise used to evaluate environmental impacts associated with the entities.

[0029] Evaluation engine 124 includes functionality to perform LCA by evaluating queries against database 122. Each query can be used to analyze the environmental impact of a product, process, service, organization, and / or another entity. To process a query, evaluation engine 124 uses metadata stored in the ontological plane to match parameters of the query to data nodes in the data plane. Evaluation engine 124 then computes emissions, consumptions, productions, waste products, and / or other types of impact data associated with the entity by traversing paths associated with the matching data nodes in the data plane and aggregating, scaling, and / or otherwise transforming functional units stored in the matching data nodes. The operation of database 122 and evaluation engine 124 is described in further detail below.Granular Query Processing Via a Planar Data Model

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

[0031] Within data plane 202, data nodes 222 store data that can be used to perform LCA. For example, each tree 224 of data nodes 222 within data plane 202 could store data from a different dataset of secondary LCA data. Each dataset could be obtainedPATENTAttorney Docket No.: VAYU0004PCfrom a separate source, such as (but not limited to) an LCA paper, an LCA database, a database of energy grid mixes, an LCA study, and / or a survey.

[0032] One type of data node 222 represents a consumable that does not have direct emissions or products, such as (but not limited to) a product, a byproduct of a process, and / or an item or material utilized in the production of a product. Another type of data node 222 represents a process that includes a series of steps for achieving a certain outcome, such as (but not limited to) producing a physical item, machine, textile, good, food, beverage, pharmaceutical product, ingredient, service, and / or experience.

[0033] Within trees 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 denote a consumption relationship, in which the first data node 222 requires a quantity of the second data node 222. Because the consumption relationship represents a dependency of the first data node 222 on the second data node 222, the consumption relationship can be used to infer the effect of a change in one data node 222 on the other data node 222. For example, a shortage in a product, material, and / or another consumable represented by the second data node 222 could result in a decrease in a different product produced by the process represented by the first data node 222. In another example, an increase in the demand for the product produced by the process represented by the first data node 222 could lead to an increase in 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 denote a production relationship, in which the first data node 222 produces a 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 could indicate that the product is produced by the process.

[0035] A given data node 222 representing a process additionally includes one or more emission relationships that represent emissions of the process. Each emissionPATENTAttorney Docket No.: VAYU0004PCrelationship can be represented as an edge from that data node 222 to a different data node 222 and / or another element in data plane 202 that represents a gas and / or another type of emission.

[0036] An example tree 224 of data nodes 222 in data plane 202 includes the following:cotton cultivation -[:CONSUMES]-> cotton seeds <-[:PRODUCES]- cotton gin -[:CONSUMES]-> cotton -[:CONSUMES]-> cotton cultivationIn the above example, a first data node 222 representing a “cotton cultivation” process has a consumption relationship with a second data node 222 representing a “cotton seeds” consumable. A third data node 222 representing a “cotton gin” process has a production relationship with the second data node 222 and a consumption relationship with a fourth data node 222 representing a “cotton” consumable. The fourth data node 222 additionally has a consumption relationship with the first data node 222 representing the “cotton cultivation” process. The “cotton cultivation” and “cotton gin” processes represented by the first data node 222 and third data node 222, respectively, can also include emission relationships (not shown) that represent emissions of various gases and / or byproducts.

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

[0038] Each type of functional unit can also be associated with a reference unit that is used to normalize and / or standardize across different functional units of that type. For example, a reference unit for distance could be set to meters, so that a consumption that is specified in another unit for distance (e.q., kilometers, centimeters, feet, miles, etc.) would be converted into meters. Further, a mathematical operation involving twoPATENTAttorney Docket No.: VAYU0004PCfunctional units that do not have the same reference unit could return an error and / or fail.

[0039] Within data plane 202, functional units can be represented using various types of probability distributions. 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, in which all values within a range between a minimum value and a maximum value have equal probability. Additional types of probability distributions can include (but are not limited to) Normal distributions, Log-normal distributions, Binomial distributions, Poisson distributions, exponential distributions, 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 the corresponding emissions, consumptions, productions, and / or data nodes 222 to be described with a quantitative uncertainty, which in turn can be used to determine the source of uncertainty and / or techniques for decreasing uncertainty within a given LCA and / or model.

[0040] A given data node 222 and / or relationship can additionally be associated with a multi-dimensional functional unit that includes multiple dimensions. For example, a delivery that is characterized using a mass, volume, and distance could be represented by a one-dimensional functional unit such as a ton-kilometer. While this onedimensional representation can be used to model environmental impacts for a linear system, the same representation would fail to yield accurate results for a non-linear system. Instead, the delivery could be represented using a single data node 222 with a multi-dimensional functional unit of (1 kg, 0.5L, 3MJ) and a certain emissions value.

[0041] One or more functional units can additionally be defined as a non-standard, or “custom” unit. For example, a custom unit for washing machine usage could include “rounds per minute,” “washing temperature,” and “number of washes.” In another example, a custom unit for the dimensions of a box could include a width, height, and depth that are each defined using centimeters. This custom unit could then be used toPATENTAttorney Docket No.: VAYU0004PCnormalize a functional unit for a given data node 222 that is specified in centimeters with a consumption that is specified in meters.

[0042] A 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 producing semiconductor wafers could include a 20% probability of producing a faulty wafer. In another example, a functional unit for a clothes washing process could include a 60% probability that an electrical dryer is used in the process. This probability is applied to a result (e.q., an emissions calculation) of a given LCA evaluation instead of being combined with other functional units used to generate the result.

[0043] In one or more embodiments, a consumption relationship is associated with a transform function that receives a first functional unit as input and generates a second functional unit as output. The transform function can be used to specify a nonlinear consumption relationship. For example, a transform function could model a nonlinear relationship between the distance traveled by an air cargo flight and the amount of fuel consumed by the flight by computing a higher fuel consumption per unit distance during takeoff and climb and a lower fuel consumption per unit distance during cruising.

[0044] A consumption relationship can also, or instead, specify an “unknown” consumption that lacks concrete data. For example, a process represented by a first data node 222 could have a consumption relationship that specifies a certain amount of electricity consumption from an unknown source of electricity. This consumption relationship could be represented by a connection between the first data node 222 and an ’’unknown” data node 222 representing the unknown source of electricity.

[0045] Ontological plane 204 stores metadata associated with each data node 222. As shown in Figure 2, ontological plane 204 includes nodes and / or elements representing instances 206, locations 208, time frames 210, sources 212, classes 214, and attributes 216 associated with data nodes 222.PATENTAttorney Docket No.: VAYU0004PC

[0046] Instances 206 correspond to metadata-based representations of individual data nodes 222 in data plane 202. More specifically, each data node 222 in data plane 202 can be associated with a unique instance in ontological plane 204. Each instance node additionally includes one or more locations 208, time frames 210, sources 212, classes 214, and / or attributes 216 that describe the corresponding data node 222.

[0047] Locations 208 include regions and / or other geographic descriptors of the corresponding data nodes 222. For example, each instance could specify a location for the corresponding data node 222. Additionally, ontological plane 204 can store a tree and / or another type of hierarchical structure under which locations 208 are organized. For example, the hierarchical structure could include a root node with a geographic identifier of “World.” This root node could include child nodes with geographic identifiers of different continents. Each node representing a continent could include child nodes representing different countries in that continent, and each node representing a country could include child nodes representing different states, provinces, and / or regions within that country. Consequently, a given parent node in the hierarchical structure could represent a region that partially or fully encompasses the regions represented by all child nodes of that parent node. To facilitate the understanding and / or determination of similarities and / or relationships across data nodes 222, a single location that is assigned to multiple instances 206 can be indicated by having each instance point to the node representing the location within the hierarchical structure.

[0048] Time frames 210 denote ranges of time within which data associated with instances 206 is assumed to be correct. For example, each instance could include one time frame that specifies a “from” timestamp and an “until” timestamp. The “from” and “until” timestamps could be set to the same value to describe an instant in time. The “from” and “until” timestamps could alternatively be set to different values to indicate a period over which data is considered to be valid (e.q., collected, reported by a research paper, etc.).

[0049] Sources 212 represent sources of data in data nodes 222. For example, each source could specify the author of the data, a location (e.q., Uniform ResourcePATENTAttorney Docket No.: VAYU0004PCLocator (URL), citation, etc.) of the data, and / or additional information related to the source.

[0050] Classes 214 form a shared ontology over entities represented by data nodes 222. More specifically, classes 214 are organized under one or more ontology trees that can be used to determine similarities, differences, and / or other semantic relationships between the corresponding entities. For example, classes 214 representing processes could be stored in one ontology tree, and classes 214 representing consumables could be stored in a different ontology tree. Each class could include a name and one or more aliases with the same semantic meaning as the name.

[0051] Each ontology tree can be constructed under a “similarity principle,” in which a child class shares the same essence as a corresponding parent class and represents a subset of the parent class. For example, a “cotton T-shirt” class could be a child of a “T-shirt” class, the “T-shirt” class could be a child of a “shirt” class, the “shirt” class could be a child of a “wearable garment” class, and the “wearable garment” class could be child of a “textile” class.

[0052] Each ontology tree can also, or instead, be constructed under a “specificity principle,” in which a child class differs from all direct and indirect parent classes in at least one attribute that is more specific than corresponding attributes associated with the parent classes. Continuing with the above example, the “cotton T-shirt” class would be associated with a specific fabric that distinguishes from other fabrics with which T-shirts can be made.

[0053] Each ontology tree can also, or instead, be constructed under an “opposition principle,” in which sibling classes that share the same direct parent are at least partially incompatible and / or opposed to one another. Continuing with the above example, the “cotton T-shirt” class could have sibling classes of “polyester T-shirt,” “wool T-shirt,” and / or “cotton, polyester, and wool blend T-shirt.”PATENTAttorney Docket No.: VAYU0004PC

[0054] Each ontology tree can also, or instead, be constructed under a “unique semantic axis principle,” in which each class is found on a unique path through the ontology tree and occurs only once in a given ontology tree. In embodiments where processes and consumables are stored in separate ontology trees, a given class can appear in both ontology trees but only once in each ontology tree.

[0055] Attributes 216 describe individual instances 206 and / or variants of individual classes 214. For example, attributes 216 associated with a “cotton T-shirt” class could include (but are not limited to) a size, a color, a brand, whether or not the T-shirt is made of organic cotton, whether or not the T-shirt is waterproof, whether or not the T-shirt is maternity clothing, and / or how the T-shirt was made (e.q., by hand or by machine).

[0056] Each attribute can include 0 or more dimensions and continuous or discrete values for each dimension. For example, a 0-dimensional attribute for maternity clothing can be represented by a Boolean value indicating whether or not an article of clothing is considered maternity clothing. A one-dimensional attribute for clothing size could include discrete values of small, medium, or large. A multi-dimensional attribute for sizing of clothing tops could include dimensions of arm length, torso circumference, and chest circumference. Each of these dimensions could be specified using continuous values that span a certain range (e.q., a minimum length or circumference to a maximum length or circumference).

[0057] In some embodiments, attributes 216 and custom functional units specify values that are used in different contexts. For example, attributes 216 could be used to distinguish between different variants of classes 214 and / or different instances 206, while custom functional units could be used to store values that have a direct impact on consumptions, productions, emissions, and / or other measures that are computed in LCA.

[0058] Continuous attribute values can be correlated with emissions, functional units, classes of consumption relationships, and / or ontologies of consumption relationships. Attributes 216 can additionally be organized into groups, where attributes 216 within aPATENTAttorney Docket No.: VAYU0004PCgiven a group are mutually exclusive. For example, different size systems for clothing could be stored under the same group of attributes so that a given class of clothing can be associated with a single size from one size system.

[0059] Attributes 216 can additionally be validated in other ways. For example, a value assigned to a discrete attribute could be verified to be one of a set of possible attribute values for the discrete attribute. In another example, a value assigned to a continuous attribute could be verified to lie within a valid range for the continuous attribute. In a third example, one or more values assigned to an attribute could be verified to describe all dimensions of the attribute.

[0060] Figure 3 illustrates an example schema associated with ontological plane 204 of Figure 2, according to various embodiments. As shown in Figure 3, the schema includes a node 302 representing an instance. Node 302 includes a“HAS_TI ME FRAME” relationship with another node 304 that specifies a time frame for the instance. Node 302 also includes a “HAS_SOURCE” relationship with a third node 306 that specifies a source for data associated with the instance.

[0061] Node 302 includes an “IN” relationship with a fourth node 318 that specifies a location for data associated with the instance. Node 318 and a fifth node 322 that specifies another location additionally include “IN” relationships with a sixth node 320 that specifies a third location, thereby indicating that the third location represented by node 320 encompasses the locations represented by nodes 318 and 322.

[0062] Node 302 includes an “IS” relationship with a seventh node 308 that specifies a class for the instance. Node 308 and an eighth node 312 representing another class additionally have “IS” relationships with a ninth node 310 representing a third class, thereby indicating that the classes represented by nodes 308 and 312 are children of the class represented by node 310.

[0063] 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 attributePATENTAttorney Docket No.: VAYU0004PCrepresented by node 314 is used to modify the class represented by node 308, and the attribute represented by node 316 is used to modify the instance represented by node 302.

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

[0065] Classes 242 identify one or more entities for which emissions, consumptions, productions, and / or other environmental impacts are to be computed. For example, classes 242 could include names and / or concepts to be matched to one or more classes 214 in ontological plane 204.

[0066] Constraints 244 include additional parameters that can be used to modify assumptions and / or values associated with LCA models and / or components stored in database 122. More specifically, constraints 244 can include primary data from a source that is external to database 122 (e.q., a system querying database 122).

[0067] In some embodiments, primary data includes data that is directly measure or collected from a facility and / or another source. For example, primary data could include raw data collected from a specific site, process, supplier, distributor, and / or set of consumers. In the context of constraints 244, primary data can be used to modify locations 208, time frames 210, sources 212, attributes 216, functional units, and / or other data or metadata associated with data nodes 222, relationships associated with data nodes 222, instances 206 corresponding to data nodes 222, productions, emissions, and / or other components of database 122. For example, each constraint could include units, values (e.q., discrete values, continuous values, multidimensional values, etc.) of the units, and / or a type of node or record in database 122 (e.q., classes 214, processes, emissions, consumptions, etc.) to which the constraint pertains. Thus, a constraint could 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 made in a certain country, includes a total of 20 grams of cotton, has a totalPATENTAttorney Docket No.: VAYU0004PCweight of 200 grams, has a precursor with total emissions of 1kg of CO2e, and / or includes cotton yam that was produced via a ring spinning technique.

[0068] In some embodiments, constraints 244 include input constraints, location constraints, time constraints, and / or emissions constraints. An input constraint can be used to mutate the consumptions 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 a consumption.

[0069] For example, input constraints can include the following definition:type Inputconstraint struct {Subj ect SpecifierInputs [ ] InputspecificationFunctionalUnit *unit . FunctionalUnit}type Inputspecification struct {Is ClassSpecifierFunctionalUnit unit . FunctionalUnitReplace boolReplaceSubj ect *ClassSpecif ierDelete boolAdd bool}

[0070] In the above definition, an input constraint is defined as a struct data type. The struct includes a “Subjectspecifier” that specifies a subject to which the input constraint pertains (e.q., the subject of a 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 or not the input is used to replace, delete, or add a consumption. When the Boolean values indicate that a consumption is to be replaced, the class of the subject can be replaced with a different class associated with the “ReplaceSubject” field.PATENTAttorney Docket No.: VAYU0004PC

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

[0072] A time constraint can be used to update the time of a given data node 222. For example, the time constraint could specify a start time, end time, and / or instance in time associated with the data node.

[0073] An emission constraint can be used to override the emissions of a given data node 222 and dependencies of the data node. For example, emission constraints can include the following definition:type EmissionsConstraint struct {Subj ect SpecifierEmits [ ] carbongraph . Emission}

[0074] In the above definition, an emission constraint is defined as a struct data type. The struct includes a “Subjectspecifier” that specifies a subject to which the emission constraint pertains (e.q., a data node for which emissions are to be overridden). The emission constraint struct also includes a list of emissions.

[0075] An example emission constraint within the list can include the following representation:{"Type : "Emission","Value" : {"ForPath" : { "Segments" : [ { "Class" : ["Example"] } ] } , "Emits" : [{"Gas" : "CO2e" ,"Value" : 12 ,}] ,PATENTAttorney Docket No.: VAYU0004PC}}The representation specifies a class of “Example” to which the emission constraint applies, as well as a gas of “C02e” and a value of “12” for the emission. This emission constraint thus indicates that the “C02e” emissions of a data node with a class of “Example” should be overridden with a value of 12.

[0076] In some embodiments, classes 242 and / or constraints 244 within query 232 are specified using a flexible query language. This query language allows complex constraints 244 to be defined for a variety of queries and / or use cases. For example, the query language could include the following specification:type Query = {Specifier : Specifier,Constraints : Array<Constraint>}type Constraint = {Type : "Input" ,For? : Array<string>,ForPath : Path,Input : Specifier,} I {Type : "Process" ,For? : Array<string>,ForPath : Path,Process : Specifier,} I {Type : "Emission" ,For? : Array<string>,ForPath : Path,Emission: Emissionspecifier,} •••PATENTAttorney Docket No.: VAYU0004PCtype Emissionspecifier = {Gas : stringFunctionalUnit : FunctionalUnit,}type Specifier = {Is : Array<string>,In : Array<string>,At : string,FunctionalUnit : FunctionalUnit,}type FunctionalUnit = Array< {Unit : string,Value : number,} >type Path = {Segments : Array< {Location? : Array<string>,Class? : Array<string>,} >}

[0077] In the above definition, a given query 232 includes a “Specifier” property that identifies criteria associated with the query, as described by the “Specifier” type. The “Specifier” includes an “Is” array describing one or more classes representing an entity, an “In” array describing one or more locations of the entity, an “At” field describing a time or time frame 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.

[0078] The above definition indicates that a given constraint can represent an “Input” constraint, a “Process” constraint, an “Emission” constraint, and / or another type ofPATENTAttorney Docket No.: VAYU0004PCconstraint. Each type of constraint includes a property named “ForPath,” which is a locator that specifies a “Path” within a tree (e.q., trees 224) to which the constraint should apply. For example, a constraint that changes the electricity consumption of a process for assembling a T-shirt could include a path that includes a class named “T-Shirt” and a class named “Assembly”:{ Segments : [ { Class : ["T-Shirt"] } , { Class : ["Assembly"] } ] }Each type of constraint can also, or instead, include a “For” property that specifies one or more classes 214 to which the constraint should apply.

[0079] The above definition also indicates that each type of constraint is associated with a different specifier. The “Emission” constraint includes an “Emissionspecifier” that indicates a type of gas being emitted and a 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 an identity (e.q., class), location, time, functional unit, and / or other properties associated with the corresponding entity and / or constraint.

[0080] The above definition additionally indicates that a 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 a numerical value for that unit.

[0081] An example query 232 that uses the above specification includes the following:Specifier :Is : ["Cotton T-Shirt"]In: ["China"]At : "2020-01-01"FunctionalUnit :- Unit: gValue : 200Constraints :PATENTAttorney Docket No.: VAYU0004PC- Type : InputFor : [ "Cotton T-Shirt" ]Input :Is : [ "Organic Cotton" , "Cotton" , "Materials" ] FunctionalUnit :- Unit : fractionValue : 0 . 8- Type : InputFor : [ "Garment Manufacturing" ]Input :Is : [ "Electricity" ]FunctionalUnit :- Unit : kWhValue : 1000- Unit : yearValue : 1- Type : ProcessFor : [ "Cotton Cultivation" ]Process :In : [ "India" ]- Type : EmissionFor : [ "Cotton Jersey" ]Emission :Gas : CO2eFunctionalUnit :- Unit : kgValue : 1- Type : ProcessFor : [ "Cotton Yarn Spinning" ]Process :Is : [ "Ring Spinning" , "Cotton Yarn Spinning" ]

[0082] The above example query includes a “Specifier” that indicates a class of “Cotton T-Shirt” in a location of “China” at a time of “2020-01 -01 The query also includes a functional unit that specifies a unit of grams and a value of 200. The queryPATENTAttorney Docket No.: VAYU0004PCadditionally includes five constraints. The first constraint is an input constraint for a consumption associated with a “Cotton T-Shirt” data node 222. The first constraint indicates that the consumption relates to one or more consumables denoted by “Organic Cotton,” “Cotton,” and / or “Materials.” The first constraint also includes a fractional functional unit of 0.8, which is multiplied with the functional unit associated with the consumable(s).

[0083] The second constraint is an input constraint for a consumption associated with a “Garment Manufacturing” data node 222. The second constraint indicates that the consumption relates to a consumable of “Electricity” with two functional units of 1000 kWh and one year, respectively.

[0084] The third constraint is a process constraint for a “Cotton Cultivation” data node 222. The third constraint specifies that the process represented by the data node has a location of “India.”

[0085] The fourth constraint is an emission constraint for emissions related to a “Cotton Jersey” data node 222. The fourth constraint includes a gas of “CO2e” and a functional unit of 1kg for the emitted gas.

[0086] The fifth constraint is a process constraint for a “Cotton Yam Spinning” data node 222. The fifth constraint indicates that the process represented by the data node can be categorized as “Ring Spinning” and / or “Cotton Yam Spinning.”

[0087] As shown in Figure 2, evaluation engine 124 executes query 232 by creating a virtual node that is included in a set of unknown nodes 238. The virtual node is stored in memory and represents an unknown consumption to be resolved using database 122. The virtual node includes the same properties (e.q., classes 242 and constraints 244) as query 232 and is identified as a “query node” that represents query 232.

[0088] Evaluation engine 124 also matches the virtual node to a set of similar data nodes 240 in database 122. In one or more embodiments, similar data nodes 240 are determined via a similar node search technique that searches and / or traverses one orPATENTAttorney Docket No.: VAYU0004PCmore trees 224 of data nodes 222 within database 122, as described in further detail below with respect to Figures 4A and 4B.

[0089] Evaluation engine 124 uses the set of similar data nodes 240 to perform computations 248 related to query 232. For example, evaluation engine 124 could compute emissions, productions, emissions, waste product allocations, and / or other values representing the environmental impacts of the entity represented by query 232. During computations 248, evaluation engine 124 can create additional unknown nodes 238 upon encountering the corresponding unknown consumptions during traversals that determine similar data nodes 240. Evaluation engine 124 can also repeat the process of matching these unknown nodes 238 to similar data nodes 240 and performing computations 248 for these similar data nodes 240 until all unknown nodes 238 have been resolved into similar data nodes 240 with known consumptions.

[0090] Evaluation engine 124 also performs aggregations 250 of computations 248 associated with similar data nodes 240 to generate results 246 of query 232. These results 246 can include a tree structure that represents the emissions breakdown associated with similar data nodes 240 selected during processing of query 232. These results 246 can also, or instead, include total emissions, productions, waste product allocations, and / or other values generated during computations 248 across similar data nodes 240.

[0091] Figure 4A illustrates how evaluation engine 124 of Figure 1 processes a query, according to various embodiments. As shown in Figure 4A, evaluation engine 124 begins by performing a step 402 of receiving a query, such as query 232 of Figure 2. Next, evaluation engine 124 performs a step 404 of creating an unknown node representing the query. This unknown node can be stored in memory and include one or more classes, one or more constraints, and / or other parameters of the query. The unknown data node can represent an unknown consumption and / or unknown emission.

[0092] Evaluation engine 124 then performs a step 406 of computing emissions for a current node, which corresponds to the unknown node created in step 404. To do this, evaluation engine 124 performs a step 408 of scaling a functional unit of the currentPATENTAttorney Docket No.: VAYU0004PCnode to match a current context of the query. Because 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 needed at this point.

[0093] Evaluation engine 124 then performs a step 410 of determining whether the current node is unknown. This step 410 evaluates to true, so evaluation engine 124 performs a step 412 of applying matcher constraints to the current node, in which the current node is changed using relevant constraints specified in the query. Evaluation engine 124 then performs a step 414 of finding the most similar data nodes using the retrieved matcher constraints.

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

[0095] Evaluation engine 124 then performs a step 454 of matching attributes in the unknown data node to data nodes 222 in database 122. For example, evaluation engine 124 could perform step 454 by filtering nodes retrieved in step 452 by the attributes.

[0096] Evaluation engine 124 additionally performs a step 456 of matching a time in the unknown data node to data nodes 222 in database 122, followed by a step 458 of matching a location in the unknown data node to data nodes 222 in database 122. In each of steps 456 and 458, evaluation engine 124 can further filter data nodes 222 determined in previous steps by the corresponding constraint values. Evaluation engine 124 can also omit steps 454, 456, and / or 458 if the matcher constraints do not specify attributes, a time, and / or a location, respectively.PATENTAttorney Docket No.: VAYU0004PC

[0097] Evaluation engine 124 subsequently performs a step 460 of determining whether or not any matching data nodes are found. For example, evaluation engine 124 could determine that a given data node 222 in database 122 is a match if the class of the data node matches the class in the unknown data node and / or is a direct or indirect child of the class in the unknown data node. Evaluation engine 124 could also, or instead, determine that a given data node 222 in database 122 is a match if the location specified in the data node matches the location in the unknown data node and / or is a direct or indirect child of the location in the unknown data node. Evaluation engine 124 could also, or instead, determine that a given data node 222 in database 122 is a match if the attributes associated with the data node match the attributes specified in the unknown data node. If no data nodes 222 in database 122 match the attributes in the unknown data node, evaluation engine 124 could determine that all data nodes that match the class and location in the unknown data node are matching data nodes. Evaluation engine 124 could also, or instead, determine that a data node is a match if the time frame in the data node is the closest to the time specified in the unknown data node.

[0098] If one or more matching data nodes are found, evaluation engine 124 performs a step 464 to return the matching data nodes. For example, evaluation engine 124 could store the matching data nodes and corresponding relationships in one or more in-memory data structures. The matching data nodes can be stored under a root node corresponding to the query node and correspond to one or more sub-trees and / or paths in trees 224. Each sub-tree and / or path can include one or more data nodes that match the class, location, attributes, and / or time specified in the unknown data node. Each sub-tree and / or path can also, or instead, include one or more data nodes with classes and / or locations that “indirectly” match the class and / or location specified in the unknown data node (e.q., data nodes with classes and / or locations that are direct or indirect children of the class and / or location specified in the unknown data node). Each sub-tree and / or path can also, or instead, include additional data nodes that are dependencies (e.q., consumptions, productions, emissions, etc.) of the data node(s) that directly or indirectly match the class, location, attributes, and / or time specified in the unknown data node.PATENTAttorney Docket No.: VAYU0004PC

[0099] If no matching nodes are found, evaluation engine 124 performs a step 462 of matching to a parent class and / or location associated with the unknown data node. For example, evaluation engine 124 could change the location used to find matching data nodes to a parent location of the location in the unknown data node if the hierarchy of locations 208 in ontological plane 204 includes a parent location for the location in the unknown data node. Evaluation engine 124 could also, or instead, change the class used to find matching data nodes to a parent class of the class in the unknown data node if the ontology tree of classes 214 in ontological plane 204 includes a parent class for the class in the unknown data node.

[0100] Evaluation engine 124 then repeats steps 452, 454, 456, 458, and 460 with the parent class and / or location. Evaluation engine 124 can also repeat step 462 to further reduce the granularity associated with the matches until matching nodes are found. Evaluation engine 124 can then perform step 464 to return the matching data nodes.

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

[0102] While the operation of evaluation engine 124 in matching a given data node to similar data nodes has been described above with respect to steps 452, 454, 456, 458, 460, 462, and 464, it will be appreciated that evaluation engine 124 can use other techniques to determine similar data nodes for a given unknown data node. For example, evaluation engine 124 could compute similarity scores between the unknown data node and some or all data nodes 222 in database 122. A given similarity score between the unknown data node and another data node could include a weighted combination of similarity measures between properties (e.q., class, attributes, time, location, etc.) of the data node and corresponding properties of the other data node. These similarity measures could include (but are not limited to) vector similaritiesPATENTAttorney Docket No.: VAYU0004PCbetween embeddings of the properties, measures of semantic similarity between the properties, measures of similarity between tokens and / or strings in the properties, binary values denoting exact matches between the properties, and / or other measures computed between the properties of the data node and corresponding properties of the other data node. Evaluation engine 124 could rank data nodes 222 by descending similarity score and return a set of highest ranked data nodes 222 as the most similar nodes. In another example, evaluation engine 124 could use a clustering technique and / or machine learning model to identify the most similar nodes based on properties of the unknown data node and corresponding properties of other data nodes. In a third example, evaluation engine 124 could use one or more properties of the unknown data node as search terms and / or filters for other data nodes in database 122.

[0103] Returning to the discussion of Figure 4A, after evaluation engine 124 has found a set of similar nodes in step 414, evaluation engine 124 performs a step 416 of scaling attributes associated with the similar nodes. For example, evaluation engine 124 could determine scaling factors that can be used to convert yam density values specified in attributes of the similar nodes to a yam density value specified in a corresponding attribute of the unknown data node. These scaling factors could then be applied to energy consumptions and / or other calculations associated with the similar nodes.

[0104] Evaluation engine 124 then performs a step 418 that iterates over the similar nodes and repeats steps 406, 408, and 410 for each of the similar data nodes. If evaluation engine 124 determines at step 410 that a data node is not unknown, evaluation engine 124 performs a step 422 of applying any relevant data node constraints specified in the query to the data node. Evaluation engine 124 then performs multiple types of computations related to the data node.

[0105] As shown in Figure 4A, evaluation engine 124 performs a step 424 of computing consumptions associated with the data node. For example, evaluation engine 124 could compute emissions of all data nodes with which the data node has a consumption relationship. While computing consumptions, evaluation engine 124 canPATENTAttorney Docket No.: VAYU0004PCalso perform a step 426 of running a transform function on functional units associated with a given consumption relationship if the transform function is defined for the consumption relationship. Evaluation engine 124 can additionally perform a step 428 of scaling the functional units resulting from steps 424 and 426 to match the current context of the query. Evaluation engine 124 can then perform a step 430 to determine whether or not any of the consumptions are unknown. If this step 430 evaluates to true, evaluation engine 124 returns to step 412 so that each unknown consumption, as represented by an unknown data node, can be matched to similar data nodes with known consumptions.

[0106] Evaluation engine 124 also performs a step 432 of computing productions associated with the data node. For example, evaluation engine 124 could identify all data nodes with which the data node has a production relationship.

[0107] Evaluation engine 124 can also perform a step 434 of computing product allocations associated with the productions. In step 434, evaluation engine 124 can assign an economic value to one or more data nodes with which the data node has a production relationship.

[0108] For example, evaluation engine 124 could retrieve an economic value associated for each product of a process represented by the data node as a price from another data node representing the product. Evaluation engine 124 could use the economic value to allocate emissions of the process across all products of the process, so that the emissions allocated to a given product is proportional to the economic value of the product. Evaluation engine 124 could also, or instead, allocate emissions of the process evenly across the products and / or based on another technique. After productions and product allocations are computed for the data node, evaluation engine 124 can perform a step 436 of scaling the functional units resulting from steps 432 and 434 to match the current context of the query.

[0109] Evaluation engine 124 additionally performs a step 438 of determining whether or not a production associated with the data node has a negative economic value. Continuing with the above example, a negative economic value (e.q., a value of -PATENTAttorney Docket No.: VAYU0004PC1) can be assigned to a production relationship between the data node and another data node representing a product when the product is considered to be a waste product of the process represented by the data node.

[0110] When a negative economic value exists for a production associated with the data node, evaluation engine 124 performs a step 440 of computing waste allocations for the product. In step 440, evaluation engine 124 can allocate emissions of any processes consuming the product to the data node representing the production process of the product.

[0111] Finally, evaluation engine 124 can perform a step 442 of computing emissions for the data node. For example, evaluation engine 124 can aggregate emissions of the data node and all data nodes with which the data node has a production or consumption relationship. Evaluation engine 124 can then return to step 406 to repeat the process for additional data nodes.

[0112] After all unknown data nodes have been resolved into similar data nodes with known emissions and / or consumptions and emissions have been computed for these data nodes, evaluation engine 124 performs a step 444 of reporting results that include these emissions. For example, evaluation engine 124 could aggregate computations associated with multiple data nodes into total emissions, consumptions, productions, and / or other values for the entity represented by the query. Evaluation engine 124 could also, or instead, compute a breakdown of the total values into contributions of individual data nodes matched to the entity represented by the query.

[0113] The operation of evaluation engine 124 in Figures 4A and 4B can be illustrated using the following example query:Specifier :Class : ["Fuel Combustion" , "Diesel Combustion" ] # REQUIRED Attributes :- Name : TerrainValue : UrbanFunctionalUnit :PATENTAttorney Docket No.: VAYU0004PCValues :- Unit : 1Value : 2 .5Constraints :- Type : TimeValue :ForPath :Segments :- Class : ["Fuel"]At : ' 2022-01-01T20 : 00 : 00Z '

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

[0115] Upon receiving the query in step 402, evaluation engine 124 performs step 404 to create an in-memory virtual unknown data node representing the query. This unknown data node corresponds to a query node that includes the same properties (e.q., classes, attribute, functional unit, time constraint) as the query and indicates that consumptions and / or emissions associated with the entity are unknown.

[0116] Evaluation engine 124 performs step 406 to begin the process of computing emissions for the newly created “current” node. In particular, evaluation engine 124 performs 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 identical to the functional unit specified in the query, the functional unit of the current node is unchanged by step 406.

[0117] Evaluation engine 124 performs step 410 to determine whether or not the current node is unknown. Because step 410 evaluates to true, evaluation engine 124PATENTAttorney Docket No.: VAYU0004PCperforms step 412 to apply matcher constraints from the query to the unknown data node. To perform step 412, evaluation engine 124 iterates over constraints and determines if a “For” field is defined in each constraint. Evaluation engine 124 checks if the class of the current unknown data node matches the class specification in the “For” field. If a match is found, evaluation engine 124 applies the constraint. Because the time constraint specified in the query includes only a “ForPath,” field, no constraints related to a “For” field are applied.

[0118] Next, evaluation engine 124 checks if each constraint includes a “ForPath” field. If a given constraint includes the “ForPath” field, evaluation engine 124 determines if 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 specifying one “Segment” (e.q., a sub-tree in data plane 202) that includes a class name of “Fuel.” Evaluation engine 124 determines if the current unknown node matches this segment by determining whether the class of the current unknown node matches the class name of “Fuel.” If a match is found, evaluation engine 124 applies the constraint to the current unknown data node. Because the current unknown node has a class of “Diesel Combustion,” no match is found, and therefore the constraint is ignored.

[0119] Evaluation engine 124 then performs step 414 to match the current node to the most similar nodes in database 122. During this matching process, evaluation engine 124 performs step 452 to search database 122 for nodes that match the “Diesel Combustion” class or any sub-class of the “Diesel Combustion” class. Evaluation engine 124 determines, as a result of the search, that each of two sub-classes of “1 ,600 cc Motor Diesel Motor Operation” and “2000 cc Motor Diesel Motor Operation” is assigned to three data nodes 222, and that the three data nodes include attributes representing different terrains of “Rural,” “Urban,” and “Mountainous.” Because similar nodes were returned by the search, evaluation engine 124 does not step up to a parent class of the “Diesel Combustion” class to find less accurate matches. Additionally, because all matches are equally distant from the desired class (i.e., all matching nodes are one level removed from the “Diesel Combustion” class), all classes of the matchingPATENTAttorney Docket No.: VAYU0004PCdata nodes are treated as being equally relevant. Thus, no additional filtering of the matching nodes is performed using classes.

[0120] Next, evaluation engine 124 performs step 454 to match attributes of the matching data nodes with attributes in the current node. For each of the six matching data nodes returned by the search, evaluation engine 124 computes a score representing the extent to which the attributes associated with the data node match the attributes of the current unknown data node. Here, evaluation engine 124 computes the score based on the similarity between the terrain attribute of each returned data node and the “Urban” terrain attribute of the current unknown data node. In this example, evaluation engine 124 computes nonzero scores for the two data nodes that have the same “Urban” terrain attribute as the current node and belong to the “1 ,600 cc Motor Diesel Motor Operation” and “2000 cc Motor Diesel Motor Operation” classes, respectively. Evaluation engine 124 also computes scores of 0 for the remaining four data nodes returned in the search.

[0121] Evaluation engine 124 performs step 456 to match the time frames for the two matched data nodes to the time associated with the unknown data node. Because the unknown data node does not specify a time or time frame, both matched data nodes are treated as equally good matches in step 456.

[0122] Evaluation engine 124 also performs step 458 to match the locations of the two matched data nodes to the location associated with the unknown data node.Because the unknown data node does not specify a location, both matched data nodes are treated as equally good matches in step 458.

[0123] Evaluation engine 124 performs step 460 to determine that both data nodes with the “Urban” terrain attribute and the “1,600 cc Motor Diesel Motor Operation” and “2000 cc Motor Diesel Motor Operation” classes, respectively, are matches. Evaluation engine 124 then performs step 464 to return the two matching nodes.

[0124] After the two matching data nodes are returned in step 414, evaluation engine 124 performs step 416 to scale attributes of the returned data nodes. Because thesePATENTAttorney Docket No.: VAYU0004PCdata nodes do not include numeric attributes that can be scaled, this step 416 is skipped.

[0125] Evaluation engine 124 then performs step 418 to iterate over the two matching data nodes. Evaluation engine 124 begins with step 406 to compute emissions for the data node with the “1 ,600 cc Motor Diesel Motor Operation” class. Evaluation engine 124 proceeds 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 Motor Diesel Motor Operation” data node is set to 1 liter. As a result, evaluation engine 124 computes a scaling factor as the ratio of the functional unit for the query to the functional unit for the “1 ,600 cc Motor Diesel Motor Operation” data node, or 2.5. This scaling factor can then be applied to emissions, consumptions, and productions associated with the “1,600 cc Motor Diesel Motor Operation” data node.

[0126] Evaluation engine 124 performs step 410 to determine that the “1,600 cc Motor Diesel Motor Operation” data node is a known data node. Because the “1 ,600 cc Motor Diesel Motor Operation” data node is known, evaluation engine 124 proceeds to 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.

[0127] Evaluation engine 124 also performs steps 438 and 440 based on economic values for productions associated with the “1 ,600 cc Motor Diesel Motor Operation” data node. In this example, the “1 ,600 cc Motor Diesel Motor Operation” data node does not include productions with negative economic values, so no waste allocations are computed.

[0128] Evaluation engine 124 additionally performs steps 424, 426, and 428 to determine consumptions associated with the “1,600 cc Motor Diesel Motor Operation” data node. In this example, the data node includes a consumption relationship with a “Diesel” class that has an unknown consumption, so evaluation engine 124 determines in step 424 that consumptions should be computed for this data node. Evaluation engine 124 also skips step 426 because the unknown consumption does not have a transform function. Evaluation engine 124 then performs step 428 using the previouslyPATENTAttorney Docket No.: VAYU0004PCcomputed scale factor of 2.5 to convert the functional unit of 1 liter for the “1 ,600 cc Motor Diesel Motor Operation” data node into the 2.5-liter functional unit of the query.

[0129] Evaluation engine 124 determines in step 430 that the “Diesel” consumption associated with the “1,600 cc Motor Diesel Motor Operation” data node is unknown, and therefore creates another unknown data node representing the unknown consumption. This unknown data node includes properties (e.q., location and time) from the consuming “1,600 cc Motor Diesel Motor Operation” data node.

[0130] Evaluation engine 124 performs step 412 to apply 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 the query. As a result, evaluation engine 124 applies the time constraint to the unknown data node by setting the time of the unknown data node to “2022-01 -01 T20:00:00Z.”

[0131] Evaluation engine 124 performs step 414 to find data nodes that are similar to the unknown data node. In particular, 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 and are therefore determined to be equally similar to the unknown data node in step 454. In step 456, evaluation engine 124 determines that the first data node has a time set to “2021-01-01,” and the second data node has a time set to “2020-01 -01.” Because the first data node has a timestamp that is closer to the time specified in the time constraint, evaluation engine 124 determines that the first data node is more similar to the unknown data node.

[0132] In some embodiments, evaluation engine 124 matches a time constraint to multiple nodes if the difference in time across the data nodes is within 10% of the difference in time between the time constraint and time in the data nodes that is farthest from the time constraint. This allows the continuousness of the time dimension to be considered in determining similar nodes and can also prevent processing of a query to be overly sensitive to small differences in time. In this example, the times associated with the two data nodes are not within 10% of the two-year difference in time between the time specified in the time constraint and the time in the second data node. As aPATENTAttorney Docket No.: VAYU0004PCresult, evaluation engine 124 determines that only the first data node matches the time constraint.

[0133] In step 458, evaluation engine 124 determines that both data nodes have the same location of “World.” As a result, evaluation engine 124 does not make additional changes to the similarity of the data nodes to the unknown data node in step 458.Evaluation engine 124 then performs steps 460 and 464 to return the first data node as a matching data node.

[0134] Evaluation engine 124 skips step 416 for the returned data node because no attribute scaling is required. Evaluation engine 124 then performs step 418 to process the single returned data node. For this data node, 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 consumptions and specifies an emission of 100g CO2e per liter. This emission is scaled by the 2.5 scale factor to 250g CO2e per liter to complete computations for the “1 ,600 cc Motor Diesel Motor Operation” data node.

[0135] Evaluation engine 124 repeats the process with the “2,000 cc Motor Diesel Motor Operation” data node. More specifically, evaluation engine also performs steps 406, 408, 410, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, and 442 to compute an emission of 2,700 g CO2e for this data node.

[0136] Because evaluation engine 124 has now computed emissions for all data nodes matching the query node (i.e., the “1 ,600 cc Motor Diesel Motor Operation” data node and the “2,000 cc Motor Diesel Motor Operation” data node), evaluation engine 124 performs step 420 to average emissions from the data nodes into an overall emissions for the entity represented by the query. In this step, evaluation engine 124 can use a linear opinion pooling technique to combine distributions of emissions associated with the data nodes into a single distribution. For example, evaluation engine 124 could convert each distribution into a percentile distribution that stores 101 numbers between the 0 quantile and the 1 quantile. Evaluation engine 124 could convert each percentile distribution into a cumulative density function (CDF) and iterate over the CDFs of the two distributions. During each iteration, evaluation engine 124PATENTAttorney Docket No.: VAYU0004PCcomputes an arithmetic mean of the densities of the CDFs and sets the density of the combined distribution at the corresponding point to the arithmetic mean. Evaluation engine 124 could then convert the CDF for the combined distribution back into a percentile distribution.

[0137] After distributions for emissions associated with the similar data nodes are merged into a combined distribution of emissions for the query node, evaluation engine 124 determines an expected value of 2,650 g CO2e for the combined distribution.Evaluation engine 124 then performs step 444 to report results that include the expected value and / or combined distribution. The results can also, or instead, include a breakdown of the 2,650 g CO2e into an emission value for each of the two similar data nodes.

[0138] Figure 5 is a flow diagram of method steps for processing a query of an LCA database, according to various embodiments. Although the method steps are described in conjunction with the systems of Figures 1-2, persons 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.

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

[0140] In step 504, evaluation engine 124 stores an unknown data node representing the query in an in-memory tree structure. For example, evaluation engine 124 could create a “virtual” data node with an unknown consumption and / or unknown emission and initialize the tree structure with the virtual data node as root. Evaluation engine 124 could also set properties of the virtual data node to those specified in the query.PATENTAttorney Docket No.: VAYU0004PC

[0141] In step 506, evaluation engine 124 searches one or more hierarchical structures within the LCA database for data nodes that match some or all properties of the unknown data node. For example, evaluation engine 124 could determine the matching nodes based on exact matches, inexact matches, semantic matches, weighted combinations of matches, and / or other types of matches between properties of the data nodes in the LCA database and properties of the unknown data node.Evaluation engine 124 could also, or instead, prioritize matching of certain properties over matching of other properties.

[0142] In step 508, evaluation engine 124 stores the matching data nodes in the tree structure. For example, evaluation engine 124 could store the matching data nodes in one or more sub-trees under the root node representing the query.

[0143] In step 510, evaluation engine 124 computes emissions associated with the matching data nodes. For example, evaluation engine 124 could compute the emissions using functional units, transform functions, economic values, and / or other components of the matching data nodes and / or the query node. During step 510, evaluation engine 124 can encounter additional data nodes and / or relationships that are associated with unknown consumptions and / or unknown emissions. When an unknown consumption and / or unknown emission is encountered, evaluation engine creates another unknown data node representing the unknown consumption and / or unknown emission and adds the unknown data node to the tree.

[0144] In step 512, evaluation engine 124 determines whether or not unknown data nodes remain in the tree. For example, evaluation engine 124 could determine that unknown data nodes remain in the tree if one or more unknown data nodes were added to the tree during step 510. While unknown data nodes remain in the tree, evaluation engine 124 repeats steps 506, 508, and 510 for each unknown data node to resolve the corresponding unknown consumptions and / or unknown emissions using similar data nodes in the hierarchical structure(s). Evaluation engine 124 then repeats step 510 to determine if additional unknown data nodes exist in the tree.PATENTAttorney Docket No.: VAYU0004PC

[0145] Once evaluation engine 124 determines that all unknown data nodes in the tree have been resolved to similar data nodes with known emissions and / or consumptions, evaluation engine 124 performs step 514, in which evaluation engine 124 aggregates emissions associated with the matching data nodes into a result of the query. For example, evaluation engine 124 could combine distributions of emissions, productions, consumptions, and / or other values computed from the matching data nodes into corresponding distributions for the entity represented by the query.Evaluation engine 124 could return the combined distribution(s), representative values in the combined distribution(s) (e.q., means, medians, quantiles, minimums, maximums, etc.), and / or other representations of the combined distributions in the results.Evaluation engine 124 could also, or instead, generate a breakdown of the computed values and / or distributions into corresponding contributions of some or all nodes in the tree.

[0146] Finally, in step 516, evaluation engine 124 causes the result to be outputted in a response to the query. For example, evaluation engine 124 could transmit the results to a source of the query. Evaluation engine 124 could also, or instead, output the results in a user interface, file, report, and / or another representation. The results of this query and / or other queries of the database can then be analyzed to determine overall emissions, consumptions, and / or productions associated with the entity; identify “hotspots” that contribute disproportionately to the emissions, consumptions, and / or productions; determine product designs, manufacturing processes, sourcing of materials, policies, regulations, and / or other strategies or actions that reduce negative environmental impacts; conduct simulations and / or studies that assess and / or compare environmental impacts across different processes, products, consumptions, and / or entities; and / or otherwise understand and / or improve the environmental impacts associated with the entities.Caching for Query Processing Via a Planar Data Model

[0147] In some embodiments, database 122 and evaluation engine 124 include functionality to cache data related to LCA queries. As discussed in further detail below, this caching can be used to expedite data retrieval and / or reduce resource overheadPATENTAttorney Docket No.: VAYU0004PCassociated with processing the LCA queries. Additionally, components involved in this caching can be implemented together with and / or separately from database 122 and evaluation engine 124 on computing device 100 and / or additional computing devices. For example, caches associated with database 122 may be stored in storage 114 on one or more instances of computing device 100. These components may also, or instead, be loaded into memory 116 on the instance(s) for subsequent execution by one or more processors 102 on the instance(s).

[0148] Figure 6 illustrates a caching system 600 for database 122 of Figure 1 , according to various embodiments. More specifically, caching system 600 includes different types of caching components that can be used to expedite different aspects of data retrieval and / or query processing using database 122 and evaluation engine 124. These caching components include a request cache 602, a linear sub-tree cache 604, a nonlinear sub-tree cache 606, a memory store 608, and / or a query cache 610. Each of these caching components is described in further detail below.

[0149] Request cache 602 stores responses to queries of database 122 in a shared, in-memory key-value store. Cache keys for entries in request cache 602 may include hashes of queries and corresponding parameters (e.g., classes and / or constraints specified in the queries). In some embodiments, request cache 602 includes a time-to-live (TTL) mechanism and / or a least recently used (LRU) policy to handle invalidation and / or eviction of data. The version of database 122 may be included in the parameters of a given cache key to avoid request cache 602 from becoming stale. Request cache 602 can be used in situations where the number of unique queries is limited.

[0150] Linear sub-tree cache 604 stores consumptions, emissions, and / or other environmental impacts associated with data nodes and corresponding dependencies for LCA models that exhibit linear behavior. When a data node is encountered during processing of a query, linear sub-tree cache 604 may be checked to determine if an entry storing a corresponding environmental impact is available. For example, a lookup of linear sub-tree cache may be performed using an identifier for the data node to determine if a matching entry exists.PATENTAttorney Docket No.: VAYU0004PC

[0151] If an entry matching a data node is found in linear sub-tree cache 604, the environmental impact may be retrieved from the entry instead of being computed using the sub-tree corresponding to the data node. A ratio between the current functional unit associated with the query and the functional unit used to compute the cached environmental impact is calculated. The environmental impact is multiplied by that ratio, and the resulting values are used in the current context of the query.

[0152] Nonlinear sub-tree cache 606 stores consumptions, emissions, and / or other environmental impacts for sub-trees associated with LCA models that cannot be scaled linearly according to the corresponding functional units. Within nonlinear sub-tree cache 606, cache keys for entries may include the corresponding functional unit values. For example, nonlinear sub-tree cache 606 may include a query-local cache that is used when the same functional units are encountered for the same data nodes in different branches of the in-memory tree structure that is generated during processing of a query.

[0153] While evaluating a sub-tree of the in-memory tree structure, evaluation engine 124 determines whether a given LCA model is linear or not. Whenever a non-linear feature is detected, all downstream nodes in the sub-tree may be considered to be nonlinear.

[0154] In some embodiments, memory store 608 includes an in-memory cache of entries in database 122. For example, memory store 608 may be implemented within a runtime for evaluation engine 124 and act as a context-aware, ephemeral copy of database 122. Memory store 608 may also be segregated by database 122 instance and / or database 122 version. When a given instance of database 122 can be stored in full in memory (e.g., memory 116 of Figure 1), memory store 608 can be used as a replacement for database 122.

[0155] Memory store 608 may include various components that facilitate retrieval of entries in database 122. For example, memory store 608 may include a map of each node in database 122 and a set of associated properties. Memory store 608 may also,PATENTAttorney Docket No.: VAYU0004PCor instead, include one or more indexes that can be used to perform direct lookup of nodes (e.g., in lieu of performing a scan of the nodes).

[0156] In one or more embodiments, each function that loads data from database 122 includes a corresponding load and store procedure for memory store 608. This load and store procedure attempts to load from memory store 608 prior to loading from database 122 and updates memory store 608 after each query of database 122.

[0157] Memory store 608 may also, or instead, include an automatic update mechanism, in which each modification to data in database 122 implements and / or executes a method to apply the same change to memory store 608. This automatic update mechanism may thus keep memory store 608 up to date with database 122.

[0158] Memory store 608 may include a maximum age to accommodate use cases that involve iterative changes and / or continuous testing of database 122. This maximum age may ensure that memory store 608 is up to date while reducing overhead and / or latency associated with retrieving data from database 122.

[0159] Query cache 610 includes a one-to-one cache on instances of database 122. Within query cache 610, entries may be retrieved using parameters, database instances, and / or queries. In some embodiments, query cache 610 includes a shared in-memory key-value store.

[0160] Because each new instance of database 122 may initially have an empty memory store 608, database 122 can be overwhelmed during periods of rapid scaling (e.g., from single instances to hundreds of instances in minutes). In these circumstances, query cache 610 can act as an additional, more persistent cache to reduce load on database 122 and facilitate such scaling.

[0161] Figure 7 illustrates different types of sub-tree caches for database 122 of Figure 1, according to various embodiments. As shown in Figure 6, the sub-tree caches may reside in memory 116 and / or storage 114 and include a local sub-tree cache 704, a global sub-tree cache 706, and a persistent sub-tree cache 708. Each of these sub-treePATENTAttorney Docket No.: VAYU0004PCcaches can correspond to linear sub-tree cache 604 and / or nonlinear sub-tree cache 606.

[0162] Global sub-tree cache 706 is located in memory 116 and stores environmental impacts and / or other data that can be reused across queries. To manage memory consumption by global sub-tree cache 706 (e.g., when constraints have large variance across queries), global sub-tree cache 706 may include an LRU mechanism.

[0163] Local sub-tree cache 704 resides in runtime memory 702 for a given query and stores intermediate results of computations that are local to that query. Local subtree cache 704 may thus allow reuse of calculations within the lifetime of a single query. For example, when the same data node is encountered in different branches of the inmemory tree structure generated during processing of a query, local sub-tree cache 704 may provide previously computed environmental impacts for that data node. Local subtree cache 704 may additionally be cleared after the query completes.

[0164] Persistent sub-tree cache 708 may store computed environmental impacts for various sub-trees in a shared database within storage 114. Entries within this shared database may be reused across both queries and instances of database 122.

[0165] In one or more embodiments, each sub-tree cache uses hashing to compute unique cache keys for entries within the sub-tree cache. For example, during processing of a given query, parameters associated with a data node in the corresponding in-memory tree structure may be used to compute one or more hash values. As described in further detail below with respect to Figure 8, these hash values are used as unique identifiers for entries in one or more sub-tree caches, thereby allowing the entries to be retrieved using parameters for the corresponding data nodes.

[0166] Figure 8 illustrates how parameters associated with query 232 are used to perform a lookup of a sub-tree cache 820, according to various embodiments. Sub-tree cache 820 may include (but is not limited to) linear sub-tree cache 604, nonlinear sub-PATENTAttorney Docket No.: VAYU0004PCtree cache 606, local sub-tree cache 704, global sub-tree cache 706, and / or persistent sub-tree cache 708.

[0167] As shown in Figure 8, the parameters include (but are not limited to) a summary configuration 802, constraints 244, classes 242, and / or context parameters 804. Some or all of these parameters are converted into one or more hash values 810(1)-810(N) (each of which is referred to individually herein as hash value 810) using a hash technique (e.g., xxHash) and / or one or more hash functions. Each hash value 810 can then be used to perform a lookup of entries 808(1 )-808(N) (each of which is referred to individually as entry 808) in sub-tree cache 820.

[0168] More specifically, each hash value 810 may be compared with some or all cache keys 806(1 )-806(N) (each of which is referred to individually herein as cache key 806) in sub-tree cache 820. When a given hash value 810 matches a certain cache key 806, that cache key 806 is used to retrieve a corresponding entry 808 in sub-tree cache 820, and data stored in that entry 808 is used to resolve an unknown consumption, emission, and / or environmental impact associated with a data node and / or sub-tree used to process query 232.

[0169] Summary configuration 802 defines a result of query 232 as a summary that includes a grouping of environmental impacts into stages (e.g., life cycle stages, arbitrarily defined stages, etc.) associated with an entity. Each stage within summary configuration 802 includes a path within a tree structure that represents a specific part of an LCA model. A given summary configuration can be reused (e.g., as summary configurations can be generated automatically by downstream systems and / or across a set of entities and / or queries). For example, the same summary configuration 802 may be used with similar LCA models, materials of a customer, stock keeping units (SKUs) in a catalog, similar products, and / or other entities with similar and / or related life cycles. In another example, a given summary configuration 802 may be specified for multiple entities included in in one or more queries that can be processed in bulk and / or in one or more batches. During this type of bulk and / or batch processing, data nodes associated with that summary configuration 802 may be cached and reused (e.g., withinPATENTAttorney Docket No.: VAYU0004PCthe same query, across multiple queries, with the same entity, with different entities, etc.).

[0170] To compute a summary as a result of query 232, evaluation engine 124 may compress sub-trees in the in-memory tree structure to the minimum number of nodes specified by summary configuration 802. Because intermediate nodes that don’t have a direct impact on the summary are removed during this compression, different summary configurations may be considered to be incompatible. Consequently, sub-tree cache keys 806 (and the corresponding entries 808) may be differentiated by stages, paths, identifiers, and / or other attributes of summary configuration 802 to avoid interference with one another.

[0171] In one or more embodiments, certain nodes are evaluated during the summarization process in a context-dependent manner. More specifically, a path that partially matches a given position in the in-memory tree structure may have a different effect on the corresponding sub-tree than in other positions. For example, node X may be cached in the path A^B^X, a summary stage may match B^Z, and X may include Z in its sub-tree. Because B^Z is a partial match for A^B^X, the summary stage may be added to a part of the cache key for X that specifies partial matches. When the path is A^D^X, the same summary stage might not match the current context path and therefore is unlikely to have a context-dependent effect on this instance of X.Consequently, this summary stage may be added to a part of a corresponding cache key 806 that includes (or is based on) summary configuration 802 and omitted from the part of that cache key 806 that includes the partial match.

[0172] While summary configurations can be stable, constraints 244 may change on a per-query basis. For example, shipments may specify float-based distances that are unique numbers as constraints, and products may include component weights.Consequently, using a hash of all query and / or data node constraints 244 as cache key 806 for a given entry 808 may reduce the efficacy of the sub-tree cache, as any change in constraints 244 may cause that cache key 806 to no longer match hash values 810PATENTAttorney Docket No.: VAYU0004PCcomputed from constraints 244 (even when the change does not affect the output of the data node represented by that entry 808).

[0173] Further, constraints 244 are typically applied to a specific position within an LCA model. For example, an LCA model in branch A^B^C may be affected by a path for B^C, while another branch A^X^C may be unaffected by the same path. In this case, cached results for sub-tree C cannot be reused across these two paths.

[0174] In one or more embodiments, reusability of cached results across paths that are potentially affected by constraints is determined by checking for a partial match. In the above example, because C is first executed in the context of A— >B, C would be marked as potentially being affected by a constraint, whereas C in the context of A— >X would not be marked as such. These partial matches are then used as part of the Bloom filter mechanism described below.

[0175] Sub-tree cache 820 entries 808 with constraints 244 that do not constitute partial matches in the given context may also be separated. These constraints 244 are applied at some point inside a given sub-tree and are included in the corresponding cache key 806. Conversely, to determine that a given constraint is not applied within a sub-tree for which a cached entry 808 exists, a Bloom Filter (or another type of probabilistic set membership data structure that allows for false positives but not false negatives) can be used to check whether one or more paths might be applicable to that sub-tree.

[0176] In particular, classes 242 in a sub-tree and / or path affected by a constraint can be used to populate a Bloom filter that is included in a corresponding cache key 806. The Bloom filter may be generated while descending a sub-tree. For each node that can be put into sub-tree cache 820, a new Bloom filter is created, and each class and corresponding parent classes (e.g., from ontological plane 204) are added to the Bloom filter (e.g., as one or more hash values 810). When a given data node is encountered while ascending the tree structure, the previous data node (e.g., a child node of the given data node) is computed or loaded from sub-tree cache 820, and thePATENTAttorney Docket No.: VAYU0004PCBloom filter for the previous data node is merged with the Bloom filter for the given data node.

[0177] For example, a first Bloom filter for a data node representing washing machine operation may be merged with a second Bloom filter for a parent data node representing electricity mix into a Bloom filter representing an electricity use phase. When a constraint that specifies the number of times a garment is washed is applied to the washing machine operation data node, one or more hash values 810 for washing machine operation are compared to bits in the Bloom filter for the electricity use phase. Because this Bloom filter includes hashes for washing machine operation, the constraint is determined to potentially affect the electricity use phase model. Further down the path same, another Bloom filter for electricity mix is used to determine that the constraint does not affect the corresponding model.

[0178] In some embodiments, Bloom filters are stored in a separate cache, in which corresponding cache keys 806 may omit constraints 244. The classes in a given entry 808 may depend on the corresponding constraints 244, since a constraint is capable of changing inputs and pulling in a class tree that would otherwise not be included in the corresponding sub-tree. For example, one constraint may add an input B to form A— >B, another constraint may add an input C to that to form A^B^C, and a third constraint may modify C. If query 232 is executed before the second constraint adds C, the third constraint modifying C would fail to be detected as being part of entry 808 for A.Further, such conditionally interdependent constraints may fail to be detected statically by examining query 232.

[0179] Consequently, constraints 244 that are detected as potentially applicable to a given data node are stored in an additional Bloom filter for that data node. That Bloom filter can then be used to check the applicability of these constraints. When a Bloom filter lookup fails, the corresponding entry 808 can be assumed to not have been computed with these constraints. When more than one conditionally interdependent constraint exists, it can be difficult to look up the Bloom filter indicating that only one ofPATENTAttorney Docket No.: VAYU0004PCthe constraints has been applied. In this case, the Bloom filter can indicate that the constraints may be applicable.

[0180] In some embodiments, a Bloom filter is created for each data node encountered during processing of query 232 and stored in global memory for reuse across queries. Because the Bloom filter cache can grow to a significant size (e.g., due to the high number of entries (-10000) that can be stored in a given Bloom filter), a LRU cache eviction strategy can be used to manage memory consumption by the Bloom filters. The Bloom filters may also, or instead, be omitted to balance the tradeoff between increased memory consumption and increased query-processing performance.

[0181] In one or more embodiments, input and output constraints that can change the shape of an LCA model are added to a cache key for the corresponding Bloom filter. A valueless hash may be created on these constraints, so that the corresponding Bloom filter can be reused when functional units change. The cache keys may include a concatenation of an identifier for the data node and hash values 810 of the input and output constraints. To ensure that the same key is generated with queries that have different orderings of the same constraints, the constraints and corresponding hash values 810 are sorted alphabetically.

[0182] When a Bloom filter is not available for a given entry 808, that entry 808 can be created to include all relevant constraints. These constraints can be omitted from the corresponding cache key 806 to avoid changes to that cache key 806.

[0183] In some embodiments, context parameters 804 include a time, location, attributes of a data node consuming another, and / or other parameters related to the current context of query 232 and / or one or more data nodes that are resolved during processing of query 232. These context parameters 804 may be included in cache keys 806 for entries 808 storing cached results for these data node(s).

[0184] In some embodiments, a Cuckoo filter (or another type of probabilistic set membership data structure that allows for false positives but not false negatives) is used to track repeated and / or systematic misses in sub-tree cache 820. These misses canPATENTAttorney Docket No.: VAYU0004PCoccur due to rules related to nonlinearity in certain data nodes and / or other conditions that prevent caching of data in certain data nodes.

[0185] For example, an in-memory Cuckoo filter may be maintained over the lifetime of a given query 232 and checked prior to performing a lookup of sub-tree cache 820. When a given set of parameters results in a cache miss during a lookup of sub-tree cache 820, the parameters are added to the Cuckoo filter (e.g., using one or more hash values 810 of the parameters). When the same set of parameters is subsequently encountered, the Cuckoo filter returns a hit, and the corresponding data node to be recomputed instead of performing another lookup of sub-tree cache 820. When subtree cache 820 is updated with an entry 808 for a given sub-tree, hash values 810 corresponding to the sub-tree are deleted from the Cuckoo filter.

[0186] A Cuckoo filter (or another type of probabilistic set membership data structure that allows for false positives but not false negatives) may also, or instead, be used to store cache keys 806 that are known to exist in sub-tree cache 820 (e.g., during a given runtime of evaluation engine 124) and “disqualify” certain parameters and / or types of parameters from lookup of sub-tree cache 820. For example, the Cuckoo filter may be used to disqualify a lookup of sub-tree cache 820 for queries that include summary configurations that have not been seen before.

[0187] Figure 9 is a flowchart of method steps for processing a query of an LCA database, according to various embodiments. Although the method steps are described in conjunction with the systems of Figures 1-2, persons 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.

[0188] In step 902, evaluation engine 124 receives a query that includes parameters specifying properties of an entity. For example, evaluation engine 124 could receive a query that specifies one or more classes associated with the entity, one or more constraints associated with properties and / or dependencies of the entity, a summary configuration, and / or one or more context parameters.PATENTAttorney Docket No.: VAYU0004PC

[0189] In step 904, evaluation engine 124 stores an unknown data node representing the query in an in-memory tree structure. For example, evaluation engine 124 may create a “virtual” data node with an unknown consumption and / or unknown emission and initialize the tree structure with the virtual data node as root. Evaluation engine 124 may also set properties of the virtual data node to the parameters specified in the query.

[0190] In step 906, evaluation engine 124 determines whether or not the unknown data node has been matched to an entry in a cache. For example, evaluation engine 124 may compute one or more hash values using the summary configuration, constraints, classes, and / or context parameters associated with the query and / or unknown data node. Evaluation engine 124 may compare the hash values with cache keys in one or more sub-tree caches, such as (but not limited to) a local sub-tree cache, a global sub-tree cache, and / or a persistent sub-tree cache. Evaluation engine 124 may determine that the unknown data node is matched to an entry in the cache when a hash value matches a cache key associated with the entry.

[0191] If the unknown data node is matched to an entry in the cache in step 906, evaluation engine 124 performs step 916, in which evaluation engine 124 computes environmental impacts associated with the unknown data node using the entry. For example, evaluation engine 124 may retrieve functional units associated with consumptions, emissions, and / or other environmental impacts from the entry. For linear LCA models, evaluation engine 124 may compute a ratio between the current functional unit associated with the query and the functional unit used to compute the cached environmental impact and multiply the environmental impact by that ratio. For nonlinear models, evaluation engine 124 may use the environmental impact directly when the functional unit values match.

[0192] Prior to performing a lookup of the cache using parameters associated with the unknown data node, evaluation engine 124 may optionally use a Cuckoo filter and / or another type of set membership data structure to determine if the parameters previously resulted in a cache miss and / or the parameters exclude caching of the dataPATENTAttorney Docket No.: VAYU0004PCnode (e.g., due to nonlinearity and / or other conditions). If the set membership data structure indicates that the parameters are likely to result in a cache miss, cache lookup using the parameters may be omitted.

[0193] If the unknown data node is not matched to an entry in the cache and / or is determined to likely result in a cache miss, evaluation engine 124 performs step 908, in which evaluation engine 124 searches the LCA database for data nodes that match some or all properties of the unknown data node. For example, evaluation engine 124 may determine the matching nodes based on exact matches, inexact matches, semantic matches, weighted combinations of matches, and / or other types of matches between properties of data nodes in hierarchical structures within the LCA database and properties of the unknown data node. Evaluation engine 124 could also, or instead, prioritize matching of certain properties over matching of other properties.

[0194] In step 910, evaluation engine 124 stores the matching data nodes in the tree structure. For example, evaluation engine 124 could store the matching data nodes in one or more sub-trees under the root node representing the query. Each sub-tree may include one or more data nodes that match the class, location, attributes, and / or time specified in the unknown data node, as well as additional data nodes that are dependencies of the matching data nodes.

[0195] In step 912, evaluation engine 124 computes environmental associated with the matching data nodes. For example, evaluation engine 124 may compute emissions, consumptions, productions, waste product allocations, and / or other values using functional units, transform functions, economic values, and / or other components of the matching data nodes and / or the query node. During step 912, evaluation engine 124 can encounter additional data nodes and / or relationships that are associated with unknown consumptions and / or unknown emissions. When an unknown consumption and / or unknown emission is encountered, evaluation engine creates another unknown data node representing the unknown consumption and / or unknown emission and adds the unknown data node to the tree.PATENTAttorney Docket No.: VAYU0004PC

[0196] In step 914, evaluation engine 124 stores the environmental impacts in the cache based on conditions associated with the data nodes. For example, evaluation engine 124 may determine whether a given sub-tree exhibits linear or nonlinear behavior and store the corresponding environmental impacts in a linear sub-tree cache or a nonlinear sub-tree cache, respectively. Evaluation engine 124 may also compute cache keys using hash values derived from summary configurations, constraints, classes, and / or context parameters associated with the data nodes. Evaluation engine 124 may store the environmental impacts in a local sub-tree cache for reuse within the current query, a global sub-tree cache for reuse across queries, and / or a persistent subtree cache for reuse across both queries and database instances. In another example, evaluation engine 124 may omit storing of environmental impacts associated with a given data node in a cache based on nonlinearity and / or other conditions that interfere with reuse of the environmental impacts.

[0197] After evaluation engine 124 has resolved environmental impacts associated with a given data node using the cache or LCA database, evaluation engine 124 performs step 918, in which evaluation engine 124 determines whether or not unknown data nodes remain in the tree. For example, evaluation engine 124 could determine that unknown data nodes remain in the tree if one or more unknown data nodes were added to the tree during step 910.

[0198] While unknown data nodes remain in the tree, evaluation engine 124 repeats step 906 for each unknown data node. More specifically, evaluation engine 124 performs step 906 to determine whether the unknown data node can be resolved using the cache. If the unknown data node can be matched to an entry in the cache, evaluation engine 124 computes environmental impacts using the entry. If no match is found, evaluation engine 124 performs steps 908, 910, 912, and 914 to search the LCA database for matching data nodes, compute environmental impacts using the matching data nodes, and selectively store the environmental impacts in the cache. Evaluation engine 124 then repeats step 918 to determine if additional unknown data nodes exist in the tree.PATENTAttorney Docket No.: VAYU0004PC

[0199] Once evaluation engine 124 determines that all unknown data nodes in the tree have been resolved to similar data nodes with known emissions and / or consumptions, evaluation engine 124 performs step 920, in which evaluation engine 124 aggregates emissions associated with the matching data nodes into a result of the query. For example, evaluation engine 124 may combine distributions of emissions, productions, consumptions, and / or other values computed from the matching data nodes into corresponding distributions for the entity represented by the query.Evaluation engine 124 may return the combined distribution(s), representative values in the combined distribution(s) (e.q., means, medians, quantiles, minimums, maximums, etc.), and / or other representations of the combined distributions in the results.Evaluation engine 124 may also, or instead, generate a breakdown of the computed values and / or distributions into corresponding contributions of some or all nodes in the tree. Evaluation engine 124 may also, or instead, generate a summary of environmental impacts for one or more stages associated with the entity.

[0200] In step 922, evaluation engine 124 causes the result to be outputted in a response to the query. For example, evaluation engine 124 could transmit the results to a source of the query. Evaluation engine 124 could also, or instead, output the results in a user interface, file, report, and / or another representation.

[0201] As discussed above, a given query may be received as a single query and / or included in a batch of related queries (e.g., different types of queries associated with the same entity, queries of multiple entities with the same summary configuration, one query specifying multiple entities and / or sets of parameters, etc.). During single and / or batch processing of these queries, steps 902-922 may be performed to compute emissions, consumptions, and / or other environmental impacts using matching data nodes and / or subtrees from the life cycle assessment database and / or entries in various caches associated with the life cycle assessment database. When a query and / or a portion of a query can be resolved using an entry from a cache, latency and / or resource overhead associated with processing the query using data nodes in the life cycle assessment database can be reduced.PATENTAttorney Docket No.: VAYU0004PC

[0202] In sum, the disclosed techniques perform caching for query processing via a planar data model in an LCA database. The planar data model includes a data plane that stores data nodes representing products, processes, emissions, consumptions, and / or other entities that are used to perform LCA. The data nodes can be organized within one or more trees to represent dependencies and / or relationships between or among the data nodes. The planar data model also includes a separate ontological plane that stores metadata associated with data nodes in the data plane. This metadata includes (but is not limited to) sources, timeframes, locations, classes, and / or attributes associated with data in the data nodes. The ontological plane and data plane are interconnected to allow emissions, consumptions, productions, and / or other quantities associated with the entities to be aggregated, related to one another, compared, and / or otherwise used to evaluate environmental impacts associated with the entities.

[0203] An LCA for a given entity can be performed by executing a query that specifies properties of the entity against the database. For example, the query may be used to analyze the environmental impact of a product, process, service, organization, and / or another entity. To process the query, metadata stored in the ontological plane is used to match parameters of the query to data nodes in the data plane. The matching data nodes are stored in an in-memory tree structure, and emissions, consumptions, productions, waste products, and / or other types of environmental impact data associated with the entity are computed by traversing paths of the matching data nodes within the tree structure and aggregating, scaling, and / or otherwise transforming functional units stored in the matching data nodes.

[0204] To streamline processing of LCA queries, one or more caches store emissions, consumptions, and / or other types of data related to environmental impacts for specific data nodes and / or sub-trees composed of data nodes. Each entry in a cache is associated with a cache key that is computed from parameters associated with a corresponding data node and / or sub-tree. These parameters may include (but are not limited to) a summary configuration, a set of classes, a set of constraints, and / or a set of context parameters. When a data node with an unknown emission, consumption,PATENTAttorney Docket No.: VAYU0004PCand / or another type of environmental impact is encountered during traversal of the inmemory tree structure, some or all of these parameters associated with the data node can be used to perform a lookup of a cache, and the environmental impact can be resolved using an entry with a cache key that matches the parameters instead of requiring further traversal of the sub-tree represented by the data node.

[0205] One technical advantage of the disclosed techniques relative to the prior art is a reduction in resource overhead and latency over conventional approaches that process LCA queries by retrieving, aggregating, and / or otherwise processing data associated with a large number of nodes in an LCA database. Another technical advantage of the disclosed techniques is the ability to match parameters of a query to entries in a cache in a context-dependent manner. In particular, the disclosed techniques can be used to determine whether or not a cached environmental impact can be reused with a subsequent query involving the same data node and / or sub-tree, thereby allowing caching techniques to be used with LCA databases that include planar data models and / or complex hierarchical structures. These technical advantages provide one or more technological improvements over prior art approaches.

[0206] 1. In some embodiments, a computer-implemented method for processing a query of a life cycle assessment database comprises searching one or more hierarchical structures included in the life cycle assessment database for a first set of data nodes that match a first set of parameters that is (i) included in the query and (ii) specifies one or more properties of an entity; upon determining that a data node included in the first set of data nodes includes an unknown consumption or an unknown emission matching a second set of parameters associated with the data node to an entry in a cache associated with the life cycle assessment database; and computing one or more environmental impacts associated with the entity based on a functional unit that is (i) included in the entry and (ii) includes a quantity associated with the unknown consumption or the unknown emission; and causing the one or more environmental impacts to be outputted in a response to the query.PATENTAttorney Docket No.: VAYU0004PC

[0207] 2. The computer-implemented method of clause 1 , further comprising prior to receiving the query, searching the one or more hierarchical structures for a second set of data nodes that matches the second set of parameters associated with the data node; computing an emission ora consumption based on a set of functional units included in the second set of data nodes; and storing, in the cache, the entry that includes the emission or the consumption.

[0208] 3. The computer-implemented method of any of clauses 1 -2, further comprising prior to searching the one or more hierarchical structures for the second set of data nodes, determining that the second set of parameters does not match any existing entries in the cache based on a lookup of a set membership data structure.

[0209] 4. The computer-implemented method of any of clauses 1 -3, further comprising deleting one or more values corresponding to the second set of parameters from the set membership data structure after the entry has been stored in the cache.

[0210] 5. The computer-implemented method of any of clauses 1 -4, further comprising storing the first set of data nodes in an in-memory tree structure; and determining that the data node includes the unknown consumption or the unknown emission during a traversal of one or more paths within the in-memory tree structure.

[0211] 6. The computer-implemented method of any of clauses 1 -5, wherein the inmemory tree structure comprises a root node that (i) represents the query and (ii) includes the first set of parameters; and one or more nodes that (i) correspond to one or more sub-trees under the root node and (ii) match at least a portion of the one or more properties.

[0212] 7. The computer-implemented method of any of clauses 1 -6, wherein the entry corresponds to a sub-tree that is (i) included the in-memory tree structure and (ii) includes the data node as a root node.

[0213] 8. The computer-implemented method of any of clauses 1 -7, wherein computing the one or more environmental impacts comprises computing a ratio between a current functional unit associated with the query and the functional unitPATENTAttorney Docket No.: VAYU0004PCincluded in the entry; and scaling an environmental impact output included in the entry by the ratio.

[0214] 9. The computer-implemented method of any of clauses 1 -8, wherein matching the second set of parameters to the entry comprises computing one or more hashes associated with the second set of parameters; and performing one or more lookups of the cache using the one or more hashes.

[0215] 10. The computer-implemented method of any of clauses 1-9, wherein the second set of parameters comprises at least one of an identifier for the data node; a path that includes the data node and one or more additional data nodes from the first set of data nodes; a grouping of consumptions or emissions associated with the path; one or more classes included in the path; and a modification to data included in the data node or the one or more additional data nodes.

[0216] 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 steps of searching one or more hierarchical structures included in a life cycle assessment database for a first set of data nodes that match a first set of parameters that is (i) included in a query and (ii) specifies one or more properties of an entity; and upon determining that a data node included in the first set of data nodes includes an unknown consumption or an unknown emission searching the one or more hierarchical structures for a second set of data nodes that matches a second set of parameters associated with the data node; computing an emission or a consumption based on a set of functional units included in the second set of data nodes, wherein each functional unit included in the set of functional units includes a quantity associated with the unknown consumption or the unknown emission; and store, in a cache associated with the life cycle assessment database, the emission or the consumption in an entry associated with the second set of data nodes, wherein the entry is subsequently used to compute one or more environmental impacts associated with the entity.PATENTAttorney Docket No.: VAYU0004PC

[0217] 12. The one or more non-transitory computer-readable media of clause 11 , wherein after the entry is stored in the cache, the instructions further cause the one or more processors to perform the steps of matching at least a portion of the second set of parameters to the entry in the cache; computing the one or more environmental impacts associated with the entity based on a functional unit that is included in the entry; and causing the one or more environmental impacts to be outputted in a response to the query.

[0218] 13. The one or more non-transitory computer-readable media of any of clauses 11-12, wherein the instructions further cause the one or more processors to perform the step of verifying that the emission or the consumption is eligible to be stored in the cache prior to storing the emission or the consumption in the cache.

[0219] 14. The one or more non-transitory computer-readable media of any of clauses 11-13, wherein the instructions further cause the one or more processors to perform the step of generating a cache key for the entry based on (i) a path of data nodes within the one or more hierarchical structures and (ii) a grouping of consumptions or emissions associated with the path.

[0220] 15. The one or more non-transitory computer-readable media of any of clauses 11-14, wherein the instructions further cause the one or more processors to perform the step of generating a cache key for the entry by populating a set membership data structure with one or more classes included in the data node and one or more additional nodes in a tree structure that includes the first set of data nodes.

[0221] 16. The one or more non-transitory computer-readable media of any of clauses 11-15, wherein the instructions further cause the one or more processors to perform the step of generating an additional cache key by populating an additional set membership data structure with one or more constraints that modify data included in the data node and the one or more additional nodes.

[0222] 17. The one or more non-transitory computer-readable media of any of clauses 11-16, wherein the instructions further cause the one or more processors toPATENTAttorney Docket No.: VAYU0004PCperform the step of generating a cache key for the entry based on an identifier for the data node and at least one of a modification to an input to the data node or a modification to an output of the data node.

[0223] 18. The one or more non-transitory computer-readable media of any of clauses 11-17, wherein the one or more hierarchical structures comprise a data plane comprising (i) a plurality of data nodes representing a plurality of entities associated with life cycle assessment and (ii) a plurality of edges between pairs of data nodes included in the plurality of data nodes and represent relationships between pairs of entities included in the plurality of entities; and an ontological plane storing metadata associated with the plurality of data nodes.

[0224] 19. The one or more non-transitory computer-readable media of any of clauses 11-18, wherein the entry corresponds to at least one of a response to a previous instance of the query or an in-memory copy of the data node from the life cycle assessment database.

[0225] 20. In some embodiments, a system comprises one or more memories that store instructions, and one or more processors that are coupled to the one or more memories and, when executing the instructions, are configured to perform the steps of receiving one or more queries specifying (i) a plurality of entities and (i) a summary configuration comprising a grouping of consumptions or emissions into one or more stages; processing a query included in the one or more queries by searching one or more hierarchical structures included in a life cycle assessment database for a first set of data nodes that match a first set of parameters that is (i) included in the query and (ii) specifies one or more properties of a corresponding entity; and resolving an unknown consumption or an unknown emission associated with a data node included in the first set of data nodes by matching at least one of (i) a path associated with the data node or (ii) the one or more stages to an entry in a cache associated with the life cycle assessment database; and computing one or more environmental impacts associated with the entity based on a functional unit that is (i) included in the entry and (ii) includes a quantity associated with the unknown consumption or the unknown emission; andPATENTAttorney Docket No.: VAYU0004PCcausing the one or more environmental impacts to be outputted in a response to the query.

[0226] Any and all combinations of any of the claim elements recited in any of the claims and / or any elements described in this application, in any fashion, fall within the contemplated scope of the present invention and protection.

[0227] The descriptions of the various embodiments have been presented for purposes of illustration, but are not intended to be exhaustive or limited to the embodiments disclosed. 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.

[0228] Aspects of the present embodiments 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, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “module,” a “system,” or a “computer.” In addition, any hardware and / or software technique, process, function, component, engine, module, or system described in the present disclosure may be implemented as a circuit or set of circuits. Furthermore, aspects of the present disclosure may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon.

[0229] Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium 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 would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memoryPATENTAttorney Docket No.: VAYU0004PC(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. 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.

[0230] Aspects of the present disclosure are described above with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the disclosure. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations 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. The instructions, when executed via the processor of the computer or other programmable data processing apparatus, enable the implementation of the functions / acts specified in the flowchart and / or block diagram block or blocks. Such processors may be, without limitation, general purpose processors, special-purpose processors, application-specific processors, or field-programmable gate arrays.

[0231] The flowchart 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 diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block 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 the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and / or flowchart illustration, andPATENTAttorney Docket No.: VAYU0004PCcombinations of blocks in the block diagrams and / or flowchart illustration, 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.

[0232] While the preceding is directed to embodiments of the present disclosure, other and further embodiments of the disclosure may be devised without departing from the basic scope thereof, and the scope thereof is determined by the claims that follow.

Claims

PATENTAttorney Docket No.: VAYU0004PCWHAT IS CLAIMED IS:

1. A computer-implemented method for processing a query of a life cycle assessment database, comprising:searching one or more hierarchical structures included in the life cycle assessment database for a first set of data nodes that match a first set of parameters that is (i) included in the query and (ii) specifies one or more properties of an entity;upon determining that a data node included in the first set of data nodes includes an unknown consumption or an unknown emission:matching a second set of parameters associated with the data node to an entry in a cache associated with the life cycle assessment database; andcomputing one or more environmental impacts associated with the entity based on a functional unit that is (i) included in the entry and (ii) includes a quantity associated with the unknown consumption or the unknown emission; andcausing the one or more environmental impacts to be outputted in a response to the query.

2. The computer-implemented method of claim 1 , further comprising:prior to receiving the query, searching the one or more hierarchical structures for a second set of data nodes that matches the second set of parameters associated with the data node;computing an emission ora consumption based on a set of functional units included in the second set of data nodes; andstoring, in the cache, the entry that includes the emission or the consumption.

3. The computer-implemented method of claim 2, further comprising prior to searching the one or more hierarchical structures for the second set of data nodes, determining that the second set of parameters does not match any existing entries in the cache based on a lookup of a set membership data structure.PATENTAttorney Docket No.: VAYU0004PC4. The computer-implemented method of claim 3, further comprising deleting one or more values corresponding to the second set of parameters from the set membership data structure after the entry has been stored in the cache.

5. The computer-implemented method of claim 1 , further comprising:storing the first set of data nodes in an in-memory tree structure; and determining that the data node includes the unknown consumption or the unknown emission during a traversal of one or more paths within the inmemory tree structure.

6. The computer-implemented method of claim 5, wherein the in-memory tree structure comprises:a root node that (i) represents the query and (ii) includes the first set of parameters; andone or more nodes that (i) correspond to one or more sub-trees under the root node and (ii) match at least a portion of the one or more properties.

7. The computer-implemented method of claim 5, wherein the entry corresponds to a sub-tree that is (i) included the in-memory tree structure and (ii) includes the data node as a root node.

8. The computer-implemented method of claim 1 , wherein computing the one or more environmental impacts comprises:computing a ratio between a current functional unit associated with the query and the functional unit included in the entry; andscaling an environmental impact output included in the entry by the ratio.

9. The computer-implemented method of claim 1 , wherein matching the second set of parameters to the entry comprises:64PATENTAttorney Docket No.: VAYU0004PCcomputing one or more hashes associated with the second set of parameters; andperforming one or more lookups of the cache using the one or more hashes.

10. The computer-implemented method of claim 1 , wherein the second set of parameters comprises at least one of:an identifier for the data node;a path that includes the data node and one or more additional data nodes from the first set of data nodes;a grouping of consumptions or emissions associated with the path;one or more classes included in the path; anda modification to data included in the data node or the one or more additional data nodes.

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 steps of:searching one or more hierarchical structures included in a life cycle assessment database for a first set of data nodes that match a first set of parameters that is (i) included in a query and (ii) specifies one or more properties of an entity; andupon determining that a data node included in the first set of data nodes includes an unknown consumption or an unknown emission:searching the one or more hierarchical structures for a second set of data nodes that matches a second set of parameters associated with the data node;computing an emission ora consumption based on a set of functional units included in the second set of data nodes, wherein each functional unit included in the set of functional units includes a quantity associated with the unknown consumption or the unknown emission; and65PATENTAttorney Docket No.: VAYU0004PCstoring, in a cache associated with the life cycle assessment database, the emission or the consumption in an entry associated with the second set of data nodes, wherein the entry is subsequently used to compute one or more environmental impacts associated with the entity.

12. The one or more non-transitory computer-readable media of claim 11 , wherein after the entry is stored in the cache, the instructions further cause the one or more processors to perform the steps of:matching at least a portion of the second set of parameters to the entry in the cache;computing the one or more environmental impacts associated with the entity based on a functional unit that is included in the entry; andcausing the one or more environmental impacts to be outputted in a response to the query.

13. The one or more non-transitory computer-readable media of claim 11 , wherein the instructions further cause the one or more processors to perform the step of verifying that the emission or the consumption is eligible to be stored in the cache prior to storing the emission or the consumption in the cache.

14. The one or more non-transitory computer-readable media of claim 11 , wherein the instructions further cause the one or more processors to perform the step of generating a cache key for the entry based on (i) a path of data nodes within the one or more hierarchical structures and (ii) a grouping of consumptions or emissions associated with the path.

15. The one or more non-transitory computer-readable media of claim 11 , wherein the instructions further cause the one or more processors to perform the step of generating a cache key for the entry by populating a set membership data structure with66PATENTAttorney Docket No.: VAYU0004PCone or more classes included in the data node and one or more additional nodes in a tree structure that includes the first set of data nodes.

16. The one or more non-transitory computer-readable media of claim 15, wherein the instructions further cause the one or more processors to perform the step of generating an additional cache key by populating an additional set membership data structure with one or more constraints that modify data included in the data node and the one or more additional nodes.

17. The one or more non-transitory computer-readable media of claim 11 , wherein the instructions further cause the one or more processors to perform the step of generating a cache key for the entry based on an identifier for the data node and at least one of a modification to an input to the data node or a modification to an output of the data node.

18. The one or more non-transitory computer-readable media of claim 11 , wherein the one or more hierarchical structures comprise:a data plane comprising (i) a plurality of data nodes representing a plurality of entities associated with life cycle assessment and (ii) a plurality of edges between pairs of data nodes included in the plurality of data nodes and represent relationships between pairs of entities included in the plurality of entities; andan ontological plane storing metadata associated with the plurality of data nodes.

19. The one or more non-transitory computer-readable media of claim 11 , wherein the entry corresponds to at least one of a response to a previous instance of the query or an in-memory copy of the data node from the life cycle assessment database.

20. A system, comprising:one or more memories that store instructions, andPATENTAttorney Docket No.: VAYU0004PCone or more processors that are coupled to the one or more memories and, when executing the instructions, are configured to perform the steps of: receiving one or more queries specifying (i) a plurality of entities and (i) a summary configuration comprising a grouping of consumptions or emissions into one or more stages;processing a query included in the one or more queries by: searching one or more hierarchical structures included in a life cycle assessment database for a first set of data nodes that match a first set of parameters that is (i) included in the query and (ii) specifies one or more properties of a corresponding entity; andresolving an unknown consumption or an unknown emission associated with a data node included in the first set of data nodes by:matching at least one of (i) a path associated with the data node or (ii) the one or more stages to an entry in a cache associated with the life cycle assessment database; andcomputing one or more environmental impacts associated with the corresponding entity based on a functional unit that is (i) included in the entry and (ii) includes a quantity associated with the unknown consumption or the unknown emission; andcausing the one or more environmental impacts to be outputted in a response to the query.

Images