Flexible environmental impact query generation and result presentation

Abstract

One embodiment of the present invention sets forth a technique for processing a query of a life cycle assessment database. The technique includes receiving a component definition for a component associated with a product and generating the query based on one or more extractors included in the component definition, wherein each of the one or more extractors includes (i) a path defining a set of data nodes in the life cycle assessment database and (ii) a query expression that is used to read one or more properties from the set of data nodes. The technique also includes executing the query to generate one or more extractor results based on the one or more properties read from the set of data nodes. The technique further includes converting the one or more extractor results into one or more environmental impacts associated with the component.

Description

FLEXIBLE ENVIRONMENTAL IMPACT QUERY GENERATION AND RESULT PRESENTATIONCROSS-REFERENCE TO RELATED APPLICATIONS

[0001] This application claims the benefit of the U.S. Provisional Application titled “FLEXIBLE ENVIRONMENTAL IMPACT QUERY GENERATION AND RESULT PRESENTATION,” filed on March 7, 2024, and having Serial No. 63 / 562,617. The subject matter of this application is hereby incorporated herein by reference in its entirety.BACKGROUNDField of the Various Embodiments

[0002] Embodiments of the present disclosure relate generally to databases and query processing and, more specifically, to flexible environmental impact query generation and result presentation.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] An LCA study is typically conducted by an LCA specialist using specialized LCA software tools and LCA databases that house environmental data related to various processes and materials. The LCA specialist typically follows a systematic and standardized sequence of steps, beginning with a “goal and scope definition” step that establishes the purpose, breadth, depth, and boundaries of the LCA study. Next, the LCA specialist performs a “life cycle inventory” step that involves collecting datarelated to inputs (e.q., raw materials and energy) and outputs (e.q., emissions and waste) across the life cycle of the entity in question. This data forms the crux of the assessment and is often gathered from various sources, including direct measurements, literature, and the LCA databases. Subsequently, the LCA specialist uses the LCA tools to perform a “life cycle impact assessment” step that aggregates and / or transforms the data into the environmental impacts. Finally, the LCA specialist engages in an “interpretation” step that involves evaluating and verifying the results, drawing conclusions, and providing recommendations for improving the environmental impacts.

[0005] However, current LCA tools and databases tend to lack granularity and specificity, which can negatively impact the accuracy of the results. For example, inaccurate and / or incomplete data from an LCA database could cause an LCA tool to compute inaccurate emissions for a given entity. These inaccurate emissions could prevent the LCA tool from identifying “hotspots” within the life cycle of the entity that contribute more to emissions, energy consumption, and / or other environmental impacts. The LCA studies could also, or instead, inaccurately identify portions of the life cycle as hotspots when these portions do not contribute significantly to the environmental impacts of the entity. In another example, inaccurate and / or incomplete data could cause an LCA tool to generate results indicating that a first process has a lower environmental impact than a second process, when the first process has a higher environmental impact than the second process. Decisions or actions that rely on these results could prioritize use of the first process over use of the second process, thereby causing an unintended increase in environmental impacts.

[0006] Newer LCA tools provide user interfaces that allow non-specialized users to conduct LCA studies by inputting data and / or measurements related to different stages in the life cycles of various types of entities. However, these LCA tools operate using predefined rigid workflows and require certain data points to be provided before the requisite environmental impacts can be assessed and evaluated. Consequently, these LCA tools can lack the ability to perform LCA for life cycles that are represented using varying amounts, types, and / or granularities of data.

[0007] As the foregoing illustrates, what is needed in the art are more effective techniques for performing LCA.BRIEF DESCRIPTION OF THE DRAWINGS

[0008] 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.

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

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

[0011] Figure 3 illustrates an example schema associated with the ontological plane of Figure 2, according to various embodiments.

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

[0013] 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.

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

[0015] Figure 6 illustrates the process of generating a query associated with the database of Figure 1 , according to various embodiments.

[0016] Figure 7 illustrates the process of generating a result of a query that is processed using the database and evaluation engine of Figure 1 , according to various embodiments.

[0017] Figure 8 is a flow diagram of method steps for generating a query of a life cycle assessment database, according to various embodiments.

[0018] Figure 9 is a flow diagram of method steps for generating a result of a query of a life cycle assessment database, according to various embodiments.DETAILED DESCRIPTION

[0019] 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

[0020] 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 practicing one or more embodiments. Computing device 100 is configured to run a database 122 and an evaluation engine 124 that reside in a memory 116.

[0021] 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.

[0022] 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 othertype of processing unit, or a 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.

[0023] 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, a universal 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.g., 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.

[0024] 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.

[0025] 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.

[0026] 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 programsthat can be executed by processor(s) 102 and application data associated with said software programs, including database 122 and evaluation engine 124.

[0027] 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 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.

[0028] 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

[0029] 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 hierarchicallyorganized within a number of trees 224(1 )-224(X) (each of which is referred to individually herein as tree 224).

[0030] 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 obtained from 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.

[0031] 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.

[0032] 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.

[0033] 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 anda product represented by the second data node 222 could indicate that the product is produced by the process.

[0034] A given data node 222 representing a process additionally includes one or more emission relationships that represent emissions of the process. Each emission relationship 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.

[0035] 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.

[0036] 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.

[0037] 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 two functional units that do not have the same reference unit could return an error and / or fail.

[0038] 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.

[0039] 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 one-dimensional representation can be used to model environmental impacts for a linear system, the same representation would fail to yield accurate results for a nonlinear 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.

[0040] 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 to normalize a functional unit for a given data node 222 that is specified in centimeters with a consumption that is specified in meters.

[0041] 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.g., an emissions calculation) of a given LCA evaluation instead of being combined with other functional units used to generate the result.

[0042] 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.

[0043] 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.

[0044] 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.

[0045] 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.

[0046] 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.

[0047] 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.).

[0048] 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 Resource Locator (URL), citation, etc.) of the data, and / or additional information related to the source.

[0049] 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 classcould include a name and one or more aliases with the same semantic meaning as the name.

[0050] 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.

[0051] 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.

[0052] 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.”

[0053] 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.

[0054] 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).

[0055] 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.g., a minimum length or circumference to a maximum length or circumference).

[0056] 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.

[0057] 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 a given 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.

[0058] 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.

[0059] 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_TIMEFRAME” relationship with another node 304 that specifies a time framefor 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.

[0060] 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.

[0061] 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.

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

[0063] 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.

[0064] 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.

[0065] 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).

[0066] 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.g., discrete values, continuous values, multidimensional values, etc.) of the units, and / or a type of node or record in database 122 (e.g., 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 total weight of 200 grams, has a precursor with total emissions of 1 kg of CO2e, and / or includes cotton yarn that was produced via a ring spinning technique.

[0067] 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.

[0068] For example, input constraints can include the following definition: type Inputconstraint struct { Sub j ect Specifier Inputs [ ] InputspecificationFunctionalUnit *unit . FunctionalUnit } type Inputspecification struct { Is ClassSpecifierFunctionalUnit unit . FunctionalUnit Replace boolReplaceSub j ect *ClassSpecif ierDelete boolAdd bool}

[0069] 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.

[0070] 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.

[0071] 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.

[0072] 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 { Sub j ectSpecifier Emits [ ] carbongraph . Emission }

[0073] 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.

[0074] An example emission constraint within the list can include the following representation:{"Type: "Emission","Value": {"ForPath": { "Segments": [{ "Class": ["Example"] }] }, "Emits": [{"Gas": "C02e","Value": 12,}] ,}}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.

[0075] 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,} ••• type 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>, }> }

[0076] 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.

[0077] The above definition indicates that a given constraint can represent an “Input” constraint, a “Process” constraint, an “Emission” constraint, and / or another type of constraint. Each type of constraint includes a property named “ForPath,” which is a locator that specifies a “Path” within a tree (e.g., 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.

[0078] 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.g., class), location, time, functional unit, and / or other properties associated with the corresponding entity and / or constraint.

[0079] 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.

[0080] 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 : g Value : 200 Constraints :- 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 : year Value: 1- Type: ProcessFor: ["Cotton Cultivation"] Process :In: ["India"]- Type: EmissionFor: ["Cotton Jersey"] Emission :Gas: CO2eFunctionalUnit :- Unit : kg Value: 1- Type: ProcessFor: ["Cotton Yarn Spinning"] Process :Is: ["Ring Spinning", "Cotton Yarn Spinning"]

[0081] 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 query additionally 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 afractional functional unit of 0.8, which is multiplied with the functional unit associated with the consumable(s).

[0082] 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.

[0083] 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.”

[0084] 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 1 kg for the emitted gas.

