U.S. patent application number 12/187837 was filed with the patent office on 2010-02-11 for interactive product configurator.
This patent application is currently assigned to Oracle International Corporation. Invention is credited to Claire M. Bagley, Michael Colena, Martin P. Plotkin.
Application Number | 20100037159 12/187837 |
Document ID | / |
Family ID | 41654068 |
Filed Date | 2010-02-11 |
United States Patent
Application |
20100037159 |
Kind Code |
A1 |
Bagley; Claire M. ; et
al. |
February 11, 2010 |
INTERACTIVE PRODUCT CONFIGURATOR
Abstract
A product configurator is based on a constraint network having a
plurality of nodes. The product configurator, when it receives a
user choice, determines which nodes in the constraint network are
affected by the user choice. For each affected node, the product
configurator stores the prior domain state of the node and
associates the stored prior domain state with the user choice.
Therefore, the nodes can be restored to their prior state if the
user choice is later removed for any reason.
Inventors: |
Bagley; Claire M.;
(Carlisle, MA) ; Plotkin; Martin P.; (Concord,
MA) ; Colena; Michael; (Lowell, MA) |
Correspondence
Address: |
Squire, Sanders & Dempsey L.L.P.;Oracle International Corporation
8000 Towers Crescent Drive, 14th Floor
Vienna
VA
22182
US
|
Assignee: |
Oracle International
Corporation
Redwood Shores
CA
|
Family ID: |
41654068 |
Appl. No.: |
12/187837 |
Filed: |
August 7, 2008 |
Current U.S.
Class: |
715/764 |
Current CPC
Class: |
G06Q 10/087
20130101 |
Class at
Publication: |
715/764 |
International
Class: |
G06F 3/048 20060101
G06F003/048 |
Claims
1. A method of operating a product configurator that comprises a
constraint network having a plurality of nodes, the method
comprising: receiving a first user choice; determining one or more
first affected nodes of the plurality of nodes that are affected by
the first user choice; and for each first affected node, storing a
first prior domain state of the node and associating the stored
first prior domain state with the first user choice.
2. The method of claim 1, wherein the nodes are affected based on a
propagation of the first user choice through the constraint
network.
3. The method of claim 1, further comprising: receiving a request
to remove the first user choice; removing the first user choice;
and restoring the stored prior first domain state for each affected
node.
4. The method of claim 3, further comprising: receiving a second
user choice before receiving the request to remove the first user
choice; determining one or more second affected nodes of the
plurality of nodes that are affected by the second user choice; and
for each second affected node, storing a second prior domain state
of the node and associating the stored second prior domain state
with the second user choice.
5. The method of claim 4, further comprising: removing the second
user choice; restoring the stored second prior domain state for
each second affected node; determining if the second user choice is
a choice to be removed; and if the second user choice is not the
choice to be removed, saving the second user choice in a list of
choices to reapply.
6. The method of claim 5, further comprising: reapplying all
choices in the list of choices to reapply.
7. The method of claim 3, wherein the request to remove the first
user choice is generated directly from a user.
8. The method of claim 3, wherein the request to remove the first
user choice is generated because another user choice is
inconsistent with the first user choice.
9. The method of claim 3, wherein the request to remove the first
user choice is generated because another user choice has a higher
precedence than the first user choice.
10. The method of claim 9, further comprising: generating a message
that alerts a user that the first user choice is removed.
11. A computer readable media having instructions stored thereon
that, when executed by a processor, causes the processor to operate
a product configurator, the instructions comprising logic for:
defining a constraint-based network having a plurality of nodes;
receiving a first user choice; determining one or more first
affected nodes of the plurality of nodes that are affected by the
first user choice; and for each first affected node, storing a
first prior domain state of the node and associating the stored
first prior domain state with the first user choice.
12. The computer readable media of claim 11, wherein the nodes are
affected based on a propagation of the first user choice through
the constraint network.
13. The computer readable media of claim 11, further comprising:
receiving a request to remove the first user choice; removing the
first user choice; and restoring the stored prior first domain
state for each affected node.
14. A system for configuring a product, the system comprising:
means for defining a constraint-based network having a plurality of
nodes: means for receiving a first user choice; means for
determining one or more first changed nodes of the plurality of
nodes that are changed by the first user choice; and for each first
changed node, means for storing a first prior domain state of the
node and associating the stored first prior domain state with the
first user choice.
15. The system of claim 14, wherein the nodes are changed based on
a propagation of the first user choice through the constraint
network.
16. The system of claim 14, further comprising: means for receiving
a request to remove the first user choice; means for removing the
first user choice; and means for restoring the stored prior first
domain state for each changed node.
17. A product configurator comprising: a processor; and a memory
coupled to the processor; wherein the memory stores instructions
that when executed by the processor comprise: a constraint-based
network having a plurality of nodes; a user interface that receives
a first user choice; a determination of one or more first changed
nodes of the plurality of nodes that are changed by the first user
choice; and for each first changed node, storing a domain state of
the node before being changed and associating the stored domain
state with the first user choice.
18. The product configurator of claim 17, further comprising: a
database coupled to the processor that stores enterprise resource
planning data.
Description
FIELD OF THE INVENTION
[0001] One embodiment is directed generally to computer
interaction, and in particular to an interactive product
configurator.
BACKGROUND INFORMATION
[0002] Many current products and services can be customized by a
customer before being purchased. For example, computer systems
typically include many possible options and configurations that can
be specifically selected or configured by the customer. Other
examples of highly configurable products and services include
telephone switching systems, airplanes, automobiles, mobile
telephone services, insurance policies, and computer software.
[0003] Product and service providers typically provide a "product
configurator" that allows a customer or sales engineer to interact
with a computer in order to customize and configure a solution by
selecting among optional choices. Some known product configurators
are constraint-based. For these configurators, constraints are
enforced between optional choices, allowing the user to select the
choices they want, while validating that the resulting set of user
choices is valid.
[0004] Some known constraint-based configurators are not fully
"interactive" because they function as batch systems in which all
of the user choices are initially collected and then checked for
validity as a batch. Other known configurators, when receiving a
user choice, propagate the user choice through its constraint
network. However, a problem arises in these known systems when a
user wishes to remove or change prior selections during the
"choosing" process. In known systems, this will likely cause a
removal of all prior selections and likely requires a restart of
the entire configuration process and then the re-assertion of all
choices minus that choice that is to be removed. This causes the
user to have to essentially start over, or at a minimum slows down
the processing, thus diminishing the interactive experience.
Further, these known systems do not easily show the user the effect
of each selection on further selections since the configuration is
not determined until all selections are made.
SUMMARY OF THE INVENTION
[0005] One embodiment is a product configurator that is based on a
constraint network having a plurality of nodes. The product
configurator, when it receives a user choice, determines which
nodes in the constraint network are affected by the user choice.
For each affected node, the product configurator stores the prior
domain state of the node and associates the stored prior domain
state with the user choice. Therefore, the nodes can be restored to
their prior state if the user choice is later removed for any
reason.
BRIEF DESCRIPTION OF THE DRAWINGS
[0006] FIG. 1 is a block diagram of a system that can implement an
embodiment of the present invention.
[0007] FIG. 2 is a flow diagram of the functionality of a product
configurator when a user makes a choice when interacting with a
configurator model in accordance with one embodiment.
[0008] FIG. 3 graphically illustrates the functionality of FIG. 2
when a user choice is received in accordance with one
embodiment.
[0009] FIG. 4 is a flow diagram of the functionality of the product
configurator when a user removes a prior choice among a series of
choices (or just a single choice) in accordance with one
embodiment.
[0010] FIG. 5 graphically illustrates the functionality of FIG. 4
when removing a prior user choice from a list of user choices and
while backtracking through the list in accordance to one
embodiment.
[0011] FIG. 6 is a flow diagram of the functionality of the product
configurator when retracting an inconsistent choice in accordance
with one embodiment.
[0012] FIG. 7 is a flow diagram of the functionality of the product
configurator when a user adds a new choice with a higher precedent
than prior choices in accordance with one embodiment.
[0013] FIG. 8 graphically illustrates the functionality of FIG. 7
when inserting a new choice having higher precedent into a list of
user choices in accordance to one embodiment.
DETAILED DESCRIPTION
[0014] One embodiment is an interactive product configurator that
efficiently stores prior node values when new user choices are
received. This allows a user to add or remove a user choice during
the configuration process without requiring a complete restart of
the process by providing efficient backtracking.
[0015] FIG. 1 is a block diagram of a system 10 that can implement
an embodiment of the present invention. System 10 includes a bus 12
or other communication mechanism for communicating information, and
a processor 22 coupled to bus 12 for processing information.
Processor 22 may be any type of general or specific purpose
processor. System 10 further includes a memory 14 for storing
information and instructions to be executed by processor 22. Memory
14 can be comprised of any combination of random access memory
("RAM"), read only memory ("ROM"), static storage such as a
magnetic or optical disk, or any other type of computer readable
media. System 10 further includes a communication device 20, such
as a network interface card, to provide access to a network.
Therefore, a user may interface with system 10 directly, or
remotely through a network or any other method.
[0016] Computer readable media may be any available media that can
be accessed by processor 22 and includes both volatile and
nonvolatile media, removable and non-removable media, and
communication media. Communication media may include computer
readable instructions, data structures, program modules or other
data in a modulated data signal such as a carrier wave or other
transport mechanism and includes any information delivery
media.
[0017] Processor 22 is further coupled via bus 12 to a display 24,
such as a Liquid Crystal Display ("LCD"), for displaying
information to a user. A keyboard 26 and a cursor control device
28, such as a computer mouse, is further coupled to bus 12 to
enable a user to interface with system 10.
[0018] In one embodiment, memory 14 stores software modules that
provide functionality when executed by processor 22. The modules
include an operating system 15 that provides operating system
functionality for system 10. The modules further include a product
configurator 16 that performs interactive product configuration as
disclosed in more detail below. The modules further include other
enterprise resource planning ("ERP") modules 18 of an ERP system
that may interact with product configurator 16, such as a bill of
material ("BOM") module and a customer relationship manager ("CRM")
module. An ERP system is a computer system that integrates several
data sources and processes of an organization into a unified
system. A typical ERP system uses multiple components of computer
software and hardware to achieve the integration. A unified ERP
database 17, coupled to bus 12, is used to store data for the
various system modules. In one embodiment, ERP modules 18 are part
of the "Oracle E-Business Suite Release 12" ERP system from Oracle
Corp. In other embodiments, product configurator 16 may be a
stand-alone system and not integrated with an ERP system, or may be
part of any other integrated system.
[0019] In one embodiment, product configurator 16 allows a user to
interactively configure a product or service by choosing options.
Product configurator 16 in one embodiment is constraint-based in
that it solves a constraint problem to arrive at a solution (i.e.,
an appropriate and valid configuration). A constraint problem is a
problem with a given set of variables, a given set of values or
range of values (referred to as a "domain") for each variable, and
a given set of constraints. Each constraint restricts the values,
from the set of values, that may be simultaneously assigned to each
variable of the set of variables. The solution is a combination of
assignments of values to each variable that is consistent with all
constraints.
[0020] A configuration "model" is created in order to implement a
configurator. A model represents a generic framework of a solution,
or of many possible solutions, to a problem, and includes a
classification of associated model entities. The model entities are
referred to as "nodes" and represent the domains of the constraint
based system. A model may represent an apparatus, such as an
automobile, with various option packages; a system such as a
telecommunications network, with various hardware, software,
protocol and service options; a suite of available services; a
suite of software applications, etc. A constraint network is a
series of nodes linked by constraints.
[0021] When a model is created and executed by product configurator
16, a user can interact with the model. The interaction in general
involves the user being presented with a series of choices or
items. Each item is represented by a variable in the underlying
constraint system. Each variable has a domain, which is a range or
set of possible values (e.g., integers between 0 and 10, the set of
blue, red or green, etc.). As choices are made by the user, the
domain may shrink. For example, if the configurator is for a car,
the user may choose a sedan instead of a convertible. However, in
the next choice, which is the color of the car, red may no longer
be available because a sedan cannot be configured in red. If a user
backtracks and decides not to choose a sedan, the color red should
be restored as one of the color choices. In prior art configurator
systems, a restart is typically required to restore the color red.
In contrast, in one embodiment, the change of domains is
efficiently tracked and stored so changes as a result of
backtracking or other reasons can easily be undone.
[0022] FIG. 2 is a flow diagram of the functionality of product
configurator 16 when a user makes a choice when interacting with a
configurator model in accordance with one embodiment. In one
embodiment, a user choice is any representation of an action by the
user in the configurator user interface ("UI"). Examples of a user
choice include clicking a checkbox, entering a number in a box,
choosing a number or choice within a drop down box, etc. The user
choices are added and managed in a manner that allows for efficient
backtracking and/or negation. In one embodiment, the functionality
of the flow diagram of FIG. 2, and FIGS. 4, 6 and 7 below, is
implemented by software stored in memory or other computer readable
or tangible medium, and executed by a processor. In other
embodiments, the functionality can be performed by hardware, or any
combination of hardware and software.
[0023] At 202, the user choice is received and stored. The user
choice can be stored using any type of internal representation of
the choice and in one embodiment is stored in memory 14. The user
choice at 202 may cause one or more associated outward constraints
in the constraint network to be affected (i.e., due to the
propagation of the user choice throughout the constraint network),
which may modify the associated node for each constraint.
[0024] At 204, the first/next outward constraint affected by the
user choice at 202 is evaluated.
[0025] At 206, it is determined if the node for the constraint has
changed. If so, at 208 the previous state for the node is stored
and associated with the added user choice at 202.
[0026] At 210, if the node for the constraint has not changed, or
after storing the previous state at 208, it is determined if there
are additional constraints to evaluate from the user choice. If
there are, the flow returns to 204. In this manner, the propagation
of the entire constraint network as a result of the user choice 202
is evaluated and previous state of any nodes that have changed in
response to the user choice is saved.
[0027] When the functionality of FIG. 2 is complete, for each node
affected by propagation in the constraint network, the prior domain
state is recorded and is associated with the current choice.
[0028] FIG. 3 graphically illustrates the functionality of FIG. 2
when a user choice is received in accordance with one embodiment.
As shown in the example of FIG. 3, a user has made a choice A,
followed by choice B, followed by choice C. Each choice contains a
set of affected nodes in the constraint network. For choice B, the
affected nodes are shown in box 300. As shown, one of the affected
nodes for choice B, node X, has a prior state of a numerical range
of 3-7. This prior state is what is recorded at 208 of FIG. 2. In
FIG. 3, having a numeric range that captures the state of a domain
is a simplified example. In operation, other kind of domains may
have different representations of the domain state, some much more
complex than what is shown in FIG. 3.
[0029] Because for each user choice the prior state of each
affected node is stored, embodiments of the present invention can
efficiently remove prior user choices (i.e., backtracking by the
user) without requiring a restart of the system. FIG. 4 is a flow
diagram of the functionality of product configurator 16 when a user
removes a prior choice among a series of choices (or just a single
choice) in accordance with one embodiment. It is assumed that for
every user choice made, the prior node states were stored as in
FIG. 2. Product configurator 16 recognizes that the user is
changing a previous selection that was made by the user in one
embodiment through the user's interaction with the configurator
(e.g., the user unchecks a previously checked box) so that the
request comes directly from the user.
[0030] In one embodiment, the series of user choices are arranged
in a chronological list, with the most recent user choice at the
end of the list. At 402, the user choice from the end of the list
is removed.
[0031] At 404, for the removed user choice at 402, all of the nodes
that were changed by that user choice are restored. The previous
state of the nodes were stored via the functionality of FIG. 2 when
the user choice was received. The constraint network is therefore
restored to its state before the choice was made.
[0032] At 406, it is determined if the choice is the target of the
removal (i.e., is the choice that the user wants to remove). If the
choice is not the target of removal, then the choice is saved in a
list of choices to be reapplied at 408. Functionality then returns
to 402, where the next choice from the end of the list is
removed.
[0033] If the choice is the target of removal at 406, then at 410
all of the saved choices are reapplied incrementally, so that when
each user choice is reapplied the functionality of FIG. 2 is
executed.
[0034] FIG. 5 graphically illustrates the functionality of FIG. 4
when removing a prior user choice from a list of user choices and
while backtracking through the list in accordance to one
embodiment. In the example of FIG. 5, the user choices in
chronological order, are A, B, C and D, as shown at 500. The user
then decides to remove user choice B.
[0035] At 502, the user choice at the end of the list, choice D, is
removed and the functionality of FIG. 4 is executed. When a choice
is removed, the network is restored to the state it was in before
the choice was made. Since choice D is not the choice to be
removed, at 504 choice C is removed. Since choice C is not the
choice to be removed, at 506 choice B is removed.
[0036] Choice B is the choice to be removed. Therefore, at 508,
choice C is reapplied, and at 510, choice D is reapplied. When each
choice is reapplied, the functionality of FIG. 2 is executed (i.e.,
the prior state of each affected node is saved).
[0037] A user may make an inconsistent choice when interacting with
product configurator 16. For example, in configuring a computer
system, a user may choose a large power cord that because of
constraints in the network requires a large power supply. However,
the user may have previously chosen a small power supply. Thus, the
choice of the large power cord is inconsistent with the constraints
and/or prior choices. In one embodiment, product configurator 16
will automatically retract the inconsistent choice, leaving the
configurator in its previous consistent state and eliminating the
need for a restart. The automatic retraction generates an internal
"request" to remove the inconsistent choice. FIG. 6 is a flow
diagram of the functionality of product configurator 16 when
retracting an inconsistent choice in accordance with one
embodiment.
[0038] At 602, the user choice is received and propagated
throughout the constraint network.
[0039] At 604, it is determined if the user choice created a
conflict or inconsistency in the constraint network.
[0040] If a conflict is determined at 604, at 606 the user choice
is retracted and the previous state of the nodes of the network are
restored. The previous state of the nodes was stored when the user
choice was received and the functionality of FIG. 2 was
executed.
[0041] At 608, the user is alerted of the conflict. For example, a
message can be generated that states that "This choice is
inconsistent with a prior choice and will be retracted".
[0042] In one embodiment, a user may wish to designate a user
choice as having a higher priority than other choices. For example,
in configuring a computer system, a user may select a specific
printer, and specify that the printer selection is more important
than any other configuration choice, or is more important than some
specific choices, such as the computer system power supply. In
response, one embodiment of product configurator 16 automatically
removes any prior choices that may are inconsistent with the higher
precedent user choice. This is achieved by incrementally
backtracking and inserting the higher precedent choice before the
lower precedent choices.
[0043] FIG. 7 is a flow diagram of the functionality of product
configurator 16 when a user adds a new choice with a higher
precedent than prior choices in accordance with one embodiment. The
user may specify that a choice is more important than all other
choices, or that it is more important than specific choices. The UI
will allow the user to make a designation of the precedence at the
time of the choice in one embodiment. The new choice with a higher
precedent may automatically generate an internal "request" to
remove a previous choice that has a lower precedent.
[0044] At 702, the user choice from the end of the current list of
user choices is removed.
[0045] At 704, the nodes are restored so that the constraint
network is in the state it was before the choice at 702 was made.
The nodes can be restored because the functionality of FIG. 2 was
executed when each user choice was received.
[0046] At 706, the choice is saved for reapply.
[0047] At 708, it is determined if the insertion point is reached.
The insertion point is the point in the list of choices where the
new choice having precedent should be inserted so that all choices
below have lower precedence. If the insertion point is not reached,
functionality returns to 702 where the next choice at the end of
the list is removed.
[0048] If the insertion point is reached at 708, the new choice is
inserted at 710.
[0049] At 712, the saved choices are reapplied. As each choice is
reapplied, conflicts are determined in view of the new choice that
was inserted. Therefore, any newly arisen conflict will prevent the
saved choice from being reapplied since the saved choice has a
lower precedent than the new choice.
[0050] FIG. 8 graphically illustrates the functionality of FIG. 7
when inserting a new choice having higher precedent into a list of
user choices in accordance to one embodiment.
[0051] At 800, four user choices have been made, choices A, B, C,
and D. The new choice, user choice E, is selected and the user
specifies that it has precedence over or is more important than
choices B, C and D.
[0052] At 802, choice D has been removed. At 804, choice C has been
removed. At 806, choice B has been removed. Therefore, the choices
have been incrementally backtracked to the insertion point.
[0053] At 808, new choice E is inserted at the insertion point
(i.e., after choice A but before choices B-D).
[0054] At 810, choice B is reapplied. Choice C is then reapplied,
but fails on reassertion due to conflicts with choice E. Finally,
choice D is reapplied at 812. As a result, new choice E is inserted
at the proper place on the list of choices and the user can
continue making additional choices without requiring a restart.
[0055] As disclosed, embodiments of the configurator save the state
of all affected nodes of a constraint network for every new
received user choice. Therefore, if the user choice has to be
removed for any reason such as a conflict, a decision to remove by
a user, a newer higher precedent choice being received, etc., the
constraint network can be easily restored to its prior state
without requiring a restart. Therefore, the user's interactive
experience is less disruptive.
[0056] Several embodiments are specifically illustrated and/or
described herein. However, it will be appreciated that
modifications and variations of the disclosed embodiments are
covered by the above teachings and within the purview of the
appended claims without departing from the spirit and intended
scope of the invention.
* * * * *