[0085] The fifth constraint is a process constraint for a “Cotton Yarn 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 Yarn Spinning.”

[0086] 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.

[0087] 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 or more trees 224 of data nodes 222 within database 122, as described in further detail below with respect to Figures 4A and 4B.

[0088] 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 query232. 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.

[0089] 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.

[0090] 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.

[0091] 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 current node 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.

[0092] 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. Evaluationengine 124 then performs a step 414 of finding the most similar data nodes using the retrieved matcher constraints.

[0093] 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.

[0094] 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.

[0095] 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.

[0096] 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 coulddetermine 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.

[0097] 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.

[0098] 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.

[0099] 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.

[0100] 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.

[0101] 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 similarities between 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.

[0102] 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 yarn 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 thenbe applied to energy consumptions and / or other calculations associated with the similar nodes.

[0103] 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.

[0104] 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 can also 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.

[0105] 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.

[0106] 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.

[0107] 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 usethe 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.

[0108] 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 -1 ) 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.

[0109] 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.

[0110] 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.

[0111] 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.

[0112] 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 : Terrain Value : UrbanFunctionalUnit :Values :- Unit : 1Value : 2 . 5Constraints :- Type : TimeValue :ForPath :Segments :- Class : [ "Fuel" ]At : ’ 2022-01-01T20 : 00 : 00Z ’

[0113] 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.

[0114] 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.

[0115] 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 thefunctional unit specified in the query, the functional unit of the current node is unchanged by step 406.

[0116] Evaluation engine 124 performs step 410 to determine whether or not the current node is unknown. Because step 410 evaluates to true, evaluation engine 124 performs 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.

[0117] 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 subtree 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.

[0118] 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 subclasses 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 matching data nodes are treated as being equally relevant. Thus, no additional filtering of the matching nodes is performed using classes.

[0119] 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.

[0120] 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.

[0121] 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.

[0122] 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.

[0123] 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 these data nodes do not include numeric attributes that can be scaled, this step 416 is skipped.

[0124] 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.

[0125] 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.

[0126] 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.

[0127] 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 previously computed 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.

[0128] Evaluation engine 124 determines in step 430 that the “Diesel” consumption associated with the “1 ,600 cc Motor Diesel Motor Operation” data nodeis 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.

[0129] 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.”

[0130] 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.

[0131] 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 a result, evaluation engine 124 determines that only the first data node matches the time constraint.

[0132] 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.

[0133] 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.

[0134] 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.

[0135] 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 124 computes 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.

[0136] 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, orinstead, include a breakdown of the 2,650 g CO2e into an emission value for each of the two similar data nodes.

[0137] 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.

[0138] 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.

[0139] 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.

[0140] 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.

[0141] 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.

[0142] 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.

[0143] 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.

[0144] 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.

[0145] 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, outputthe 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.Flexible Environmental Impact Query Generation and Result Presentation

[0146] In some embodiments, database 122 and evaluation engine 124 include functionality to operate within a framework for flexible query generation and result presentation for various types of environmental impact assessment. As discussed in further detail below, this flexible query generation and result presentation allows LCA queries to be processed in a manner that is agnostic to specific categories of environmental impacts and / or data formats associated with external primary data and / or nodes within database 122.

[0147] Additionally, components involved in this flexible query generation and result presentation 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, components used to perform flexible query generation and result presentation could be stored in storage 114 on one or more instances of computing device 100. These components could also 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 the process of generating a query 232 associated with the database of Figure 1 , according to various embodiments. As shown in Figure 6, the process includes the use of a product specification 602 and one or more component definitions 604.

[0149] Product specification 602 includes a definition and / or representation of a product for which environmental impacts are to be computed. For example, productspecification 602 could include the class of the product. The class could be manually specified or estimated and / or determined based on information related to the product from a corresponding product detail page (e.g., on a website). Product specification 602 could also include additional metadata related to the product, such as (but not limited to) a brand, material composition, country of origin, certifications (e.g., organic, etc.), name, description, variant, color, size, weight, attributes, price, functional unit, guality, state (e.g., whether the product is a secondhand or previously used product, an overstock product, sold at a discount, repaired or refurbished, etc.), and / or number of days the product has been in a warehouse.

[0150] Component definitions 604 include definitions and / or representations of data formats associated with product components 606 that make up the product and / or facility components 608 representing facilities that are used to manufacture the product and / or individual product components 606. In some embodiments, one or more component definition languages can be used to generate a generic component definition for a given component. This component definition can include a schema for the component, rules for generating records 610 based on these properties, extractors that are used to guery nodes and validate the schema, and logic that specifies how the results of the extractors are mapped back onto properties of the component. Component definitions 604 are described in further detail below with respect to Figure 7.

[0151] Product components 606 and facility components 608 include primary data for the corresponding products and facilities, respectively. For example, a product component could include names, descriptions, and / or metadata related to precursors of the product and / or parts within the product. In another example, a facility component could include the amount of electricity (or another resource) consumed by a corresponding facility, processes carried out by the facility, and / or specific technologies used at the facility. Each of product components 606 and facility components 608 can include data and / or fields that are formatted according to a corresponding component definition.

[0152] An example set of product components 606 for a “Footwear” product includes the following:["product Id": "acbbl7ef-3240-4b2f-959a-e36a9e33fc55","component Id": "8dcdb3f8-lfe8-438f-99ff-95c7fb35905d", "component": {"id" : "8dcdb3f 8-lf e8 -438 f- 99f f -95c7 fb35905d" ,"title": "Footwear ABC123","type": "Footwear","value": {"Type": "Footwear","Title": "Footwear ABC123","Facility" : "c6dcaf76-ec5f-482f-9957-9603ac55ea76","IsGlobal": false},"children" : [{"id" : "5 Of 05e30-510c-4cd7-ac7c-bf 32020d4ca9","title": "Insole ABC123","type": "Footwearinsole","value": {"Type": "Footwearinsole","Title": "Insole ABC123","Weight": "9","IsGlobal": false},"children" : [{"id" : "cl5bd6eb-59ae-4a00-8b7e-lbd95a25blcf ","title": "Sockliner","type": "InsoleMaterial","value": {"Name": "Textile","Type": "InsoleMaterial","Title": "Sockliner","Weight": "2","IsGlobal": false},"children": []},"id" : "d3c96493-35c8-4409-8469-703ce848892f ","title": "Sockliner foam","type": "InsoleMaterial","value": {"Name": "EVA Plastic","Type": "InsoleMaterial","Title": "Sockliner foam","Weight": "7","IsGlobal": false},"children": []},{"id" : "8fe8716a-lle6-479c-86b3-cb79feac4b0d","title": "Laminating","type": "InsoleProcess " ,"value": {"Name": "Footwear Lamination","Type": "InsoleProcess","Title": "Laminating","IsGlobal": false},"children": []}]},{"id" : "8d604 c92-7 Oaf -4 c64-b2d5-d70el5e7e774 " ,"title": "Upper ABC123","type": "FootwearUpper","value": {"Type": "FootwearUpper","Title": "Upper ABC123","Facility" : "c6dcaf76-ec5f-482f-9957-9603ac55ea76","IsGlobal": false,"Total eight": "241""children" : ["id" : "ee4560bl-0cad-4bb2-8247-7f 9d7f 73c308 ","title": "Tongue","type": "FootwearUpperPart","value": {"Name": "Textile","Type": "FootwearUpperPart","Title": "Tongue","Weight": "2","Facility" : "6171ce8c-e6df-434b-9ef 8-7322a405eb72 ","IsGlobal": false,"UpperSection": "Tongue"},"children": []},{"id" : "f 4aa673f-77a6-4 f 0 l-b046- 9f 30e3bccf c2 " ,"title": "Tongue Lining","type": "FootwearUpperPart","value": {"Name": "Textile","Type": "FootwearUpperPart","Title": "Tongue Lining","Weight": "6","Facility" : "3cf c96bc-ba7e-4460-bf 79-8695824 Of 968 " ,"IsGlobal": false,"UpperSection": "Tongue"},"children": []},{"id" : "205ce4fa-8039-4e64-b5a4-3f 49d89de0ba","title": "Vamp","type": "FootwearUpperPart","value": {"Name": "Textile","Type": "FootwearUpperPart","Title": "Vamp","Weight": "200","Facility" : "c6dcaf76-ec5f-482f-9957-9603ac55ea76","IsGlobal": false,"UpperSection": "Vamp"},"children": []},{"id" : "ca669dc9-768e-43cb-a5b9- 95427ccb3112 " ,"title": "Tongue Padding","type": "FootwearUpperPart","value": {"Name": "Polyurethane","Type": "FootwearUpperPart","Title": "Tongue Padding","Weight": "2","Facility" : "9ff 406c7-0el6-4092-b361-e9556fd581a0","IsGlobal": false,"UpperSection": "Tongue"},"children": []},{"id" : "ld62f 602-3382-49fa-b88f-fd7elb42900e","title": "Quarter","type": "FootwearUpperPart","value": {"Name": "Textile","Type": "FootwearUpperPart","Title": "Quarter","Weight": "4","Facility" : "7ec29925-aa91-4f f 8-a42c-bd69dfa0e4fc","IsGlobal": false,"UpperSection": "Vamp"},"children": []{"id" : "823 lel34-f 8a8 -4b07-8 f 6d-b03b298bl 993 " ,"title": "Quarter reinforcement","type": "FootwearUpperPart","value": {"Name": "Non-woven fabric","Type": "FootwearUpperPart","Title": "Quarter reinforcement","Weight": "2","Facility" : "213180d4-aa6b-4247-9a7c-b34e2a2895fe","IsGlobal": false,"UpperSection": "Vamp"},"children": []},{"id" : "f 2be72f b- 6016-4269-b5d3-ad4164d33950 " ,"title": "Toe Reinforcement","type": "FootwearUpperPart","value": {"Name": "Recycled PU","Type": "FootwearUpperPart","Title": "Toe Reinforcement","Weight": "4","Facility" : "213180d4-aa6b-4247-9a7c-b34e2a2895fe","IsGlobal": false,"UpperSection": "Toe"},"children": []},{"id" : "f 592f 219-0489-4067-bb32-3a56c77dae62 ","title": "Heel Foam","type": "FootwearUpperPart","value": {"Name": "Polyurethane","Type": "FootwearUpperPart","Title": "Heel Foam","Weight": "6","Facility" : "7ec29925-aa91-4f f 8-a42c-bd69dfa0e4fc","IsGlobal": false,"UpperSection": "Heel"},"children": []},{"id" : "3c0652f 5-5aae-49ef-a4a8-9a6cb57ed445 " ,"title": "Collar Lining","type": "FootwearUpperPart","value": {"Name": "Textile","Type": "FootwearUpperPart","Title": "Collar Lining","Weight": "4","IsGlobal": false,"UpperSection": "Collar"},"children": []},{"id" : "3900caa4-8ela-47df-a5ee-e28760cble71 " ,"title": "Collar Foam","type": "FootwearUpperPart","value": {"Name": "Recycled PU","Type": "FootwearUpperPart","Title": "Collar Foam","Weight": "7","IsGlobal": false,"UpperSection": "Collar"},"children": []},{"id" : " 98113f23-2639-4133-9055-c3c06419dle7","title": "Upper Assembly","type" : "FootwearUpperProcess","value": {"Name": "Die-cutting and Sewing, Footwear","Type" : "FootwearUpperProcess","Title": "Upper Assembly","Facility" : "c6dcaf76-ec5f-482f-9957-9603ac55ea76","IsGlobal": false},"children": []}]},{"id" : "bf 19a05 f-7191-427a-bf 48-318704b57855 " ,"title": "Midsole ABC123","type": "FootwearMidsole " ,"value": {"Type": "FootwearMidsole","Title": "Midsole ABC123","Weight": "140","Facility" : "9ff 406c7-0el6-4092-b361-e9556fd581a0","IsGlobal": false},"children" : [{"id" : "486643a8-3fa7-4dl2-9fcl-fac5bllf 030b","title": "Recycled PU Foam","type": "MidsoleMaterial " ,"value": {"Name": "Recycled PU","Type": "MidsoleMaterial","Title": "Recycled PU Foam","Weight": "140","Facility" : "213180d4-aa6b-4247-9a7c-b34e2a2895fe","IsGlobal": false},"children": []},{"id" : "2d0a69cc-ead8-4bel-8419-f 04cfeclc948 ","title": "Compression Moulding","type": "MidsoleProcess","value": {"Name": "Compression Moulding, Footwear","Type": "MidsoleProcess","Title": "Compression Moulding","Facility" : "9ff 406c7-0el6-4092-b361-e9556fd581a0","IsGlobal": false},"children": []}]},{"id" : "7 If 87126-8664 -43f 1-ae 91-803df c2cc715 " ,"title": "Outsole ABC123","type": "FootwearOutsole " ,"value": {"Type": "FootwearOutsole","Title": "Outsole ABC123","Weight": "110","Facility" : "213180d4-aa6b-4247-9a7c-b34e2a2895fe","IsGlobal": false},"children" : [{"id" : "f 670dcb8-lcl4 -485d-aab9- 93f 596936433 " ,"title": "Injection Moulding","type": "OutsoleProcess " ,"value": {"Name": "Injection Moulding, Footwear","Type": "OutsoleProcess","Title": "Injection Moulding","Facility" : "213180d4-aa6b-4247-9a7c-b34e2a2895fe","IsGlobal": false},"children" : [ ]} ,{"id" : "220b6e5a-b28a-4 f 6a-8 c99-43aaa3c08d24 " ,"title" : "Natural Rubber" , "type" : "OutsoleMaterial" , "value" : {"Name" : "Secondary Natural Rubber Products" ,"Type" : "OutsoleMaterial" , "Title" : "Natural Rubber" , "Weight" : "110" , "IsGlobal" : false , "Standards" : [ "Organic"] } , "children" : [ ] } ]}]}}]

[0153] More specifically, the example set of product components 606 includes a first product component that represents the product and has a title (e.q., name) of “Footwear ABC123” and a type of “Footwear.” The first product component also includes a number of values (e.q., data elements) related to the product. These values include the title, the type, an identifier for a facility associated with the manufacture and / or storage of the component, and an “IsGlobal” Boolean value. The facility identifier can be used to retrieve one or more facility components 608 associated with the facility identifier. These facility components 608 may specify primary data related to the facility, such as (but not limited to) the amount of a resource (e.q., electricity, water, etc.) consumed by the facility, the amount of a certain waste generated by the facility, processes conducted at the facility, and / or technologies used at the facility.

[0154] The example set of product components 606 also includes a first level of “children” corresponding to additional product components 606 that make up the product. Each product component includes a unique identifier, a title (e.q., “Insole ABC123,” “Sockliner,” “Sockliner foam,” “Laminating,” “Upper ABC123,” “Tongue,” etc.), and a type (e.q., “Footwearinsole,” “InsoleMaterial,” “InsoleProcess,” “FootwearUpper,” “FootwearUpperPart,” etc.). Each product component also includes a set of associated values (e.q., data elements), which include the title, type, and additional data related to the product component (e.q., a weight, a name, a facility identifier, etc.).

[0155] The example set of product components 606 also includes a second level of “children” below the first level of children. This second level of children includes product components 606 representing materials, manufacturing processes, and / or other types of information related to product components 606 in the first level of children. Consequently, product components 602 may be organized within multiple levels of a hierarchy to denote inclusion of a component in the product and / or another component, manufacturing of a component at a certain facility, and / or other relationships.

[0156] In some embodiments, data from product specification 602, product components 606, and / or facility components 608 is used to populate one or more records 610. Records 610 correspond to an intermediate data format between formats associated with input primary data included in product specification 602, product components 606, and / or facility components 608 and formats associated with secondary data in database 122. This intermediate format allows the query generation process to be adapted to changes to data formats associated with product specification 602 and / or component definitions 604, as well as to changes to data formats and / or query processing associated with evaluation engine 124 and / or database 122. One or more records 610 can also, or instead, be used directly as a primary data source, in lieu of or in addition to one or more records 610 that are generated from product components 606 and / or facility components 608.

[0157] In some embodiments, records 610 provide similar functionality to constraints and adhere to a predefined (e.q., intermediate) format. For example, a data structure for defining a record includes the following:interface Record { path: Path inputs: Array< { Subject: Array<string>, ReplaceSub ect : Array<string>, ... }> attributes: Array< { Id: Uuid, Values: Array<{ Name: string, Value : any }> }> functionalUnits? : Array<FunctionalUnit> / / reference unit emits: Array<{ Gas: string, FunctionalUnit : FunctionalUnit }> facilityld?: string}The above data structure includes a “Path” that defines specific nodes (e.q., nodes 222) within the data model associated with database 122. The data structure also specifies changes to be made to those nodes. These changes can be applied to inputs, attributes, functional units, emissions, facilities, and / or other components of the data nodes.

[0158] Using the above data structure, an example record that is used to set the location of a process includes the following:{"facilityld" : "6844cc06-01db-48d3-bc4a-483faa7ee784 ","path" : {"sparseMatch" : true,"segments": [{"class": ["Products " ,"Clothing" ,"Footwear" ,"Sneakers / Trainers " , "Sports Trainers", "Running Shoes",] ,"location" : null},{"class" : ["Production Process" , "Apparel Assembly" , "Footwear Assembly" , "Shoes Assembly" ] , "location" : null } } ]} ,"attributes" : [ ]}

[0159] More specifically, the example record above includes a facility identifier for a facility at which the process takes place. The example record also includes a path that is used to set the location of data nodes associated with various classes of products (e.g., “Products,” “Clothing,” “Footwear,” “Sneakers / Trainers,” “Sports Trainers,” “Running Shoes”) and processes (e.g., “Production Process,” “Apparel Assembly,” “Footwear Assembly,” “Shoes Assembly”) to a null value.

[0160] Using the above data structure, another example record that is used to change a “Fiber / Material” attribute to “Cotton” for classes of “Cargo Transport,” “Last Mile Delivery,” and “Customer Self-Pickup” includes the following:{"description" : "Description 1" ,"path" : {"sparseMatch" : true ,"segments" : [{"class" : ["Cargo Transport" ,"Last Mile Delivery" ,"Customer Self-Pickup"] , } ]},"attributes": [{"name": "Fiber / Material" ,"values": ["Cotton"]}]}

[0161] Using the above data structure, another example record that is used to modify an input constraint associated with the impact assessment of a product from production (e.g., gate) to disposal (e.g., grave) includes the following:"description": "Gate-to-grave set to 0","functionalUnit" : { "values": [{"unit": "kg","value": 1,}] },"inputs": [{"path" : {"sparseMatch" : true,"segments": [{"class": ["Use-Phase " ,"Footwear care"]}]},"functionalUnit": { "value": [{"unit": "kg","value": 0}] }},{"path" : {"sparseMatch" : true,"segments": [{"class": ["End of Life Products","End of life footwear"]}]},"functionalUnit" : { "value": [{"unit": "kg","value": 0}] }}]"outputs " : [ ] ,"path" : {"sparseMatch": true,"segments": [{"class": ["Products "]}]},"attributes": []

[0162] The example record above specifies a functional unit of 1 kg that is used in an environmental impact assessment. The record also includes a number of inputs that describe various modifications to the impact assessment during different phases of the lifecycle of the product. These inputs indicate that a functional unit of 0 kg is to be used with process classes of “Use-Phase” and “Footwear care” and product classes of “End of Life Products” and “End of life footwear.” The record additionally includes an empty set of outputs, which indicates that no specific outputs or emissions are to be generated. The record further specifies an empty set of attributes for all data nodes associated with the “Products” class. Consequently, this record can be used to specify that a functional unit of 1 kg for certain phases related to the use, care, and end of life of one or more products is to be replaced with a functional unit of O kg.

[0163] In some embodiments, different component definitions 604, product components 606, facility components 608, and / or records 610 are specified for different LCA and / or environmental impact assessment use cases associated with a given product. Each use case can be associated with a different source of primary data and / or entity (e.q., group of users, organization, role, brand, stakeholder, etc.). For example, a use case for a payment gateway provider entity could involve performing a high-level environmental impact assessment for a certain class of product that is handled by the payment gateway provider. A use case for an entity that includes a supply chain manager for a company could involve performing LCA for a product from the company based on detailed supply chain information for that product. A use case for an entity that includes developers or designers of a product could involve estimating environmental impacts associated with various decisions or changes related to the design of the product. Environmental impacts associated with each use case may be generated using a corresponding set of primary data, component definitions, and / or records for the use case.

[0164] After records 610 are generated from product specification 602, product components 606, and / or facility components 608, records 610 are used to generate query 232. For example, records 610 could be used in a similar fashion to constraints to modify assumptions and / or values associated with LCA models and / or other components or data stored in database 122. Records 610 could also, or instead, beused to generate constraints (e.g., constraints 244) within query 232. Query 232 can then be processed by evaluation engine 124 using the techniques described above.

[0165] Figure 7 illustrates the process of generating a result of a query (e.g., query 232) that is processed using database 122 and evaluation engine 124 of Figure 1 , according to various embodiments. As shown in Figure 7, a component definition 704 for a given component (e.g., a product component, facility component, etc.) specifies one or more extractors 706 that are used to derive values associated with the component from a computation result. These extractors 706 are passed in the query to evaluation engine 124, and results (e.g., results 246) of the query are combined with component definition 704 into a component representation 708 that is outputted and / or presented to an entity (e.g., a user and / or organization for which the query is generated and / or executed to perform LCA).

[0166] As discussed above, a component definition language can be used to generate component definition 704 for a component. For example, the component definition language could be used to generate a schema in JavaScript Object Notation (JSON) and / or another format. This schema could specify properties of the component and how values should be read from the results of a corresponding query. The component definition language could also specify how one or more records (e.g., records 610) are to be generated from the properties. The component definition language could also, or instead, define extractors 706 that are used to render record values from the results and / or mappings between results of extractors 706 and properties of the component.

[0167] An example component definition 704 that is generated using a component definition language includes the following:{ local rpath = path ( context . Path + [ { Class : [ ' my ' , ' class ' ] } ] ) , local attribute = attributeldByName ( ' process type ' ) , properties : { processType : { type : ' string ' , enum : [ ' high ' , ' low ' ] , value : if std . average ( extractors . attribute . value ) == 21 then ' high 'else 'low'}}, records : [ { path: rpath, attributes : [ { id: attribute, values: [ { name : ' asdf ' , value : if value . rocessType == 'high' then 42 else 21} ] }]}] , extractors : { attribute: { path: record. path, query: "$ .Attributes [? (@ . Id = $ { attribute } ) ]

[0000] . Values [ ? ( @ . Name = 'asdf' ) ] [0] .Value",}},}

[0168] The example component definition 704 includes a local relative path (i.e., “rpath”) for the component that is constructed by appending a segment with a class identifier of “['my', 'class']” to an existing “context. Path.” The example component definition 704 also includes a “local attribute” that is retrieved by a name of “process type.” The example component definition 704 further includes a schema that specifies a property named “processType” that is a string with a value of either “high” or “low.” A special “_value” field is used to define how the value of “processType” is to be read from the result of a query. More specifically, “_value” is used to set “processType” based on an average of values retrieved by one or more extractors706. If this average is 21 , “processType” is set to “high.” Otherwise, “processType” is set to “low.”

[0169] The example component definition 704 additionally includes a set of “records” (e.g., records 610). This set of records is located at “rpath” and includes a set of “attributes.” The attributes include an identifier and a value with a name of “asdf.” The value is set to 42 if the “processType” property is set to “high” and to 21 otherwise.

[0170] Finally, the example component definition 704 includes a set of “extractors” that are used to render record values. Each extractor includes a “path” and a “query” expression. The path defines a set of nodes (e.g., emissions nodes) on which the extractor is to be evaluated, and the query expression defines how properties (e.g., of the corresponding component and / or emissions) should be read from the path. The result of evaluating a given extractor can be included in both a summary (e.g., an overall result) and / or breakdown of results 246 associated with the query. For example, each extractor result could include an array of evaluation results associated with evaluating the query on each matching emission node.

[0171] More specifically, the example component definition 704 includes one extractor with a path that is set to “rpath”. The extractor also includes a query expression that is specified in a JSONPath query language and used to navigate through the attributes of a given record and extract the value associated with the name of “asdf.”

[0172] In some embodiments, an extractor can additionally define an aggregation of values associated with the component. For example, an extractor with an aggregation that is set to “average” could be used to compute an average of all values computed and / or retrieved by the extractor. An extractor with an aggregation that is set to “array” could be used to write all values to an array. An extractor with an aggregation that is set to “probability” could be used to return an object that includes one or more key-value pairs, where the keys in the key-value pairs represent all possible values returned by the query expression in the extractor and the values in the key-value pairs represent probabilities of occurrence of the corresponding keys.

[0173] Since evaluation engine 124 can choose to discard portions of a given emissions tree during evaluation of an LCA query (e.q., because these portions include irrelevant details), use of extractors 706 can be limited in some embodiments. More specifically, when a node matches the path specified in an extractor, the node can be marked as relevant for extraction. During the breakdown reduction process, during which nodes that aren’t needed to generate the corresponding results of the LCA query are discarded, marked nodes are not discarded to allow scaling factors to correctly be applied at a later step before evaluating the extractor.

[0174] In some embodiments, evaluation engine 124 uses component definition 704 to generate a corresponding component representation 708 that is included in results of the query. More specifically, evaluation engine 124 uses information related to extractors 706 from component definition 704 to determine mappings from the results of extractors 706 onto properties of a given component. For example, evaluation engine 124 could use the schema and logic associated with extractors 706 to retrieve mappings between values retrieved and / or generated using extractors 706 and values in component representation 708.

[0175] Evaluation engine 124 also uses these mappings to generate a component representation 708 for the component that includes environmental impacts associated with these properties. For example, evaluation engine 124 could use these mappings to propagate a change in a functional unit of a process that is made by the component onto the corresponding component representation 708. In another example, evaluation engine 124 could use these mappings to replace an input material within component representation 708 with a different input material. In a third example, evaluation engine 124 could use these mappings to determine whether or not a specific process is used to evaluate a query and / or generate results of the query.

[0176] In one or more embodiments, evaluation engine 124 uses mappings in component definition 704 to generate results at different levels of granularity and / or detail. Evaluation engine 124 and / or another component can additionally generate a user interface that allows a user to explore the results across the levels of granularity and / or detail. For example, the user interface could include graphical and / or textual representations of data in the results. These graphical and / or textual representations could be generated using different fields and / or objects in component representation 708 and / or mappings in component definition 704. The user interface could alsoinclude “zoom” functionality that allows a user to view the results at a first, highest level representing the product (e.g., information from product specification 602 for a footwear product), a second level representing major product components 606 with which the product is composed (e.g., insole, upper, midsole, outsole, etc.), a third level representing additional product components 606 and / or facility components 608 grouped under the major product components 606 (e.g., materials, manufacturing processes, facilities, etc.), and / or one or more additional levels that provide additional sub-components and / or information related to the additional product components 606 and / or facility components 608 (e.g., raw materials, technologies, and / or processes used to manufacture the additional product components 606). Data associated with each level of the user interface could be generated using a different set of records 610 and / or component definitions 604 to allow the granularity and / or type of the data to be tailored to a specific use case.

[0177] As shown in Figure 7, a domain-specific two-way component definition language 702 is optionally used to generate component definition 704. This two-way component definition language 702 represents a simplified way of defining and generating components.

[0178] For example, the example component definition 704 above could be rewritten using two-way component definition language 702 into the following: path { { "Components" , "Component Y" } { "Manufacturing Process" , "Some Process " } } constrain attribute { name "my attribute" value "adsf" [ switch [property processType ] case "high" 42 case "low" 21 ]}

[0179] Unlike the previous component definition 704 that includes four separate portions (i.e., schema, record generation logic, extractors 706, logic for how extractors 706 can be used to generate component values), the example component definition 704 above includes a “path” portion and a “constrain attribute” portion. The pathportion specifies two sets of nodes of {"Components", "Component Y"} and {"Manufacturing Process", "Some Process"}. The “constrain attribute” portion sets constraints on an attribute name of “my attribute” in a component. The “my attribute” attribute is related and / or mapped to the “asdf attribute in one or more records and has a value that is set to 42 if the “processType” property is set to “high” and to 21 if the “processType” property is set to “low.”

[0180] In some embodiments, two-way component definition language 702 includes inference mechanisms to determine variable types instead of requiring the variable types to be defined within component definition 704. Continuing with the above example component definition 704, this inference mechanism could leverage system-level awareness of the types of most properties to infer the type of “processType” to be “string.”

[0181] In cases where the system cannot infer the type of a variable, a “property” command can be used to provide a type hint and / or other constraints related to the variable within a given component definition 704. An example component definition 704 with such a “property” command includes the following: constrain attribute { name "Yarn Density" value [property "Density" { type integer minimum 1 maximum 100} ]}More specifically, the example component definition 704 above includes an attribute named “Density” that has a type of “integer,” a minimum value of 1 , and a maximum value of 100. The type, minimum value, and maximum value can be used as validation rules for the “Yarn Density” attribute in a corresponding component.

[0182] Another example component definition 704 with a “property” command includes the following: constrain attribute { name "Customer Group"value [ "Age Group" { switch [property " Is Children' s Clothing?" ] case "true" "Children" case "false" "Adults"} ]}The example component definition 704 above includes an attribute name of “Customer Group” for an attribute in the component, which is mapped to an “Age Group” attribute in one or more records. The example component definition 704 also includes a Boolean property of “Is Children’s Clothing?” that is used to determine the value of “Customer Group” and / or “Age Group. When the property is set to true, this value is set to “Children.” When the property is set to false, this value is set to “Adults.”

[0183] In some embodiments, two-way component definition 704 is used to generate an input constraint when an input is upserted. This input constraint can be used to derive a reference functional unit from the current context. An example of such an input constraint includes the following: upsert input { select { "Trim" "Button" "Metal Button" } replace { "Trim" "Button" } funit { g [property weight ]}}The example input constraint above includes an input of {"Trim" "Button" "Metal Button"}, which is used to replace {"Trim" "Metal Button"}. The input constraint also specifies a functional unit for a “weight” property that is associated with a certain number of grams. Thus, the example input constraint can be used to ensure that when a new input (e.g., a metal button) is added, a functional unit for the input is derived from the weight of the associated garment. If the weight is not set, the entire “funit” field can be dropped.

[0184] Another example input constraint that is used to handle multiple inputs includes the following:switch [property processType ] case "high" [ upsert input { path { { "Components" "Component Y" } { "Manufacturing Process" , "Some Process" } } select { "Trim" "Button" "Metal Button" } funit { g [property weight ]}}] case "low" [ remove input { path absolute { "a" , "b" } select { " " }}]The example input constraint above includes a “switch” statement that is used to perform different operations based on the value of the “processType” property. When “processType” is set to “high,” the input of {"Trim" "Button" "Metal Button"} is selected from a path of “{{"Components" "Component Y"} {"Manufacturing Process", "Some Process"}},” and the functional unit for the input is defined in units of grams and derived from the “weight” property. When “processType” is set to “low,” one or more inputs with an absolute path of “{"a", "b"}” are removed. Consequently, the “switch” statement allows conditional logic to be applied to the management and processing of components within the system, with different actions (e.q., upserting or removing an input) taken depending on whether “processtype” is set to "high" or "low".

[0185] Figure 8 is a flow diagram of method steps for generating a query of a life cycle assessment 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.

[0186] In step 802, evaluation engine 124 receives a product specification for a product and a set of components associated with the product. For example,evaluation engine 124 may receive a product specification that includes a definition and / or representation of a product for which environmental impacts are to be computed. The product specification may include a class, brand, material composition, country of origin, certifications, name, description, variant, color, size, weight, attributes, functional unit, quality, state, and / or other attributes that identify and / or describe the product. Evaluation engine 124 may also receive one or more product components that represent precursors and / or subsets of the product and / or one or more facility components that represent facilities used to manufacture the product, precursors, and / or subsets. Each product component may include names, descriptions, and / or metadata related to precursors of the product and / or parts within the product. Each facility component may include an amount of a resource (e.g., electricity, fuel, water, cotton, metal, etc.) consumed by a corresponding facility, processes carried out by the facility, and / or specific technologies used at the facility. The product specification, product components, and / or facility components may include fields that store primary data for the corresponding products and facilities, respectively. Various types of relationships among the product components and / or facility components may be denoted by organizing the product components and / or facility components into multiple levels within a hierarchy.

[0187] In step 804, evaluation engine 124 determines properties of each component based on a corresponding component definition. For example, the data format and / or types of primary data in each component may be defined in a corresponding component definition. The component definition may also include a schema that defines the properties of the component.

[0188] In step 806, evaluation engine 124 populates one or more records in an intermediate data format based on rules associated with the properties from the component definition. Continuing with the above example, each component definition may include rules for generating a record based on the properties in the corresponding component. Each component definition may also, or instead, include one or more extractors that specify how nodes in the life cycle assessment database are to be queried and / or how values in the record are to be rendered from results of the queried nodes. Consequently, evaluation engine 124 may use the rules and / or extractors to initialize and / or populate at least a portion of the fields in the record(s).

[0189] In step 808, evaluation engine 124 generates a query of the life cycle assessment database based on the record(s). For example, evaluation engine 124 may use a path in a given record to identify a set of data nodes in the life cycle assessment database. Evaluation engine 124 may also use the record to identify changes to be made to those nodes. Evaluation engine 124 may further add, to the query, one or more constraints corresponding to the changes and / or other representations of the changes.

[0190] In step 810, evaluation engine 124 processes the query using the life cycle assessment database to compute one or more environmental impacts associated with the product. For example, evaluation engine 124 may process the query and generate compute the environmental impact(s) using the techniques discussed above with respect to Figures 2-5. Evaluation engine 124 may also, or instead, process the query and compute the environmental impact(s) using the techniques discussed below with respect to Figure 9.

[0191] Figure 9 is a flow diagram of method steps for generating a result of a query of a life cycle assessment 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.

[0192] In step 902, evaluation engine 124 receives a component definition for a component associated with a product. The component definition may be matched to an identifier for the component and / or another attribute associated with the component. The component definition may be generated using one or more component definition languages. The component definition may be associated with a different source of primary data, environmental impact assessment use case, group of users, organization, and / or role. The component definition may include a schema that specifies properties of the component and how values should be read from the results of a corresponding query, how one or more records are to be generated from the properties, one or more extractors that are used to render record values from the results, and / or mappings between extractor results of the extractor(s) and properties of the component.

[0193] In step 904, evaluation engine 124 generates a query based on one or more extractors in the component definition and primary data in the component. For example, evaluation engine 124 may populate the query with information from the extractor(s) defined in the component definition. This information may include a path defining a set of data nodes in the life cycle assessment database and / or a query expression that is used to read one or more properties from the set of data nodes. Evaluation engine 124 may also, or instead, populate one or more records with the primary data from the component based on a data format for the component that is defined in the component definition. Evaluation engine 124 may additionally use the records to modify assumptions and / or values associated with the data nodes.

[0194] In step 906, evaluation engine 124 executes the query to generate one or more extractor results based on one or more properties read from data nodes in a life cycle assessment database using the extractor(s). For example, evaluation engine 124 may use the path and / or query expression from the query to read values associated with the properties from the data nodes. Evaluation engine 124 may also use the values and / or aggregations of the values to generate one or more corresponding extractor results.

[0195] In step 908, evaluation engine 124 computes one or more environmental impacts associated with the component based on the extractor result(s) and the component definition. For example, evaluation engine 124 may retrieve, from the component definition, one or more mappings between the extractor result(s) and the corresponding properties of the component. Evaluation engine 124 may also generate a component representation that includes the one or more environmental impacts based on the mapping(s) (e.g., so that each environmental impact is represented as a property mapped to a corresponding extractor result).

[0196] In step 910, evaluation engine 124 outputs the environmental impact(s) in a user interface. For example, evaluation engine 124 may generate a user interface that includes graphical and / or textual representations of the environmental impact(s). These graphical and / or textual representations could be generated using different fields and / or objects in the component representation and / or mappings in the component definition. The user interface may include “zoom” functionality that allows a user to view the results at a first, highest level representing the product and one or more lower levels representing components with which the product is composedand / or facilities used to manufacture the product and / or components. Data associated with each level of the user interface may be generated using a different set of records, components, and / or component definitions to allow the granularity and / or type of the data to be tailored to a specific use case.

[0197] In sum, the disclosed techniques support flexible query generation and result presentation in the context of environmental impact assessment. During query generation, a product specification that includes high-level information related to a product and primary data for product components within the product and / or facilities used to manufacture the product components and / or product are converted into an intermediate “record” format. This record format is used to modify assumptions and / or values associated with a data model for a database, thereby adapting processing of the query to the types and / or formats of the primary data for the product and / or the types and / or formats of secondary data stored in the database.

[0198] One or more component definition languages are used to create component definitions that include schemas for the components, rules for generating records associated with the components, extractors for querying and validating data related of the components, and / or mappings between extractor results of the extractors and properties of the components. During execution of a given query, the extractors can be used to retrieve and / or compute values associated with a component, the record-generating rules can be used to specify constraints on data processed using the query, and mappings between extractor results of the extractors and fields in the schema can be used to generate component representations of the components that are included in results of the query. Different component definitions can thus be created to accommodate different use and / or cases or requirements associated with various types of products and / or environmental impact assessments.

[0199] One technical advantage of the disclosed techniques relative to the prior art is the ability to determine environmental impacts associated with the life cycle of an entity without requiring specific inputs, outputs, and / or measurements across the life cycle of the entity to be provided. Consequently, the disclosed techniques can be used to define and execute LCA queries with greater granularity, flexibility, and efficiency than conventional LCA tools that operate using predefined workflows and require certain data points to be specified. Another technical advantage of the disclosed techniques is the ability to flexibly adapt the query generation process tochanges in data formats associated with primary data passed in an LCA query and to changes in data formats and / or query processing techniques associated with a database against which the LCA query is executed. Yet another technical advantage of the disclosed techniques is the ability to flexibly adapt primary data, secondary data, query processing, and query results to different use cases and / or levels of granularity associated with LCA or environmental impact assessment. These technical advantages provide one or more technological improvements over prior art approaches.

[0200] 1 . In some embodiments, a computer-implemented method for generating a query of a life cycle assessment database comprises receiving (i) a product specification for a product and (ii) a set of components associated with the product, wherein the product specification and the set of components include primary data in one or more data formats; populating one or more records in an intermediate data format with the primary data based on one or more component definitions associated with the one or more data formats, wherein the one or more records include (i) a set of data nodes in the life cycle assessment database and (ii) a set of changes to be applied to the set of data nodes; generating the query based on the one or more records; and processing the query using the life cycle assessment database to compute one or more environmental impacts associated with the product.

[0201] 2. The computer-implemented method of clause 1 , wherein populating the one or more records with the primary data comprises determining a set of properties of each component included in the set of components based on a corresponding component definition that is included in the one or more component definitions; and applying one or more rules included in the corresponding component definition to the set of properties to generate the one or more records.

[0202] 3. The computer-implemented method of any of clauses 1-2, wherein generating the query comprises adding, to the query, an extractor from a component definition included in the one or more component definitions, wherein the extractor includes (i) a path that specifies the set of data nodes included in the life cycle assessment database and (ii) a query expression that specifies a set of properties to be read from the path.

[0203] 4. The computer-implemented method of any of clauses 1-3, wherein generating the query comprises at least one of generating one or more constraints included in the query based on the one or more records; or modifying a value included in the life cycle assessment database based on the one or more records.

[0204] 5. The computer-implemented method of any of clauses 1-4, wherein the one or more records include at least one of a path that specifies the set of data nodes; one or more inputs associated with the set of data nodes; one or more attributes of the set of data nodes; one or more functional units associated with the set of data nodes; one or more emissions associated with the set of data nodes; or one or more facilities associated with the set of data nodes.

[0205] 6. The computer-implemented method of any of clauses 1-5, wherein the product specification includes at least one of a class associated with the product, a brand, a material composition, a country of origin, a certification, a name, a description, a variant, a color, a size, a weight, an attribute, a price, a functional quality, a state, or a number of days the product has been in a warehouse.

[0206] 7. The computer-implemented method of any of clauses 1-6, wherein the set of components includes a product component corresponding to at least one of a portion of the product or a precursor of the product.

[0207] 8. The computer-implemented method of any of clauses 1-7, wherein the product component includes at least one of a facility, a class, a weight, a material, a manufacturing process, or one or more child components.

[0208] 9. The computer-implemented method of any of clauses 1-8, wherein the set of components includes a facility component representing a facility associated with a manufacture of the product.

[0209] 10. The computer-implemented method of any of clauses 1 -9, wherein the facility component includes at least one of an amount of a resource consumed by the facility, one or more processes carried out at the facility, or one or more technologies used at the facility.

[0210] 11 . In some embodiments, one or more non-transitory computer-readable media store instructions that, when executed by one or more processors, cause theone or more processors to perform the steps of receiving (i) a product specification for a product and (ii) a set of components associated with the product, wherein the product specification and the set of components include primary data in one or more data formats; populating one or more records in an intermediate data format with the primary data based on one or more component definitions associated with the one or more data formats, wherein the one or more records include (i) a set of data nodes in a life cycle assessment database and (ii) a set of changes to be applied to the set of data nodes; generating a query based on the one or more records; and processing the query using the life cycle assessment database to compute one or more environmental impacts associated with the product.

[0211] 12. The one or more non-transitory computer-readable media of clause 11 , wherein populating the one or more records with the primary data comprises determining, based on one or more schemas included in the one or more component definitions, (i) a set of properties of the set of components and (ii) a set of rules associated with the set of properties; and applying the set of rules to the set of properties to generate the one or more records.

[0212] 13. The one or more non-transitory computer-readable media of any of clauses 11-12, wherein generating the query comprises adding, to the query, an extractor from a component definition included in the one or more component definitions, wherein the extractor includes (i) a path that specifies the set of data nodes included in the life cycle assessment database and (ii) a query expression that specifies a set of properties to be read from the path.

[0213] 14. The one or more non-transitory computer-readable media of any of clauses 11-13, wherein the extractor further includes an aggregation of a set of values associated with the set of properties.

[0214] 15. The one or more non-transitory computer-readable media of any of clauses 11-14, wherein processing the query using the life cycle assessment database comprises evaluating the extractor to generate an extractor result based on the set of properties read from the path; and updating the one or more environmental impacts based on the extractor result.

[0215] 16. The one or more non-transitory computer-readable media of any of clauses 11-15, wherein processing the query using the life cycle assessment database comprises searching one or more hierarchical structures included in the life cycle assessment database for the set of data nodes that match a first set of parameters included in the query, wherein the first set of parameters comprises a set of primary data associated with an entity; computing a first set of emissions associated with the set of data nodes based on a first set of functional units included in the set of data nodes; and aggregating the first set of emissions into the one or more environmental impacts.

[0216] 17. The one or more non-transitory computer-readable media of any of clauses 11-16, wherein the product specification comprises at least one of a class included in an ontological plane of the life cycle assessment database, a brand, a material composition, a country of origin, a certification, a name, a description, a variant, a color, a size, a weight, a price, a functional unit, a quality, or a state.

[0217] 18. The one or more non-transitory computer-readable media of any of clauses 11-17, wherein the set of components comprises at least one of (i) a product component representing a portion of the product or a precursor of the product or (ii) a facility component representing a facility used to manufacture the product, the portion of the product, or the precursor of the product.

[0218] 19. The one or more non-transitory computer-readable media of any of clauses 11-18, wherein the set of components is associated with at least one of a source of the primary data, a user, a group of users, an organization, a role, or an environmental impact assessment use case.

[0219] 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 (i) a product specification for a product and (ii) a set of components associated with the product, wherein the product specification and the set of components include primary data in one or more data formats; populating one or more records in an intermediate data format with the primary data based on one or more component definitions associated with the one or more data formats, wherein the one or more records include (i) a set of data nodes in a life cycle assessmentdatabase and (ii) a set of changes to be made to the set of data nodes; generating a query based on the one or more records; and processing the query using the life cycle assessment database to compute one or more environmental impacts associated with the product.

[0220] 21 . In some embodiments, a computer-implemented method for processing a query of a life cycle assessment database comprises receiving a component definition for a component associated with a product; generating the query based on one or more extractors included in the component definition, wherein each of the one or more extractors includes (i) a path defining a set of data nodes in the life cycle assessment database and (ii) a query expression that is used to read one or more properties from the set of data nodes; executing the query to generate one or more extractor results based on the one or more properties read from the set of data nodes; and converting the one or more extractor results into one or more environmental impacts associated with the component.

[0221] 22. The computer-implemented method of clause 21 , wherein generating the query comprises generating one or more records in an intermediate data format based on the component definition and a set of primary data included in the component; and generating the query based on the one or more records.

[0222] 23. The computer-implemented method of any of clauses 21-22, wherein generating the one or more records comprises determining, based on a schema included in the component definition, (i) the one or more properties of the component and (ii) a set of rules associated with the one or more properties; and applying the set of rules to the one or more properties to generate the one or more records.

[0223] 24. The computer-implemented method of any of clauses 21-23, wherein executing the query comprises changing one or more values associated with the one or more properties based on the one or more records.

[0224] 25. The computer-implemented method of any of clauses 21-24, wherein generating the query comprises populating the query with the path and the query expression.

[0225] 26. The computer-implemented method of any of clauses 21-25, wherein converting the one or more extractor results into the one or more environmentalimpacts comprises retrieving, from the component definition, one or more mappings between the one or more extractor results and the one or more properties of the component; and computing the one or more environmental impacts based on the one or more mappings and the one or more extractor results.

[0226] 27. The computer-implemented method of any of clauses 21-26, wherein the component definition further includes a schema for the one or more properties of the component.

[0227] 28. The computer-implemented method of any of clauses 21-27, further comprising outputting the one or more environmental impacts in a user interface.

[0228] 29. The computer-implemented method of any of clauses 21-28, wherein the one or more extractor results comprise a property of an emission node included in the set of data nodes.

[0229] 30. The computer-implemented method of any of clauses 21-29, wherein the component comprises at least one of (i) a product component representing a portion of the product or a precursor of the product or (ii) a facility component representing a facility used to manufacture the product, the portion of the product, or the precursor of the product.

[0230] 31 . 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 receiving a component definition for a component associated with a product; generating a query based on one or more extractors included in the component definition, wherein each of the one or more extractors includes (i) a path defining a set of data nodes in a life cycle assessment database and (ii) a query expression that is used to read one or more properties from the set of data nodes; executing the query to generate one or more extractor results based on the one or more properties read from the set of data nodes; and converting the one or more extractor results into one or more environmental impacts associated with the component.

[0231] 32. The one or more non-transitory computer-readable media of clause 31 , wherein generating the query comprises generating one or more records in an intermediate data format based on (i) a data format for the component that is definedin the component definition and (ii) a set of primary data included in the component; and generating the query based on the one or more records.

[0232] 33. The one or more non-transitory computer-readable media of any of clauses 31-32, wherein converting the one or more extractor results into the one or more environmental impacts comprises retrieving, from the component definition, one or more mappings between the one or more extractor results and the one or more properties of the component; and generating a component representation that includes the one or more environmental impacts based on the one or more mappings.

[0233] 34. The one or more non-transitory computer-readable media of any of clauses 31-33, wherein the instructions further cause the one or more processors to perform the steps of generating a user interface that includes a plurality of levels associated with the product; and outputting the one or more environmental impacts within a first level included in the plurality of levels that corresponds to the component.

[0234] 35. The one or more non-transitory computer-readable media of any of clauses 31-34, wherein the plurality of levels further comprises a second level that (i) corresponds to the product and (ii) is higher than the first level.

[0235] 36. The one or more non-transitory computer-readable media of any of clauses 31-35, wherein the one or more environmental impacts comprise at least one of an emission, a production, or a waste product allocation.

[0236] 37. The one or more non-transitory computer-readable media of any of clauses 31-36, wherein the one or more extractors further comprise an aggregation of a set of values associated with the one or more properties.

[0237] 38. The one or more non-transitory computer-readable media of any of clauses 31-37, wherein the aggregation comprises at least one of an average, an array, or a set of probabilities associated with the set of values.

[0238] 39. The one or more non-transitory computer-readable media of any of clauses 31-38, wherein the component definition is associated with at least one of a source of primary data, a user, a group of users, an organization, a role, or an environmental impact assessment use case.

[0239] 40. 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 a component definition for a component associated with a product; generating a query based on one or more extractors included in the component definition, wherein each of the one or more extractors includes (i) a path defining a set of data nodes in a life cycle assessment database and (ii) a query expression that is used to read one or more properties from the set of data nodes; executing the query to generate one or more extractor results based on the one or more properties read from the set of data nodes; and converting the one or more extractor results into one or more environmental impacts associated with the component.

[0240] 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.

[0241] 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.

[0242] 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.

[0243] Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal mediumor 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 memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc readonly 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.

[0244] 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.

[0245] 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 theblock 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, and combinations 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.

[0246] 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

WHAT IS CLAIMED IS:1 . A computer-implemented method for generating a query of a life cycle assessment database, the method comprising: receiving (i) a product specification for a product and (ii) a set of components associated with the product, wherein the product specification and the set of components include primary data in one or more data formats; populating one or more records in an intermediate data format with the primary data based on one or more component definitions associated with the one or more data formats, wherein the one or more records include (i) a set of data nodes in the life cycle assessment database and (ii) a set of changes to be applied to the set of data nodes; generating the query based on the one or more records; and processing the query using the life cycle assessment database to compute one or more environmental impacts associated with the product.

2. The computer-implemented method of claim 1 , wherein populating the one or more records with the primary data comprises: determining a set of properties of each component included in the set of components based on a corresponding component definition that is included in the one or more component definitions; and applying one or more rules included in the corresponding component definition to the set of properties to generate the one or more records.

3. The computer-implemented method of claim 1 , wherein generating the query comprises adding, to the query, an extractor from a component definition included in the one or more component definitions, wherein the extractor includes (i) a path that specifies the set of data nodes included in the life cycle assessment database and (ii) a query expression that specifies a set of properties to be read from the path.

4. The computer-implemented method of claim 1 , wherein generating the query comprises at least one of: generating one or more constraints included in the query based on the one or more records; ormodifying a value included in the life cycle assessment database based on the one or more records.

5. The computer-implemented method of claim 1 , wherein the one or more records include at least one of: a path that specifies the set of data nodes; one or more inputs associated with the set of data nodes; one or more attributes of the set of data nodes; one or more functional units associated with the set of data nodes; one or more emissions associated with the set of data nodes; or one or more facilities associated with the set of data nodes.

6. The computer-implemented method of claim 1 , wherein the product specification includes at least one of a class associated with the product, a brand, a material composition, a country of origin, a certification, a name, a description, a variant, a color, a size, a weight, an attribute, a price, a functional quality, a state, or a number of days the product has been in a warehouse.

7. The computer-implemented method of claim 1 , wherein the set of components includes a product component corresponding to at least one of a portion of the product or a precursor of the product.

8. The computer-implemented method of claim 7, wherein the product component includes at least one of a facility, a class, a weight, a material, a manufacturing process, or one or more child components.

9. The computer-implemented method of claim 1 , wherein the set of components includes a facility component representing a facility associated with a manufacture of the product.

10. The computer-implemented method of claim 9, wherein the facility component includes at least one of an amount of a resource consumed by the facility, one or more processes carried out at the facility, or one or more technologies used at the facility.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: receiving (i) a product specification for a product and (ii) a set of components associated with the product, wherein the product specification and the set of components include primary data in one or more data formats; populating one or more records in an intermediate data format with the primary data based on one or more component definitions associated with the one or more data formats, wherein the one or more records include (i) a set of data nodes in a life cycle assessment database and (ii) a set of changes to be applied to the set of data nodes; generating a query based on the one or more records; and processing the query using the life cycle assessment database to compute one or more environmental impacts associated with the product.

12. The one or more non-transitory computer-readable media of claim 11 , wherein populating the one or more records with the primary data comprises: determining, based on one or more schemas included in the one or more component definitions, (i) a set of properties of the set of components and (ii) a set of rules associated with the set of properties; and applying the set of rules to the set of properties to generate the one or more records.

13. The one or more non-transitory computer-readable media of claim 11 , wherein generating the query comprises adding, to the query, an extractor from a component definition included in the one or more component definitions, wherein the extractor includes (i) a path that specifies the set of data nodes included in the life cycle assessment database and (ii) a query expression that specifies a set of properties to be read from the path.

14. The one or more non-transitory computer-readable media of claim 13, wherein the extractor further includes an aggregation of a set of values associated with the set of properties.

15. The one or more non-transitory computer-readable media of claim 13, wherein processing the query using the life cycle assessment database comprises: evaluating the extractor to generate an extractor result based on the set of properties read from the path; and updating the one or more environmental impacts based on the extractor result.

16. The one or more non-transitory computer-readable media of claim 11 , wherein processing the query using the life cycle assessment database comprises: searching one or more hierarchical structures included in the life cycle assessment database for the set of data nodes that match a first set of parameters included in the query, wherein the first set of parameters comprises a set of primary data associated with an entity; computing a first set of emissions associated with the set of data nodes based on a first set of functional units included in the set of data nodes; and aggregating the first set of emissions into the one or more environmental impacts.

17. The one or more non-transitory computer-readable media of claim 11 , wherein the product specification comprises at least one of a class included in an ontological plane of the life cycle assessment database, a brand, a material composition, a country of origin, a certification, a name, a description, a variant, a color, a size, a weight, a price, a functional unit, a quality, or a state.

18. The one or more non-transitory computer-readable media of claim 11 , wherein the set of components comprises at least one of (i) a product component representing a portion of the product or a precursor of the product or (ii) a facility component representing a facility used to manufacture the product, the portion of the product, or the precursor of the product.

19. The one or more non-transitory computer-readable media of claim 11 , wherein the set of components is associated with at least one of a source of the primary data, a user, a group of users, an organization, a role, or an environmental impact assessment use case.

20. A system, comprising: 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 (i) a product specification for a product and (ii) a set of components associated with the product, wherein the product specification and the set of components include primary data in one or more data formats; populating one or more records in an intermediate data format with the primary data based on one or more component definitions associated with the one or more data formats, wherein the one or more records include (i) a set of data nodes in a life cycle assessment database and (ii) a set of changes to be made to the set of data nodes; generating a query based on the one or more records; and processing the query using the life cycle assessment database to compute one or more environmental impacts associated with the product.21 . A computer-implemented method for processing a query of a life cycle assessment database, the method comprising: receiving a component definition for a component associated with a product; generating the query based on one or more extractors included in the component definition, wherein each of the one or more extractors includes (i) a path defining a set of data nodes in the life cycle assessment database and (ii) a query expression that is used to read one or more properties from the set of data nodes; executing the query to generate one or more extractor results based on the one or more properties read from the set of data nodes; and converting the one or more extractor results into one or more environmental impacts associated with the component.

22. The computer-implemented method of claim 21 , wherein generating the query comprises:generating one or more records in an intermediate data format based on the component definition and a set of primary data included in the component; and generating the query based on the one or more records.

23. The computer-implemented method of claim 22, wherein generating the one or more records comprises: determining, based on a schema included in the component definition, (i) the one or more properties of the component and (ii) a set of rules associated with the one or more properties; and applying the set of rules to the one or more properties to generate the one or more records.

24. The computer-implemented method of claim 22, wherein executing the query comprises changing one or more values associated with the one or more properties based on the one or more records.

25. The computer-implemented method of claim 21 , wherein generating the query comprises populating the query with the path and the query expression.

26. The computer-implemented method of claim 21 , wherein converting the one or more extractor results into the one or more environmental impacts comprises: retrieving, from the component definition, one or more mappings between the one or more extractor results and the one or more properties of the component; and computing the one or more environmental impacts based on the one or more mappings and the one or more extractor results.

27. The computer-implemented method of claim 26, wherein the component definition further includes a schema for the one or more properties of the component.

28. The computer-implemented method of claim 21 , further comprising outputting the one or more environmental impacts in a user interface.

29. The computer-implemented method of claim 21 , wherein the one or more extractor results comprise a property of an emission node included in the set of data nodes.

30. The computer-implemented method of claim 21 , wherein the component comprises at least one of (i) a product component representing a portion of the product or a precursor of the product or (ii) a facility component representing a facility used to manufacture the product, the portion of the product, or the precursor of the product.31 . 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: receiving a component definition for a component associated with a product; generating a query based on one or more extractors included in the component definition, wherein each of the one or more extractors includes (i) a path defining a set of data nodes in a life cycle assessment database and (ii) a query expression that is used to read one or more properties from the set of data nodes; executing the query to generate one or more extractor results based on the one or more properties read from the set of data nodes; and converting the one or more extractor results into one or more environmental impacts associated with the component.

32. The one or more non-transitory computer-readable media of claim 31 , wherein generating the query comprises: generating one or more records in an intermediate data format based on (i) a data format for the component that is defined in the component definition and (ii) a set of primary data included in the component; and generating the query based on the one or more records.

33. The one or more non-transitory computer-readable media of claim 31 , wherein converting the one or more extractor results into the one or more environmental impacts comprises:retrieving, from the component definition, one or more mappings between the one or more extractor results and the one or more properties of the component; and generating a component representation that includes the one or more environmental impacts based on the one or more mappings.

34. The one or more non-transitory computer-readable media of claim 31 , wherein the instructions further cause the one or more processors to perform the steps of: generating a user interface that includes a plurality of levels associated with the product; and outputting the one or more environmental impacts within a first level included in the plurality of levels that corresponds to the component.

35. The one or more non-transitory computer-readable media of claim 34, wherein the plurality of levels further comprises a second level that (i) corresponds to the product and (ii) is higher than the first level.

36. The one or more non-transitory computer-readable media of claim 31 , wherein the one or more environmental impacts comprise at least one of an emission, a production, or a waste product allocation.

37. The one or more non-transitory computer-readable media of claim 31 , wherein the one or more extractors further comprise an aggregation of a set of values associated with the one or more properties.

38. The one or more non-transitory computer-readable media of claim 37, wherein the aggregation comprises at least one of an average, an array, or a set of probabilities associated with the set of values.

39. The one or more non-transitory computer-readable media of claim 31 , wherein the component definition is associated with at least one of a source of primary data, a user, a group of users, an organization, a role, or an environmental impact assessment use case.

40. A system, comprising: 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 a component definition for a component associated with a product; generating a query based on one or more extractors included in the component definition, wherein each of the one or more extractors includes (i) a path defining a set of data nodes in a life cycle assessment database and (ii) a query expression that is used to read one or more properties from the set of data nodes; executing the query to generate one or more extractor results based on the one or more properties read from the set of data nodes; and converting the one or more extractor results into one or more environmental impacts associated with the component.

Images