U.S. patent application number 13/225400 was filed with the patent office on 2012-06-07 for automated facilities management system.
This patent application is currently assigned to PEPPERDASH TECHNOLOGY CORPORATION. Invention is credited to Anker Berg-Sonne, David M. Huselid, Howard A. Nunes, Sumanth Rayancha.
Application Number | 20120143356 13/225400 |
Document ID | / |
Family ID | 45044684 |
Filed Date | 2012-06-07 |
United States Patent
Application |
20120143356 |
Kind Code |
A1 |
Berg-Sonne; Anker ; et
al. |
June 7, 2012 |
AUTOMATED FACILITIES MANAGEMENT SYSTEM
Abstract
An automated facilities management system has the ability to
predict occupant behavior by identifying recurring patterns in the
way that people use buildings and comparing them with environmental
characteristics. This technology is not limited to human behavior
patterns, but extends to any mechanical systems or data points that
tend to vary in recurring patterns. The data processing is carried
out by rules engines triggered by relational database
modifications.
Inventors: |
Berg-Sonne; Anker; (Stow,
MA) ; Huselid; David M.; (Burlington, MA) ;
Nunes; Howard A.; (Swampscott, MA) ; Rayancha;
Sumanth; (New York, NY) |
Assignee: |
PEPPERDASH TECHNOLOGY
CORPORATION
Allston
MA
|
Family ID: |
45044684 |
Appl. No.: |
13/225400 |
Filed: |
September 2, 2011 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
61379714 |
Sep 2, 2010 |
|
|
|
61379715 |
Sep 2, 2010 |
|
|
|
61409532 |
Nov 2, 2010 |
|
|
|
Current U.S.
Class: |
700/49 |
Current CPC
Class: |
H02J 3/003 20200101;
Y02B 70/3225 20130101; Y04S 20/222 20130101; H02J 3/14 20130101;
G05B 15/02 20130101 |
Class at
Publication: |
700/49 |
International
Class: |
G05B 13/02 20060101
G05B013/02 |
Claims
1. A system for automatically managing a facility, comprising: a
plurality of sensor devices providing sensed data; a plurality of
control devices for actuating facility devices; a data store having
a plurality of patterns related to the sensor devices; a processor
coupled to the data store, the sensor devices, and the control
devices, the processor being responsive to the sensed data over
time from the sensor devices to: store the sensed data over time in
the data store; calculate the best match pattern from sensed data
over time and the plurality of patterns; predict future sensed data
from the best match pattern; and signal a control device based on
the predicted future sensed data.
2. The system of claim 1, wherein the sensor devices are occupancy
sensors.
3. The system of claim 1 further comprising a building management
system disposed between the processor and the control devices.
4. The system of claim 1, wherein the data store includes a
relational database.
5. The system of claim 4, wherein the relational database is ACID
compliant.
6. The system of claim 1, wherein the patterns include expected
sensor data for an interval of time.
7. The system of claim 6, wherein the interval of time is divided
into equal length time slices.
8. The system of claim 1, wherein the processor includes a rules
engine.
9. A method for automatically managing a facility, comprising:
receiving sensed data from a plurality of sensor devices providing
sensed data; providing a plurality of control devices for actuating
facility devices; storing a plurality of patterns related to the
sensor devices in a data store; coupling a processor coupled to the
data store, the sensor devices, and the control devices, the
processor being responsive to the sensed data over time from the
sensor devices to: store the sensed data over time in the data
store; calculate the best match pattern from sensed data over time
and the plurality of patterns; predict future sensed data from the
best match pattern; and signal a control device based on the
predicted future sensed data.
10. An article of manufacture, comprising: a machine-readable
medium; a set of program code segments embodied on the
machine-readable medium, the program code segments including
machine instructions for a method for automatically managing a
facility, the method comprising: receiving sensed data from a
plurality of sensor devices providing sensed data; providing a
plurality of control devices for actuating facility devices;
storing a plurality of patterns related to the sensor devices in a
data store; coupling a processor coupled to the data store, the
sensor devices, and the control devices, the processor being
responsive to the sensed data over time from the sensor devices to:
store the sensed data over time in the data store; calculate the
best match pattern from sensed data over time and the plurality of
patterns; predict future sensed data from the best match pattern;
and signal a control device based on the predicted future sensed
data.
Description
RELATED APPLICATIONS
[0001] This application claims the benefit of: [0002] U.S.
Provisional Application No. 61/379,714, entitled PATTERN MATCHING
FOR AUTOMATED ENERGY MANAGEMENT SYSTEM and filed on Sep. 2, 2010;
[0003] U.S. Provisional Patent Application No. 61/379,715, entitled
RULES ENGINE FOR AUTOMATED ENERGY MANAGEMENT SYSTEM and filed on
Sep. 2, 2010; and [0004] U.S. Provisional Patent Application No.
61/409,532, entitled SYSTEM FOR MEASURING AND MANAGING GROUP
COMFORT USING OCCUPANT FEEDBACK and filed on Nov. 2, 2010. The
entire teachings of the above applications are incorporated herein
by reference.
BACKGROUND
[0005] Smart Building technologies are typically employed in an
effort to monitor and control elements of a building. In such
systems, the various building subsystems are integrated into a
network infrastructure with a common user interface. The integrated
subsystems typical include mechanical and electrical equipment such
as Heating, Ventilation, and Air Conditioning (HVAC), lighting,
power, fire, communications, and security systems
[0006] While the Smart Building interface allows a user to manage
HVAC and lighting, the functions are controlled by manually
entering set points. While different zones can have differing set
points and differing target temperatures and lighting levels, the
zones typically have a morning set point and an evening set point.
After the morning set point, the thermostats and lighting
controllers are set in anticipation of zone occupancy. Likewise,
after the evening set point, the thermostats and lighting
controller are set in anticipation of the zone being unoccupied.
The settings are usually dictated by building management to reflect
standard work hours.
[0007] While weekdays, weekends, and holidays are recognized and
programmed differently, workers who come in early or stay late may
be uncomfortable. Likewise, zones that are vacant during a
particular workday will be treated and being occupied, wasting
energy. Special action must be taken by building management to
accommodate special occupancy requests, such as working on weekends
or unusual hours. To avoid this problem, set points are often left
fully closed (occupied setting) around the clock, which is a
substantial waste of energy.
SUMMARY
[0008] In the domain of Smart Buildings, the ability to predict
future occupant needs, and intelligently address those needs
preemptively, is a very powerful capability. For example, being
able to predict accurately when a building or a section of a
building will be occupied and preemptively adjust lighting and HVAC
(Heating, Ventilation & Air Conditioning) optimizes occupant
comfort. Conversely, being able to predict accurately when
buildings and sections of buildings will be unoccupied and setting
lighting and HVAC for maximum energy savings during those periods
minimizes energy consumption. A particular automated facilities
management system also changes settings in anticipation of changes
in occupancy. For example, coasting is done well in advance of the
time that the space will be unoccupied. Doing all provides better
comfort and energy savings.
[0009] An automated facilities management system in accordance with
particular embodiments of the invention has the ability to predict
occupant behavior by identifying recurring patterns in the way that
people use buildings and comparing them with environmental
characteristics. This technology is not limited to human behavior
patterns, but extends to any mechanical systems or data points that
tend to vary in recurring patterns.
[0010] A particular embodiment of the invention includes a method
for predicting future behavior. That method includes: [0011]
collecting historical data related to a behavior; [0012] processing
the historical data into intervals related to the behavior; [0013]
processing the intervals of historical data into a plurality of
patterns; [0014] comparing current data related to the behavior
with the patterns to determine a best fit pattern that is most
similar to the current data; and [0015] applying the data in the
best fit pattern to predict future data related to the
behavior.
[0016] In more particular embodiments, the behavior can be a group
behavior. Also processing the intervals of historical data can
include performing a cluster analysis to identify the patterns.
Additionally, comparing the current data can include performing a
cluster analysis to identify the best fit pattern from the
plurality of patterns. That cluster analysis can weigh recent
current data more than distant current data.
[0017] The intervals can be divided into an equal number of slices.
Specifically, the slices can be consecutive time slices.
[0018] Furthermore, the method can include making adjustments in
anticipation of the predicted data. In addition, the method can
solicit feedback and make adjustments in response to the
feedback.
[0019] Another embodiment of the invention can include a system for
automatically managing a facility. The system can include: [0020] a
plurality of sensor devices providing sensed data; [0021] a
plurality of control devices for actuating facility devices; [0022]
a data store having a plurality of patterns related to the sensor
devices; [0023] a processor coupled to the data store, the sensor
devices, and the control devices, the processor being responsive to
the sensed data over time from the sensor devices to: [0024] store
the sensed data over time in the data store; [0025] calculate the
best match pattern from sensed data over time and the plurality of
patterns; [0026] predict future sensed data from the best match
pattern; and [0027] signal a control device based on the predicted
future sensed data.
[0028] Another particular embodiment of the invention can include
an automated computing system, including a database system and a
rule.
[0029] The database system can store data in an organized structure
and trigger an event upon modifications to the stored data. The
database system can include an ACID-compliant relational database
storing the data in tables with data columns.
[0030] The rule can be responsive to the triggered event to process
an action based on the stored data. The rule can include a rule
definition identifying the data that triggers the rule. More
particularly, the rule definition can include a list of data that
triggers the rule. The rule can also include an assigned
priority.
[0031] As for the action, the action can succeed or fail and a
failed action can be retained and can be restartable.
[0032] Another particular embodiment of the invention can include a
more particular automated computing system, including a relational
database system and a plurality of rules.
[0033] The relational database system can store data in an
organized structure of tables having columns of data. The
relational database system can also trigger an event upon
modifications to the stored data. In particular, the relational
database can be ACID compliant.
[0034] Each rule can include a list of table and column pairs in
the relational database that trigger the rule and an action process
responsive to a event to the data stored in a table and column from
the list, where the action can process a subset of the stored data.
The rule can further include an assigned priority.
[0035] In particular, the subset of stored data can include data
not in the table and column pairs. Also a plurality of instances of
a same rule can execute in parallel. Furthermore, instances of the
same rule can be triggered by different table and column pairs. The
triggering and execution of the rules can be multi-threaded and/or
asynchronous.
[0036] Furthermore, the action can succeed or fail and a failed
action can be retained and can be restartable. More particularly,
triggered rules can be stored as entries in an execution queue. The
rules entered in the execution queue can be modified. Those
modified rules can also be consolidated.
BRIEF DESCRIPTION OF THE DRAWINGS
[0037] The foregoing and other objects, features and advantages of
the invention will be apparent from the following more particular
description of particular embodiments of the invention, as
illustrated in the accompanying drawings in which like reference
characters refer to the same parts throughout the different views.
The drawings are not necessarily to scale, emphasis instead being
placed upon illustrating the principles of the invention.
[0038] FIG. 1 is a schematic block diagram of a particular
automated facilities management system.
[0039] FIG. 2 is a schema diagram for a simplified LEO database of
FIG. 1.
[0040] FIG. 3 is a database schema diagram for a rules database
used by the rules engines of FIG. 1.
[0041] FIG. 4 is a pictorial diagram of an exemplary office having
a simplified array of sensors.
[0042] FIG. 5 is an exemplary normalized graph of all occupancy
sensor readings for the office of FIG. 4 over a one-day time
interval.
[0043] FIG. 6 is a graph showing the application of an exemplary
occupancy pattern of FIG. 5 to thermostat settings.
[0044] FIG. 7 is a graph showing a more detailed application of the
exemplary pattern of FIG. 5 to thermostat settings.
[0045] FIG. 8 is a flowchart of the overall process for pattern
detection, matching, and prediction.
[0046] FIG. 9 is a block diagram illustrating the process of
calculating the similarity of sensor readings for two time
intervals.
[0047] FIG. 10 is a flowchart for a particular precise method to
identifying clusters.
[0048] FIG. 11 is a flowchart for a particular heuristic method to
identifying patterns.
[0049] FIG. 12 is a block flow diagram for a particular pattern
matching algorithm on a LEO of FIG. 1.
[0050] FIG. 13 is a flowchart for the detailed process of
determining the default pattern for a time interval in FIG. 8.
[0051] FIG. 14 is flowchart for the detailed process of dynamically
updating the default pattern from FIG. 8.
[0052] FIG. 15 is a flowchart for the detailed process of
retrieving a predicted value for a sensor from FIG. 8.
[0053] FIG. 16 is an exemplary graph illustrating the trade-offs in
balancing energy saving with occupant comfort.
[0054] FIG. 17 is a flow diagram illustrating the processing of
feedback for a control zone within a subsystem.
[0055] FIG. 18 is an exemplary user interface for feedback
devices.
[0056] FIG. 19 is a block diagram of a rule definition in
accordance with particular embodiments of the invention.
[0057] FIG. 20 is a flowchart of a particular rules engine in
accordance with particular embodiments of the invention.
[0058] FIG. 21 is a flowchart of rule triggering logic of FIG.
20.
[0059] FIG. 22 is a flowchart for translation of event queue
entries into rule execution queue entries from FIG. 20.
[0060] FIG. 23 is a flowchart of rule execution logic of FIG.
20.
[0061] FIG. 24 is a flowchart of a process for translation of event
queue entries into rule execution queue entries from FIG. 22 to
include queue entry modification.
[0062] FIG. 25 is a block diagram of rule definition components of
FIG. 19 modified to support execution queue entry modification of
FIG. 24.
DETAILED DESCRIPTION
[0063] An automated facilities management system in accordance with
particular embodiments of the invention is useful in residential
and commercial buildings. In particular, the system can tailor a
building's energy usage to known or derived occupancy patterns and
the building's energy parameters. By doing so, energy can be more
efficiently used when needed and conserved when not needed.
[0064] FIG. 1 is a schematic block diagram of a particular
automated facilities management system. The system includes a
client-side infrastructure 2 on a Local Area Network (LAN) and a
remote central hosting infrastructure 8. The client-side
infrastructure 2 communicates with the central hosting
infrastructure 8 via a Wide Area Network (WAN) 7, such as the
public Internet.
[0065] The client-side infrastructure includes one or more Local
Energy Optimizers (LEO) 20-1, 20-2. Each LEO 20-1, 20-2 is
responsible for executing a local energy conservation plan. A
particular building may require multiple LEOs, depending on various
factors including network infrastructure. Indeed, each business
operating within a building can have one or more dedicated LEOs.
The LEOs function autonomously, but each will generally be embodied
in a commercially-available desktop or laptop computer having
limited processing power and memory.
[0066] Each LEO 20-1, 20-2 is in communication with a plurality of
facility devices 30 located throughout a monitored space. The
facility devices 30 include sensors 32 and controls (i.e.
actuators) 37.
[0067] While the sensors 32 can directly communicate with the LEOs
20-1, 20-2, certain sensors 32 communicate via a separate sensor
controller 34-2, such as a third-party Crestron controller. Example
sensors include, but are not limited to: [0068] occupancy sensors
to detect the presence of a person, such as Infrared motion
sensors, Bluetooth, RFID, or other wireless RF emitters, oxygen
sensors, and manually activated switches (light switches, computer
keyboards, touch panels etc.); [0069] temperature sensors to detect
the temperature at the sensor; [0070] gas detectors, such as carbon
monoxide detectors; [0071] humidity sensors; and [0072] light
sensors to detect the light level at the sensor.
[0073] Similarly, the LEOs 20-1, 20-2 forward commands to a
plurality of controls 37 to adjust the energy usage of the space.
Examples of such controls include, but are not limited to: [0074]
relays; [0075] thermostats; and [0076] light dimmers.
[0077] While the LEOs 20-1, 20-2 can directly communicate with the
controls 37, such as in a residential environment, a particular
embodiment of the invention exploits third-party Building
Management System (BMS) controllers 39-1, 39-2 to operate facility
controls 37. Such BMS controllers 39-1, 39-2, available from
various sources, are typically installed in commercial buildings to
control and monitor the building's mechanical and electrical
equipment such as HVAC, lighting, power systems, fire systems, and
security systems.
[0078] In particular, commercial BMS controllers 39-1, 39-2 are
programmed to operate a network of control actuators 37 to obtain a
desired result (e.g. temperature change). In other words, the
building's BMS controllers 39-1, 39-2 already know what systems
need to be adjusted and how each component in the system (dampers,
mixing valves, etc.) needs to be actuated to accomplish a result
without compromising other parts of the system. What the BMS
controllers lack is an understanding of when to make macro
adjustments such as zone temperature changes, instead relying on
human policy or configuration input. By integrating with the BMS,
the LEOs automate the "when" part of the equation by predicting
future needs. The actual protocols used to communicate with the BMS
are product specific.
[0079] More particularly, when to apply changes to HVAC settings in
anticipation of a predicted change in occupancy is determined by
establishing the heating and cooling characteristics of the HVAC
zone through regression analysis of the rate of change in
temperature as a function of HVAC heating or cooling demand,
interior temperature, exterior temperature, and solar heating
through windows. The coefficients derived from this analysis
establish the characteristic of the zone. By applying these
coefficients to actual conditions, the time to heat or cool the
space to the desired temperature can be determined. Once this time
has been established, it can be applied to the predicted occupancy
and an optimal time to either actively heat or cool the space, or
turn off active heating and cooling and let the temperature settle,
can be determined. By continually performing this analysis, changes
in coefficients will be indicators of changes in HVAC system
performance or in building shell performance.
[0080] Data from the sensors 32 is stored in a local data store
29-1, 29-2 as relational database tables 28-1, 28-2. Each LEO 20-1,
20-2 includes a respective rules engine 22-1, 22-2 for processing
the stored sensor data and signaling the controls 37 and BMS
controllers 39-1, 39-2, if necessary. Each rules engine 22-1, 22-2
employs a respective rules database 24-1, 24-2 to manage data and
processing. In a particular embodiment, the rules engines 22-1,
22-2 are implemented as Windows Services under a Microsoft Windows
operating system.
[0081] Also in communication with the WAN 7 and accessible by the
LEOs 20-1, 20-2 are logical sensors 74, which provide external data
to the LEOs 20-1, 20-2. Examples of logical sensors 74 include
weather forecasts, such as provided by Google, Inc., climate
models, electricity rates, time signals from time services, and
other data feeds.
[0082] The LEOs 20-1, 20-2 communicate through the WAN 7 with a
central server 82 on the central hosting infrastructure 8. It
should be understood that the database for an LEO can include data
from sensors 32 that signal another LEO, by receiving the sensor
data over the LAN or via the central server 82. Specifically, the
LEO will periodically send data to the central server 80 for
storage or transfer to another LEO. The LEO can also send a request
for data to the central server 80, where it will either reply with
data or timeout. Because the LEOs 20-1, 20-2 will typically
communicate through a firewall 40-1, 40-2, the communication is
initiated by the LEOs 20-1, 20-2 through an open firewall port
(such as a Hyper-Text Transport Protocol (HTTP) request through
port 80).
[0083] The central server 80 is responsible for storing long-term
data and operating on the data, particularly pattern detection and
analysis. The central server 80 communicates with a data warehouse
89 storing a relational database 88. Human interaction with the
system is through a computer interface, such as a web client 27
(PC), 77 (smartphone), a mobile client 76 or feedback devices 25
(smartphone), 26 (PC). Note that human interaction can also be
initiated on the central hosting infrastructure 8, depending on how
implemented.
[0084] By disposing the central server 80 on the WAN 7, the data
warehouse 89 can be used to store historical data and patterns from
numerous client sources. That micro data can then be exploited to
derive macro data for use by energy utilities and energy brokers.
To that end, a particular embodiment of the invention deploys the
central hosting infrastructure 8 on a commercial cloud computing
system. Of course, the central server 80 and data warehouse 89 can
be disposed on the client LAN for clients, such as government
entities, that desire or require secure control over its data and
patterns.
[0085] The central data warehouse 89 stores historical data for
each LEO 20-1, 20-2 and each LEO 20-1, 20-2 locally stores current
data at least until transferred to the central server 80, such as
once per day (e.g. overnight transfer). Once the central data
warehouse 89 stores a sufficient amount of historical data, the
historical data is processed by a server rules engine 82 on the
central server 80 to detect patterns in the data. The rules engine
82 employs a server rules database 84 to manage data and
processing. Again, in a particular embodiment, the rule engine 82
is implemented as Windows Services under a Microsoft Windows
operating system.
[0086] One important measure of patterns is the occupancy rate of
an office or home as viewed over a period of time, such as daily.
For example, instead of a building usage following a simple,
weekday or weekend pattern there can be several usage patterns for
both a weekday and a weekend. Knowing those patterns allows
significant energy conservation by anticipating demand. In a
particular embodiment, pattern detection and recognition processing
is performed at a convenient periodic time, such as on a weekly
basis.
[0087] Once patterns are recognized, those patterns are useful for
predicting future behavior, such as occupancy. Specifically, as
long as occupancy can be correlated with a known pattern, it can be
assumed that the pattern will continue at least for the near term.
For that use, the various detected patterns are transferred to the
LEO databases 28-1, 28-2 for real-time matching.
[0088] FIG. 2 is a schema diagram for a simplified LEO database of
FIG. 1. The LEO database 28 is shown as a group of related data
tables. The tables include a clients table 280, a spaces table 281,
a leos table 282, a controllers table 283, a controllerattributes
table 284, a devices table 285, a deviceattributes table 286, a
sensorsandcontrols table 287, a sensororcontrollog table 288, and a
timeslotlog table 289. It should be understood that the illustrated
database is not a complete database, but instead is meant to
highlight some core aspects of the data.
[0089] The clients table 280 defines the installations of the
management system included in the database. The table columns
include: [0090] ClientID: Unique identifier for the installation
[0091] Name: A descriptive name for the installation
[0092] The spaces table 281 includes hierarchical definitions of
the spaces (locations, buildings, floors, zones, rooms) of all
installations. The table columns include" [0093] ClientID: The
installation that this space is within [0094] NodeID: A unique
identifier for this space within the installation [0095] Name: A
descriptive name for this space
[0096] The leos table 282 includes entries for all LEOs within all
installations. The table columns include: [0097] ClientID: The
installation that this LEO is installed at [0098] LEOID: A unique
identifier for this LEO within the installation [0099] Name: A
descriptive name for this LEO
[0100] The controllers table 283 includes entries for all
interfaces to controllers, sensors or controls across all
installations. The table columns include: [0101] ClientID: The
installation that the interface is installed at [0102] LEOID: The
LEO that communicates with the interface [0103] ControllerID: A
unique ID for this interface on this LEO
[0104] A controller represents an interface to a third-party
controller or a network interface and protocol to a bank of
directly controlled sensors and controls. The controllerattributes
table 284 controls meta data describing the controller. Controllers
are associated with LEOs. These are physical associations.
[0105] The controllerattributes table 284 thus includes entries
that define the attributes for each controller, such as the type of
interface (BMS, Bluetooth, ZigBee), the address of the interface,
and any other interface-specific meta data. The table columns
include: [0106] ClientID: The installation that the interface is
installed at [0107] LEOID: The LEO that communicates with the
interface [0108] ControllerID: A unique ID for this interface on
this LEO [0109] Attribute: A controller-unique name for the
attribute [0110] Value: The value of the attribute
[0111] The devices table 285 includes an entry for each device
(sensor or control). The table columns include: [0112] ClientID:
The installation that the device is installed at [0113] LEOID: The
LEO that communicates with the interface [0114] ControllerID: The
controller that this device is interfaced through [0115] DeviceID:
A controller-unique ID for this device [0116] SensorOrControlID: If
not null, the sensor or control that should receive send data to or
from this device [0117] Name: A descriptive name for this
device
[0118] Notice that sensors and controllers are directly tied to
spaces. These connections may be physical or logical. The
connection between sensors and controls to LEOs is through devices
and controllers.
[0119] The deviceattributes table 286 includes entries that define
attributes for each device, such as the network address. The table
columns include: [0120] ClientID: The installation that the device
is installed at [0121] LEOID: The LEO that communicates with the
interface [0122] ControllerID: The controller that this device is
interfaced through [0123] DeviceID: The ID for this device [0124]
Attribute: A device-unique name for the attribute [0125] Value: The
value of the attribute
[0126] The sensorsandcontrols table 287 includes entries for all
sensor values, control settings and intermediate values used by
rules. The table columns include: [0127] ClientID: The installation
that this value is used by [0128] SensorOrControlID: A
client-unique ID for the value [0129] Name: A descriptive name for
this value [0130] NodeID: If not null, the ID of the space (zone,
room, . . . ) that the sensor or control is associated with [0131]
Type: "Binary", "Range", "String", or "Timer". The type of value.
[0132] Read: If 1, indicates that the value is read from a sensor
[0133] Write: If 1, indicates that changes in the value need to be
written to a control [0134] Log: If 1, indicates that any changes
in the value must be transmitted to the central server [0135]
Visible: If 1, indicates that the value should be visible through
the reporting interfaces [0136] Scale: Constant used for
normalization [0137] Class: The class of value, like temperature,
motion, light, . . . [0138] BinaryValue: Contains the value if
Type="Binary" and the alarm status is Type="Timer" [0139]
RangeValue: Contains the value if Type="Range" and the countdown
timer if Type="Timer" [0140] StringValue: Contains the value if
Type="String"
[0141] The sensororcontrollog table 288 includes the new value and
time of transitions for sensors and controls. The table columns
include: [0142] ClientID: The installation that the sensor or
control is installed at [0143] LogID: Unique identifier for this
entry in the table [0144] SensorOrControlID: The ID of the sensor
or control [0145] Value: A string representing the new value of the
sensor or control [0146] TimeStamp: The date and time of the
transition
[0147] The timeslotlog table 289 includes average values for a
sensor or control across a time slot. The table columns include:
[0148] ClientID: The installation that the sensor or control is
installed at [0149] SensorOrControlID: The ID of the sensor or
control [0150] StartTime: The date and time of the start of the
time slot [0151] Average: The average value of the sensor or
control during the time interval
[0152] FIG. 3 is a database schema diagram for a rules database
used by the rules engines of FIG. 1. The rules database 24 is shown
as a group of related data tables. The tables include a classes
table 241, a rules table 242, a rule_parameters table 243, an
event_queue table 244, and a rule_queue table 245. Here again, it
should be understood that the illustrated database is not a
complete database, but instead is meant to highlight some core
aspects of the data.
[0153] The classes table 241 defines the base classes for rules and
includes columns with meta data for loading the code implementing
the classes. The table columns include: [0154] ClassName: Unique
name for the class [0155] AssemblyPath: Contains the storage path
to the folder containing the assembly containing the class assembly
file. [0156] AssemblyFile: Contains the file name of the assembly
class file. [0157] AssemblyClass: The name that the class is
registered as in the assembly class file
[0158] The rules table 242 defines all rules. It includes an entry
for all rules being used by the application running on the rules
engine. The table columns include: [0159] RuleName: Unique name for
the rule. [0160] Description: A short description of the rule.
[0161] ClassName: The name of the class from which the rule is
derived. [0162] Priority: The priority that the rule will run at (1
and up). Smaller values are higher priorities.
[0163] The rule_parameters table 243 is used when deriving multiple
rules from a single class. It may, for example, define the table(s)
and column(s) that the rule will be triggered by and perform
actions on. The table columns include: [0164] RuleName: Name of the
rule the parameter customizes. [0165] ParameterName: Rule-unique
name of the parameter. [0166] ParameterValue: Value of the
parameter.
[0167] The event_queue table 244 includes a FIFO (First In, First
Out) queue of events. The table columns include: [0168] EventID:
Unique ID for the event [0169] TableName: Name of the table that
triggered the event [0170] ColumnName: Name of the column that
triggered the event [0171] Action: "Insert", "Update" or "Delete".
Contains the verb of the SQL statement that triggered the event.
[0172] PrimaryKeys: Encoded string containing the values of the
primary key fields of the row that triggered the event
[0173] The rule_queue table 245 includes an entry for each rule
that is queued for execution, running, or has failed. The table
columns include: [0174] RuleID: A unique ID for the rule instance
(multiple instances of the same rule, triggered by different
events, may exist in the queue) [0175] RuleName: The name of the
rule [0176] TableName: The name of the table that triggered the
rule [0177] ColumnName: Name of the column that triggered the rule
[0178] PrimaryKeys: Encoded string containing the values of the
primary key fields of the row that triggered the rule [0179]
InstanceParameters: String that further defines the data the rule
should act on. May be set when a rule is scheduled by another rule
or by external code [0180] Action: "Insert", "Update" or "Delete".
Contains the verb of the SQL statement that triggered the rule
[0181] State: "N" (waiting to run), "W" (running), "R" (running to
be rescheduled after completion), or "F" (failed) [0182] Priority:
Priority of the rule [0183] Scheduled: The date and time the rule
was scheduled or rescheduled [0184] Exception: Information about
the nature of the failure when State="F"
[0185] With the basic structure of the system and its databases,
the detailed processing will now be described.
[0186] FIG. 4 is a pictorial diagram of an exemplary office having
a simplified array of sensors. The office includes a number of
office spaces, cubicle spaces, and meeting spaces. As shown,
infrared motion sensors IR-1 . . . IR-10 are dispersed throughout
the office. In addition, a Bluetooth receiver BT is centrally
located and paired with employee Bluetooth devices (mobile phones,
etc.). It should be understood that many more sensors can be
deployed and interfaced with an LEO to detect and measure
occupancy.
[0187] The communication between the IR sensors and the LEO (not
shown) is determined by the sensor manufacturer. Some manufacturer
will signal whenever a change is detected, and some will
periodically signal. For this example, it is assumed that the IR
sensors signal changes. Also, the Bluetooth emitters are
periodically polled on a rolling basis, generally cycling every few
seconds depending on the number of emitters and system load.
[0188] In the early morning, the office would typically be
unoccupied so all the sensors are inactive. From the database, we
can determine when employees left the office by looking at data
stored for their respective Bluetooth (cell phone) emitters.
[0189] As the workday begins, Bluetooth emitters from cell phones
and signals from the IR detectors will begin to be reported as
active. Throughout the day motion continues to be detected
throughout the office. Some people may come and go, and others will
move around to continually populate the database.
[0190] As the workday comes to an end, people will begin leaving
the office so sensor activity will decrease. Some people may stay
later than others but typically, everyone will leave for the night.
Sporadic activity may be detected from cleaning crews, security
patrols, and employees returning to the office to work or to
retrieve forgotten items. People fitting those demographics usually
do not require a change in the environmental settings.
[0191] As can be appreciated, occupancy and usage patterns of a
space can be tracked and plotted. To that end, the data changes are
logged for forwarding to the central server 80. The central server
80 analyzes the historical data. In particular, the central server
80 performs statistical analysis to recognize patterns in the data,
such as occupancy patterns. Further analysis can provide more
individualized information, such as individual space usage
patterns.
[0192] FIG. 5 is an exemplary normalized graph of all occupancy
sensor readings for the office of FIG. 4 over a one-day time
interval. To create the graph 100, all occupancy-related sensor
readings are transformed into averaged readings over fixed time
slices 102 along the horizontal axis. The data is then normalized
between values of 0-1, as shown by the vertical axis. The resulting
pattern 105 represents the occupancy levels of the space throughout
the day.
[0193] The length of the time slices is chosen to match the
application of the pattern, which in an HVAC application is a
function of balancing data operations performance against providing
balanced energy efficiency. For example, when controlling heating
and cooling, a 15-minute time slice is a typical choice that
strikes a balance between the amounts of data generated and the
granularity required for optimum comfort. The time slice can be
variable over time, based on circumstances. So if data quantities
were moderate, and comfort could be enhanced by shorter time
slices, the time slices for a space could be shortened.
[0194] By averaging sensor values, the system determines the
probability of certain behaviors for various time intervals with
similar characteristics (such as day of week). The patterns act as
a predictor of sensor values for a given time slices in the future,
especially the next time slice. To that end, the system gathers
sensor data over time, groups the data by time intervals with
similar characteristics, then compares new time intervals with
similar characteristics to find matches. If a match is found, the
system predicts sensor values in the new time interval by recalling
the values found in the past time intervals with similar
characteristics. Because sensor values are indicative of specific
human behaviors, such as occupancy, the system becomes reliable in
the prediction of such human behavior.
[0195] Once the human behavior is patterned, the results can be
used in facilities management. Specifically, predictions based on
the patterns are used to tailor temperature and lighting levels to
the environment. The patterns can also be used to examine other
facility metrics, such as space usage and planning. For example,
individual schedules can be monitored to see if people really use
scheduled rooms. Rooms can also be consolidated into common zones.
Another example application of scheduling involves factory
scheduling and school schedule.
[0196] In addition to human behavior, the system is sensitive to
changes in the electrical and mechanical performance of the
building. If the facilities equipment and physical building do not
behave or respond as expected, those deviations can be logged. As
such, the facilities management system can perform monitoring-based
commissioning of the facility.
[0197] FIG. 6 is a graph showing the application of an exemplary
occupancy pattern of FIG. 5 to thermostat settings. The graph 110
shows the exemplary occupancy pattern 105 for the office
environment. As shown, the pattern 105 is a series of averaged
sensor readings over a plurality of consecutive time slices
102.
[0198] Viewing the data, the pattern 105 can be divided into
multiple operational segments. The office is occupied from the
morning until the evening, with some people coming in earlier than
others and some people leaving later than others. There is no
overnight occupancy. During the occupied working hours segment 115,
the HVAC plan can focus on optimizing employee comfort. During the
overnight segments 117a, 117b, the office is generally unoccupied
and the HVAC system can focus on maximizing savings. During morning
and evening standby segments 119a, 119b, people are entering or
leaving for the day and the HVAC plan can maintain an intermediate
setting by either ramping up the HVAC system during the morning
segment 119a, or allowing the HVAC system to coast to the overnight
setting during the evening segment 119b.
[0199] When exactly the HVAC system is initially ramped up or
begins coasting will depend on the thermal characteristic of the
building. It is understood that the thermal characteristics of the
building are not static or predefined. Instead, the system
determines the rate at which space gains or dissipates heat as part
of its normal operation, thereby self-learning the thermal
characteristics that contribute to the "when" the ramping up or
coasting begins.
[0200] FIG. 7 is a graph showing a more detailed application of the
exemplary pattern of FIG. 5 to thermostat settings. Again, the
graph 120 shows the exemplary occupancy pattern 105 at 15-minute
time slices 102. Also shown, the pattern 105 is used to determine a
target indoor temperature 127. Also shown are plots of the outside
air temperature 129, the heating thermostat set point 122, and the
cooling thermostat set point 128. In a commercial embodiment
utilizing a BMS, the set points are computed by the BMS controller
39-1, 39-2 (FIG. 1). The temperature and occupancy values are also
normalized to a 0-100 range based on the range of sensor values in
the raw historical data.
[0201] It should be understood that the predicted pattern depends
on the time interval characteristics. Characteristics are data that
describe objects and time interval characteristics are data that
describe time intervals. For example, in an office environment,
occupancy is typically different on weekdays as opposed to
weekends. Thus, the day of the week (e.g., Wednesday) is a
characteristic of a "24-hour period starting and ending at
midnight", and one that has an obvious relevance to the occupants
of a space. Depending on the situation, a large number of other
characteristics can be relevant. Examples include, but are not
limited to: [0202] Season [0203] Current weather [0204] Temperature
[0205] Amount of sunlight [0206] Wind [0207] Weather forecast
[0208] Holidays [0209] The particular holiday itself [0210] The
nature or category of holiday [0211] The week containing the
holiday [0212] Fiscal year status [0213] Major projects [0214]
Epidemics [0215] Academic calendar
[0216] The system initially performs general pattern detection
across all time intervals, disregarding characteristics such as the
day of the week. The result is a number of patterns, each of which
is characterized by average sensor values for each time slice, the
number of time intervals that were used in generating the pattern,
and the "density" of the pattern. Density is a measure of how
similar the sensor data is across all the time intervals used to
generate it. Patterns that are generated from many time intervals
and are "dense" are strong indicators of recurring sensor data, and
therefore strong predictors of future sensor values.
[0217] After the patterns have been ascertained, they are matched
against time interval characteristics. For all time intervals that
match a given characteristic, the system determines which pattern
is the best fit. The result is a count for each pattern of the
number of time intervals for which it was the best fit. The pattern
that has the highest count of being the best fit is considered the
best match for the selected characteristic. That best fit match is
then used as a basis for predicting future behavior for facilities
management.
[0218] FIG. 8 is a flowchart of the overall process for pattern
detection, matching, and prediction. The process begins at the
server with retrieving sensor data from stored historical time
intervals 1005, from which recurring patterns are detected at step
1010. The recurring patterns are then saved to storage 1015 for
sharing with the client LEOs.
[0219] On the client-side, the stored recurring patterns 1015 are
combined at step 2030 with the previously stored characteristics of
the time interval 2025 to find a default pattern from time
intervals with similar characteristics. That default pattern is
then used as the initial current pattern 2050 at step 2030.
[0220] Pattern matching is now done against current time interval
2060, which has a starting time slice 2060.sub.1, a current time
slice 2060.sub.K, and an ending time slice 2060.sub.N For the
elapsed time period 2070 from the starting time slice 2060.sub.1 to
the last completed time slice 2060.sub.K-1, current data for each
time slice 2060.sub.1, . . . , 2060.sub.K-1 is compared against
data in a respective time slice 2050.sub.1, . . . , 2050.sub.K-1 in
the current pattern 2050. The recurring patterns 1015 are also
combined at step 2040 with sensor data from elapsed time slices
2015 to find the best match and use as the current pattern if a
better fit is found than the previously selected current
pattern.
[0221] Based on the sensor data in the current pattern, the process
predicts future sensor data at step 2080. It should be understood
that the prediction is most accurate for the current time slice and
the next time slice in the future, while the prediction becomes
less reliable as they more farther in the future. Once data
collection for the current time slice completes, the matching
algorithm at step 2040 and prediction algorithm at step 2080 are
processed again, and iterative continues after each new time
slice.
[0222] The algorithms used for pattern detection and matching are
driven by a tradeoff between accuracy and performance. That
compromise aims to achieve an optimum balance between accuracy,
responsiveness, and computing resource consumption. The algorithms
for measuring similarity of sensor readings between two time
intervals and the heuristic algorithm for detecting recurring
patterns in a large number of time intervals were developed with
this balance in mind.
[0223] As an overview, every time a selected sensor value differs
from the previous reading of the sensor, the date and time of the
transition and the new sensor value is stored in a log file. At the
end of each time slice, the average values for the selected sensors
are calculated and stored with the date and time of the time slice
in an averaged sensor value log file. The average values for all
the selected sensors are normalized for equal weighting to ensure
that all sensors have the same effect on the similarity
calculations. A typical normalization formula adds a base value and
multiplies the result with a factor to yield the same range of
values for all the sensors. A typical normalization will map all
sensor values into a numerical range from 1 to 100.
[0224] The general normalization equation is:
R.sub.n=N.sub.min+(R.sub.a-R.sub.min)*(N.sub.max-N.sub.min)/(R.sub.max-R-
.sub.min)
where R.sub.n is the normalized value, R.sub.a is the average
sensor value, R.sub.min is the smallest value the sensor can
return, R.sub.max is the maximum value the sensor can return,
N.sub.min is the smallest possible normalized value, and N.sub.max
is the largest possible normalized value. In some cases it may be
desirable to select R.sub.min and R.sub.max as the smallest and
largest typical sensor values as opposed to the smallest and
largest possible sensor values.
[0225] The normalized average sensor value is stored in a log file
with the time slice for which it was calculated.
[0226] FIG. 9 is a block diagram illustrating the process of
calculating the similarity of sensor readings for two time
intervals. As shown, the process 1110 divides time intervals into N
equal-sized time slices 1112.sub.1, . . . , 1112.sub.N and
1122.sub.1, . . . , 1122.sub.N. For each time slice, a data value
1114.sub.1, . . . , 1114.sub.N, 1116.sub.1, . . . , 1116.sub.N and
1124.sub.1, . . . , 1124.sub.N, 1126.sub.1, . . . , 1126.sub.N is
stored for each sensor.
[0227] The first step 1130 is to calculate the similarity of sensor
values for each corresponding time slice in the two time intervals.
The time slice similarity function is:
S T = I = 1 M ( R I T 1 - R I T 2 ) 2 M ##EQU00001##
where S.sub.T is the calculated similarity for time slice T,
R.sub.IT1 is the normalized average sensor value for sensor I in
time slice T for time interval 1, R.sub.IT2 is the normalized
average sensor value for sensor I in time slice T for time interval
2, and M is the number of sensors chosen for the calculation.
[0228] Once the similarity of individual time slices within a time
interval are calculated, the overall similarity of the two time
intervals is calculated at step 1140 as:
S O = T = 1 N S T 2 N ##EQU00002##
where S.sub.T is the similarity of sensor readings for time slice
T, and N is the total number of time slices in a time interval.
[0229] The calculated value of similarity becomes zero when the
sensor readings are identical across all time slices. Thus small
values indicate a high degree of similarity and large values
indicate significant differences in sensor readings. In accordance
with a particular embodiment of the invention, the time slices are
considered to be suitably similar if S.sub.o.ltoreq.100.
[0230] While a distance of 100 or less implies similarity in
accordance with a particular embodiment. This value can be modified
over time by determining what values deliver the best patterns.
"Best" means delivering the largest number of patterns. High values
deliver few, large patterns. Too small values will not deliver any
patterns. It is anticipated that a few times a year, all historical
data is analyzed to determine an optimal value. It should be
appreciated that the optimal value is dependent on the
characteristics of the space. For example, a residence will have a
different optimal value than a commercial office space.
[0231] To detect recurring patterns of sensor readings, clusters of
similar time intervals must be identified. Two approaches will now
be described. The first approach is a precise approach that is
guaranteed to identify all clusters, but scales poorly. The second
approach is a heuristic approach that has been shown to find almost
all possible clusters, but which does scale well.
[0232] The precise method was used during the development of the
heuristic method to validate that they generated the same or very
similar patterns. As increasing amounts of data is collected, or
questions are raised about the accuracy of the heuristic algorithm,
the precise algorithm can be used as a baseline for validation or
improvements of the heuristic approach.
[0233] FIG. 10 is a flowchart for a particular precise method to
identifying clusters. The first step 1210 in the method 1200 is to
create an initial set of two-member clusters that includes all
possible pairs of time intervals with similarities no greater than
an absolute maximum cluster size; a value chosen to ensure that
clusters really represent similar patterns. The value is chosen by
analyzing a representative data set with different settings. The
setting that yields the best patterns/clusters becomes the chosen
setting. "Best" will depend on the application. For this
embodiment, "best" was defined as yielding the largest number of
patterns.
[0234] Furthermore, a cluster also must have a minimum number of
members. For this embodiment, three was chosen. The choice is
application dependent and driven by whether there is a need or
desire to yield patterns with small data sets, and the existence of
a need for large numbers of patterns with large data sets.
[0235] The method then enters an iterative loop at step 1220 where
all time intervals are tested against all clusters in which they
are not already a member. At step 1220, for each cluster, all
possible clusters are created with one additional member, but not
exceeding the absolute maximum cluster size. If the addition of the
time interval to the cluster does not cause the cluster to exceed
the maximum cluster size, the time interval is added to the
cluster. The iterative loop continues through step 1230 until a
pass does not add any time intervals to any clusters. All possible
clusters no larger than the absolute maximum cluster size are thus
identified.
[0236] Two additional steps are performed. First, at step 1240, all
clusters less than a certain size are eliminated. An optimal cutoff
size depends on the data, but typically one to two orders of
magnitude smaller than the total number of time intervals
contributing to the process. Next, at step 1250, the process
eliminates overlapping clusters, i.e. clusters that share members.
The approach is to eliminate all but the cluster with the largest
number of members from the overlapping set. If multiple clusters
are of the same size, the one with the highest density is
retained.
[0237] FIG. 11 is a flowchart for a particular heuristic method to
identifying patterns. The heuristic method 1300 for pattern
detection starts at 1310 by creating a list of all possible
pairings of time intervals sorted by similarity, smallest
first.
[0238] The rest of the algorithm runs in a loop that starts at step
1320 with picking the similarity of the first pair in the list as a
current maximum cluster size for this iteration. Viewed
graphically, the new maximum cluster size is a diameter equal to
the distance between the first pair in the list. At step 1330, the
method then determines if any existing clusters can be combined
into a single cluster without exceeding the current maximum cluster
size. Those that can are merged. At step 1340, the method then
determines if any of the time intervals (e.g. days) that are not
already in a cluster can be added to any of the existing clusters
without exceeding the current maximum cluster size. Then at step
1350, all pairs from the list that have similarities not greater
than the current maximum cluster size, and where none of the two
are members of a cluster, are added to the clusters. The final step
1360 of the iterative loop is to remove all pairs where at least
one member of the pair has been assigned to clusters. The iteration
stops when the similarity of the smallest pair in the list exceeds
the maximum cluster size, or there are no more unassigned time
intervals.
[0239] Regardless of which method is employed, every detected
cluster is the source for a pattern. In particular, each pattern is
the sensor value averages from all members of the cluster across
each time slice in the time interval. The collections of patterns
are stored by the server and transferred to the LEOs at an
appropriate time, such as over a weekend. Each LEO then begins
using the patterns in its matching algorithms.
[0240] FIG. 12 is a block flow diagram for a particular pattern
matching algorithm on a LEO of FIG. 1. As shown, the matching
process 1400 compares a pattern 1410 to a current time interval
1420 with an algorithm similar to the one used to compare time
intervals with each other for pattern recognition in FIG. 9.
Instead of comparing historical data, pattern matching compares the
current stream of sensor data values to the recognized
patterns.
[0241] For pattern matching, the general time slice similarity
function is:
S T = I = 1 M ( ( R IP - R IT ) * ( 1 - ( ( ( T N - T T ) T S ) ) )
2 M ##EQU00003##
[0242] where S.sub.T is the calculated similarity for time slice T,
R.sub.IP is the normalized average sensor value for sensor I in
time slice T for the pattern, R.sub.IT is the normalized average
sensor value for sensor I in time slice T for the time interval, M
is the number of sensors chosen for the calculation, T.sub.N is the
time of the current time slice relative to the start of the time
interval, T.sub.T is the time of the time slice being measured
relative to the start of the time slice and T.sub.S is the length
of a time slice.
[0243] One difference between this formula and the one used for
pattern detection is that differences are weighted by the time
difference between the start of the current time slice and the
start of the time slice being measured. The current time slice
difference is given a weight of one, and a time difference of a
full time slice away is given a weight of zero.
[0244] The weighting can be made non-linear by applying an exponent
to the weighting factor as below.
S T = I = 1 M ( ( R IP - R IT ) * ( 1 - ( ( ( T N - T T ) T S ) ) P
) 2 M ##EQU00004##
where P is the exponent applied. The weighting makes differences
that are recent in time carry more weight than differences that are
more distant in time.
[0245] The overall similarity of the pattern to the time interval
is
S O = T = 1 N S T 2 N ##EQU00005##
where S.sub.T is the similarity of sensor readings for time slice
T, and N is the total number of time slices in a time interval.
[0246] FIG. 13 is a flowchart for the detailed process of
determining the default pattern for a time interval in FIG. 8.
Typically, time intervals will have characteristics 2025 that are
relevant to energy management as outlined above. First, the sensor
data from all historical time intervals 1005 and the
characteristics of the time intervals 2025 processed at step 2032
to select historical time intervals with similar characteristics
2033. For characteristic values (e.g., the day of the week),
patterns are ranked at step 2034 by comparing each pattern 1015
with sensor data for each historical time interval having similar
characteristics 2033.
[0247] At step 2036, the process counts the number of times a
particular pattern is the best match for a time interval. Then, at
step 2038, the pattern that has the highest count of being the best
match becomes the default pattern for the given time interval
2050.
[0248] For each time interval characteristic, the pattern with the
highest rank becomes the default pattern for that characteristic.
The default patterns, the characteristics, and the number of times
the patterns is the best match for the characteristic are stored
for prediction of sensor values. It should be appreciated that the
choice of the default pattern is dynamic and can thus change as
frequently as every time slice.
[0249] FIG. 14 is flowchart for the detailed process of dynamically
updating the default pattern from FIG. 8. The process 2040 begins
at step 2042, where at the start of each time slice, the average
sensor values for the current time interval 2015 are matched
against all patterns 1015 and the pattern with the best match is
stored 2055. At step 2044, the stored best match 2055 is compared
to the stored current pattern 2050. At step 2045, if another
pattern is a better match than the currently selected current
pattern 2050, the pattern with the best match 2055 becomes the new
current (i.e. default) pattern at step 2048; otherwise the current
pattern 2050 is continued as the default pattern at step 2046. This
approach ensures that the current pattern reflects actual sensor
data and is adaptive to changes in behavior and usage. In
particular, the system has the ability to recognize when an
exception has occurred and to change the current pattern to a more
appropriate one
[0250] FIG. 15 is a flowchart for the detailed process of
retrieving a predicted value for a sensor from FIG. 8. To predict a
future sensor value at step 2084, the average sensor value stored
for the current pattern's time slice 2081 is used at step 2082,
where the predicted time slice 2050.sub.X is that time slice in the
current time interval to be predicted. Note that this is an
average, and depending on the sensor, interpretation of the average
sensor value meaning can vary. For example, for an occupancy
sensor, a value of 0.5 may indicate that occupancy is likely to
start or end half-way through the time slice.
[0251] How far out in the future to retrieve a predicted sensor
value is dependent on the actual application. For HVAC, the time
needed to bring the building to the desired temperature is the
major factor. This time will vary with the thermal properties of
the building and with the range that the temperature needs to
change by, which, in turn may vary by the outside temperature. The
times can also be different for heating and cooling.
[0252] While the above pattern detection and matching processes
have been described with reference to time slices, the horizontal
dimension can be other metrics other than time. An example of
non-time based patterns is monitoring how a failure of vehicle
parts relate to the mileage of the vehicle. That is, if the failure
of various parts are mapped into the mileage across a large
population of vehicles, patterns will emerge. The emergence of new
patterns, occurring at lower mileages, may indicate deteriorating
quality of a part.
[0253] To accomplish balanced energy efficiency, a particular
embodiment of the system includes logic to understand how
comfortable the occupants of a building are, and how comfortable
they should be. The determination of how comfortable occupants
"should be" includes an element of corporate or institutional
policy that must be considered, and is accounted for in the system
algorithms as well. In particular, the system uses occupant
feedback to determine the comfort status of groups of occupants,
and uses that as a factor in governing the settings of building
subsystems to optimize group comfort, while balancing against
policy driven energy savings requirements.
[0254] By employing feedback, people are treated as fuzzy sensors
(e.g. "too hot", "too cold", "just right"). Feedback then is thus
data, from which the system can extract information, and treated as
complaints. Thus feedback is actively solicited, unlike complaints,
because more data is better.
[0255] FIG. 16 is an exemplary graph illustrating the trade-offs in
balancing energy saving with occupant comfort. As shown, increasing
comfort may decreases energy efficiency. A goal of the system is to
attempt to maximize productivity by balancing comfort with
efficiency, while recognizing that some increased energy costs may
be overcome by increased productivity.
[0256] In most buildings, efficient facilities management requires
striking a balance between reducing energy consumption and
optimizing occupant comfort. In environments such as businesses,
institutions and agencies, the comfort of an employee is an
important factor in their overall job satisfaction and has a direct
impact on their morale, productivity and employee retention.
Whereas reducing energy consumption means saving money, one cannot
lose sight of the costs associated with unhappy employees. The
costs associated with reduced productivity or low rates of
retention can be substantial, and have the potential to outweigh
energy savings gained at the expense of comfort. Therefore, finding
the perfect balance between reducing energy consumption and keeping
people comfortable is an important strategic goal of most
commercial entities.
[0257] A particular facilities management system includes the
ability to measure occupant comfort and apply the results to
facilities management. The system facilitates and encourages
occupant feedback by providing easy and entertaining feedback
interfaces on familiar devices such as smart phones and personal
commuters, and by responding to the occupant's feedback in a way
that makes the occupant understand the functioning of the system
and remain eager to participate. Encouraging full and active
occupant feedback participation allows for accurate statistical
analysis and reliable determination of group comfort.
[0258] Subsystems will have overlapping, but often different
control zones. For example, a room may be the entire control zone
for lighting control, but one of several rooms that are a single
HVAC control zone. When feedback is received, the location of the
feedback is mapped into all of the control zones that the location
is part of. Typically, but not necessarily, feedback for a given
subsystem is handled independently of feedback from other
subsystems. Feedback that an occupant finds that a space is too
brightly lit may affect the lighting or window shade settings, but
will not affect temperature handling.
[0259] Occupant feedback is implemented through a cycle of
collecting feedback for a given period of time, the measurement
period, then analyzing the feedback to identify differences between
group comfort and current subsystem settings adjustments, and
finally making adjustments to subsystem settings as appropriate.
The cycle repeats continuously as feedback is received.
[0260] FIG. 17 is a flow diagram illustrating the processing of
feedback for a control zone within a subsystem. The process 3100
can be viewed as a Collection-Analysis-Adjustment cycle.
[0261] The collection phase addresses collecting feedback received
from feedback devices at step 3110 for a fixed time period. The
measurement period length for each collection phase is determined
on a customer-by-customer basis to account for: [0262] the cycles
of space occupancy and use; [0263] the desired frequency of
feedback-based adjustments; and [0264] the quantity of feedback
collected during each collection phase.
[0265] It should be noted that too short of a measurement period
may result in undesirable fluctuations in settings based on too few
instances of feedback. However, too long of a measurement period
may result in undesirable delays between feedback and noticeable
changes in subsystem settings or feedback response. System reports
can assist the customer in selecting the most appropriate
measurement period. The default setting for a new customer is
typically 24 hours.
[0266] Feedback for a measurement period is stored in a database
3115, including the following information: [0267] Required data:
[0268] Date and time of feedback [0269] Subsystem related to the
feedback: [0270] Temperature [0271] Light [0272] Glare [0273]
Humidity [0274] Noise [0275] Feedback value (a value representing
the feedback) [0276] The control zone from which the feedback was
taken [0277] Associated subsystem settings at the time the feedback
was provided, such as: [0278] Thermostat set-points and dead band
[0279] Lighting status: [0280] On [0281] Off [0282] Percentage
dimmed [0283] Window shade position status [0284]
Humidifier/dehumidifier status [0285] Ventilation fan status [0286]
Optional data: [0287] Identity of the occupant providing the
feedback [0288] Sensor data for the area of feedback, if available,
such as: [0289] Temperature [0290] Light level [0291] Humidity
level [0292] Noise level
[0293] The user interface typically supports simultaneous feedback
on multiple subsystems. Each instance of feedback will create a
separate record in the database relating to the associated
subsystem.
[0294] For the analysis phase, feedback is parsed for analysis
according to associated subsystems and control zones. Feedback for
each subsystem is analyzed independently of the feedback for other
subsystems. Within each subsystem, feedback for each control zone
is analyzed independently of other control zones.
[0295] Feedback is pre-processed from individual occupants at step
3120. The treatment of multiple instances of feedback from
individual occupants is defined by the customer's policy settings
3160. Settings may be collective, applying to all occupants, or
individual, applicable to specific occupants. The purpose is to
ensure that occupant feedback is treated "fairly", as determined by
the customer, and to eliminate intentional manipulation of the
system.
[0296] Multiple instances of feedback from a single individual for
a specific subsystem and control zone during a single measurement
period can be handled in several ways: [0297] give each feedback
instance the same weight as a single feedback instance normally
would have; [0298] take the average of all instances of feedback
and use this value as a single feedback instance; [0299] take the
median value of all instances of feedback and use the value of this
as a single feedback instance; or [0300] take the feedback value
most frequently given during the feedback period and use it as a
single feedback instance.
[0301] It is recognized that the pre-processing of feedback may
raise alerts 3140 to the customer. For example: [0302] If an
occupant supplies inconsistent feedback, such as registering both
too cool and too warm during a measurement period, this may raise
an alert, and the customer may choose to take action at step 3150,
such as: [0303] asking the occupant about the circumstances that
gave rise to the feedback; or [0304] defining a policy for the
specific occupant.
[0305] The feedback from specific occupants for specific subsystems
and control zones can be given different levels of weight as
defined by customer policy. For example, the customer may decide
that feedback from residents is given more weight than feedback
from non-residents, or that professors are accorded a higher
weighting than students. Such weighting can be included in the
calculation of adjustment factors for a given subsystem or control
zone.
[0306] After the feedback from individual occupants has been
processed, then all feedback is analyzed statistically at the group
level at step 3130 for: [0307] Distribution [0308] Average [0309]
Median [0310] Standard deviation [0311] After elimination of a
group of percentile outliers (typically 90th percentile): [0312]
Average [0313] Median [0314] Standard deviation [0315] Trends
[0316] Relative to sensor data [0317] Relative to subsystem
settings
[0318] The statistical analysis may also raise alerts 3140 to the
customer that indicate that facility systems are faulty or out of
calibration, such as: [0319] Feedback about being too cold in spite
of high thermostat settings may indicate: [0320] Open windows
[0321] Faulty thermostat calibration [0322] Clogged filters [0323]
Feedback about being too noisy may indicate: [0324] Faulty HVAC air
handlers [0325] Doors left open, which should be closed
[0326] Specific occupants consistently providing feedback that is
divergent from the majority of occupants may indicate: [0327] The
occupant may need to be provided with things that improve their
comfort, such as: [0328] Space heaters [0329] Personal fans [0330]
Sweaters [0331] The occupant may need to be relocated to spaces
where the settings would make them more comfortable, such as:
[0332] Less glare [0333] Higher or lower temperatures [0334] Less
noise
[0335] The following feedback data received from a group of
individuals is an illustrative example:
TABLE-US-00001 Comfort Value Count Extremely cold -4 1 Very cold -3
1 Cold -2 2 Cool -1 10 Comfortable 0 20 Warm 1 15 Hot 2 4 Very hot
3 1 Extremely hot 4 0
In this example the average feedback value is 0.56 ("comfortable"
with a small "warm" bias), and the median feedback is
"comfortable".
[0336] If the 10% outliers are removed, the data becomes:
TABLE-US-00002 Comfort Value Count Extremely cold -4 0 Very cold -3
0 Cold -2 0 Cool -1 10 Comfortable 0 20 Warm 1 15 Hot 2 4 Very hot
3 0 Extremely hot 4 0
Now the average feedback value is 1.44 ("warm"), and the median
feedback is "warm".
[0337] With the outliers removed, there is a significant bias
towards "warm" in the feedback. Depending on the customer's policy
settings, the season, the weather, or the influence of solar
heating, etc., this might warrant dropping the thermostat's high
set-point in summer, causing more energy consumption for air
conditioning, or dropping the thermostat low set-point during the
heating season, leading to a reduction in energy consumption for
heating.
[0338] In addition, occupant-level statistical analysis is also
performed at step 3130 for: [0339] Distribution [0340] Average
[0341] Median [0342] Standard deviation [0343] After elimination of
specific percentile outliers (typically ninetieth percentile)
[0344] Average [0345] Median [0346] Standard deviation [0347]
Trends [0348] Relative to sensor data [0349] Relative to subsystem
settings
[0350] The following aggregate feedback received from an individual
is another example:
TABLE-US-00003 Comfort Value Count Extremely cold -4 1 Very cold -3
2 Cold -2 4 Cool -1 10 Comfortable 0 20 Warm 1 6 Hot 2 2 Very hot 3
1 Extremely hot 4 0
[0351] From the data, the average feedback from this individual
Occupant is -1.66 ("cool") and the median value is "comfortable".
If we again remove 10% outliers, the average becomes -2 ("cold")
and the median remains "comfortable". Depending on the customer's
policy settings, an alert may be issued that this occupant
typically feels too cold.
[0352] For the adjustment phase 3170, the results of the
statistical analysis from step 3130 and customer policy settings
3160 are fed to rules that manage the settings for the controls
that adjust the subsystems and control zones just analyzed.
Examples of such rules are: [0353] If more than a specified
percentage of the processed feedback reports the control zone as
being uncomfortably hot, adjust the thermostat set-points a
predetermined number of degrees down. [0354] Customer policy may
limit this rule to specific levels of occupancy. For example: Do
not adjust set-points during periods of no or low occupancy. [0355]
Adjust outside shades to block more direct sunlight if the average
processed feedback is uncomfortable glare. [0356] Adjust outside
shades to admit more direct sunlight if no reported glare
discomfort, and if daylight harvesting allows the lowering of
electric lighting levels.
[0357] Note that the adjustments typically will create an optimum
balance between occupant comfort and energy consumption.
[0358] The system also includes a provision for policy override
because some amount of discomfort may be desirable from a business
perspective due to the potential energy savings. Thus policy
adjustment mechanisms are provided to over-ride optimization to
conform to such business policy.
[0359] An occupant feedback response 3190 is provided at all stages
of feedback processing. The types of response and when a response
should be provided to the occupant who provides the feedback are
driven by rules that take customer policy settings as input.
[0360] From the collection stage at step 3110, an immediate
response is provided to the occupant to show that each instance of
feedback has been received and will be processed. Responses may
also include incentives or historical information, such as: [0361]
a rating of the occupant that indicates how often he/she provides
feedback; [0362] adjustments that may have been made in response to
previous feedback from the occupant; and [0363] rewards for
particularly frequent or substantive participation.
[0364] From the analysis stage, all steps can result in responses
to specific occupants, to groups of occupants, or all occupants,
depending on specific conditions. As a result of pre-processing of
feedback at step 3120 from individual occupants, the occupants may
be provided a feedback response, such as: [0365] reassuring
occupants who have provided multiple instances of feedback that
their feedback will be processed, and to be patient; and [0366]
informing occupants who appear to be attempting to manipulate the
system that there are other ways to address their discomfort. As a
result of the group and occupant statistical analysis at step 3130,
a feedback response may be generated both to individual occupants
and to groups, such as: [0367] The occupants may be provided
feedback responses that indicate group comfort levels combined with
energy consumption data. [0368] Individual occupants may be given
feedback responses that they are feeling discomfort when others are
comfortable, suggesting available remedial measures that the
occupant may take him/herself, or a response may be forwarded to a
manager for action. [0369] Remedial measures that the occupant may
be able to take himself or herself: [0370] Wearing warmer or cooler
clothing. [0371] Closing manual shades. [0372] Potential management
action: [0373] Issuance of equipment that may make the occupant
more comfortable. [0374] Relocating the occupant to a workspace
that would be more comfortable.
[0375] From the adjustments stage at step 3170, energy management
setting adjustments can generate occupant feedback responses, such
as informing all affected occupants of adjustments that have been
made in response to occupant feedback, with information about the
impact of the adjustment on comfort levels and energy
consumption.
[0376] FIG. 18 is an exemplary user interface for feedback devices.
As shown, the feedback interface 3500 is a window that includes a
voting frame 3510, a energy tracking frame 3520, and a results
frame 3530. In the voting frame, the user is shown a scale with the
current temperature 3512 and the user can vote on the perceived
comfort level with the current temperature using a slider 3514 and
can add comments 3516. By way of feedback, the user can also view
results from others in the zone or other locations, such as the
temperature that others would like it to be 3532 and the voting
outcomes for today 3534. The user can also track the building's
energy usage by a displayed temperature gauge 3522 ranging from low
to high. Additional encouragement to vote can be provided by
offering coupons or further applying gaming theory. By providing
such feedback, it is hoped that employees will be willing to
sacrifice some comfort for energy efficiency.
[0377] Returning to FIG. 1, each LEO 20-1, 20-2 and the central
server 80 include a respective rules engine 22-1, 22-2, 82 for
processing data. While traditional programming could be used, the
rules engines create a programming environment that is extremely
close to a number of real-world situations. By using a rules
engine, the programmer can focus on the business problem and not
worry about traditional programming concepts such as program
flow.
[0378] A rules engine, in accordance with particular embodiments of
the invention, operates on a set of rules, specified as "when
<event> do <action>". The rules engines detect the
occurrence of events and automatically execute the matching actions
for rule-specified events that have occurred. If an action creates
the conditions specified by one or more events, or possibly the
same rule, they, in turn are executed until no more events are
detected. In the terminology of rules engines, a rule is triggered
when an event fires.
[0379] Ideally, the rules engine itself consumes few resources and
leaves most of the computer's resources to execution of the rule
actions. In practice, however, rules engines often consume large
amounts of resources in the process of detecting events and
triggering rules.
[0380] The most complex issues that contribute to rules engine
overhead are detection of events and chaining to rules, and state
management.
[0381] For the detection of events and chaining to rules, the more
general the rules engine, and the more complex logic is allowed in
the definition of events, the more difficult, and in turn, resource
consuming does the rules engine's logic for this process become. In
the terminology of artificial intelligence, a rules engine can be
forward chaining, in which cases it detects an event then examines
whether any rules exist that should be triggered by the event, or
backward chaining, in which case the rules engine constantly
watches the environment for conditions that satisfy the rule
triggering logic.
[0382] Management of state by the rules engine is important and
potentially very complex. As a result, most rules engines are
single-threaded--only one rule action can execute at a time.
Multithreading can be desirable if some events take a long time to
complete.
[0383] The order in which rule actions execute can also be
important, if some event triggers two rules, the final state can be
different depending on the order in which the rule actions execute.
If the order is predictable the rules engine is deterministic and
if it is not, the rules engine is non-deterministic.
[0384] An interesting case is the scenario where an event fires a
rule, but for some reason the conditions defining the event are not
true at the time the action executes. A real-world example is that
a rule can specify that a thermostat should be set at a comfortable
level when an office is occupied, and another rule states that
different thermostat settings should be employed when the office is
unoccupied. If the office becomes occupied and triggers the first
rule, but the event is not executed until the office becomes
unoccupied, then the thermostat is adjusted unnecessarily. The
second rule will fire when the office becomes unoccupied and if the
rule actions execute in the order in which the rules were fired,
the thermostat will be set correctly after the second rule performs
its action.
[0385] The rules engines are frequently triggered by periodic
events. As such, the system uses rules to maintain time data in a
heartbeat table (not shown) and to process actions in response to
changes in the time fields.
[0386] In accordance with a particular embodiment of the invention,
a rules engine addresses the issues described above by leveraging
ACID relational database technology 24, 84 (FIG. 1) in the creation
of rules engines. Specifically: [0387] Limiting the logic of the
rule-triggering to "changes in the data contained in one or more
relational databases", which enables the rules to be very efficient
in forward chaining by employing database triggers to alert the
rules engine when rule-triggering modifications have been made.
[0388] Storing all of the state-critical data in one or more
relational databases and using the database engine to maintain
consistent state and ACID compliance.
[0389] In a particular embodiment of the invention, the ACID
database is provided by MySQL, version 5.2, paired with the InnoDB
storage engine. The integration of ACID-compliant database
technology has enabled a number of other significant features and
benefits. To maximize leverage of database technology and to make
the rules engine as useful as possible in a real-world application
setting, the particular rules engine has the following features:
[0390] 1. Events are limited to changes in value to any of a number
of relational database columns. A single event can specify columns
in several tables and multiple columns in a single table. Insertion
of new rows and deletion of rows are considered changes in value.
[0391] 2. A rule event is tied to a triggering action happening to
a specific row in a table. If triggering events happen to multiple
rows in a table, they generate separate calls to the rule action.
The rule action knows the specific table, row and column that
triggered it. [0392] 3. Rule actions must assume that the state of
the system may have changed between the event and the time the
action is performed, including changes to database columns that
trigger the event. [0393] 4. If multiple event-triggering columns
for the same rule are changed simultaneously they will cause
multiple executions of the rule event. One for each column that had
its value changed. [0394] 5. All actions are transactional and
ACID: [0395] Rule actions are Atomic, meaning that they either
complete, or all changes to the database are rolled back if the
actions fail, for any reason. [0396] The data in the database is
Consistent, meaning that all actions see a consistent state. [0397]
All actions are Isolated, meaning that if an action modifies
database data used by some other action, the second action will be
suspended until the first action completed. [0398] All actions are
Durable, meaning that changes to the database performed by an
action are guaranteed to survive any failure. [0399] 6. Rule
triggering and rule action execution is asynchronous: [0400] Rule
trigger detection and rule action execution run independently of
one another, the former feeding a queue and the latter consuming
it. [0401] Events are not triggered by a rule until it completes
and commits. [0402] 7. All rules have an assigned priority: [0403]
If single-threaded rule execution is chosen, rule action execution
order is strictly by increasing priority and increasing triggering
timestamp. [0404] If multi-thread rule execution is chosen, each
thread chooses rules to execute in the order of increasing priority
and increasing triggering timestamp, but since a thread can be
limited to a range of priorities and the nature of multi-threading,
overall rule action execution is not guaranteed to be in increasing
priority and increasing triggering timestamp order.
[0405] The particular rules engine applies the capabilities of
modern ACID-compliant relational databases to the domain of rules
engines in a unique and innovative manner to implement a rules
engine with a number of unique and desirable features: [0406] 1.
Triggering a rule in response to changes to specific columns in any
row of specific tables. [0407] 2. Scaling of rules to work
efficiently on massive amounts of data by allowing one rule to
operate on all rows of database tables containing potentially
massive amounts of data. In effect, the rules engine will scale as
efficiently as the database engine it leverages. [0408] 3. Multiple
instances of the same rule, triggered by different rows or columns,
can execute in parallel. [0409] 4. Multi-threaded triggering and
execution of rules. [0410] 5. Asynchronous triggering and execution
of rules. [0411] 6. Rule triggers and rule actions triggered can be
guaranteed against loss by any failure short of a catastrophic
event. [0412] 7. ACID compliance: [0413] a. Atomicity of rule
execution; [0414] b. Consistency of overall system state; [0415] c.
Isolation of one executing rule from other executing rules; and
[0416] d. Durability of rule execution. [0417] 8. Failing rules are
retained and can be restarted after the cause of the failure has
been corrected. [0418] 9. The balance of throughput and
responsiveness of rules can be managed by assigning priorities and
having multiple execution threads assigned to subsets of
priorities.
[0419] FIG. 19 is a block diagram of a rule definition in
accordance with particular embodiments of the invention. As shown,
a rule 4000 is defined by specifying three items: [0420] 1. the
event definition 4010, which is the data that will trigger the
rule; [0421] 2. the action 4020 the rule should perform when
triggered; and [0422] 3. the priority of the rule 4030.
[0423] Triggering data is data that, if changed by database
inserts, deletes or updates, will trigger rules. The definition
includes a list of table and column pairs. The list of tables can
include multiple tables 4081, 4082, . . . , 4089 and multiple
columns 4081-A, 4081-B, 4082-C, . . . , 4089-D with no restriction
other than all the tables must be under the control of a single
transaction manager. Pointers 4015 are used to access the table
columns.
[0424] The action to be performed when triggered is
machine-executable code that must be run after the rule is
triggered.
[0425] Rules are created by adding entries to a rule definition
table that contains the identity of the rule, the trigger
definition, the action code and the rule priority. Depending on the
implementation, any or all of these fields can be pointers to data
external to the database or contained in data or code external to
the database.
[0426] FIG. 20 is a flowchart of a particular rules engine in
accordance with particular embodiments of the invention. The rules
engine 4100 is responsive to database modifications. As shown, a
process P running outside the scope of the rules engine 4100 makes
a change to data in the ACID database 4080. At step 4110, the
database engine triggers an event for a table specified in the rule
events 4010 (FIG. 19) and an entry is placed in an event queue
4120. At step 4130, the event queue entries are translated into
rule execution queue entries and placed in a rule execution queue
4140.
[0427] The entries on the rule execution queue 4140 are processed
by processes 4020-1, 4020-2, . . . , 4020-R executing the specified
rule action 4020 (FIG. 19). As shown, the processes can run in
parallel. The power of the rules engine can be appreciated by the
fact that the rule actions can result in modification to the
database, which can also trigger further rules.
[0428] FIG. 21 is a flowchart of rule triggering logic of FIG. 20.
Rule triggering 4110 is performed by database triggers attached to
the tables that are defined in rule trigger definitions. The
database triggers are executed on insert, delete and updates to the
tables 1081 by any process P. At step 4112, the triggers examine
the before and after contents of all columns named in trigger
definitions. If there is no change, then no action is taken at step
4114. But for each column in which the data has changed, the
trigger will add an entry at step 4116 to an event queue table
4120, which includes the table name, the column name, the action
that caused the change (insert, delete or update), and the primary
key values of the database row containing the change.
[0429] One advantage of using database triggers is that the process
making the change to the data is unaware of the triggering, and
that the trigger will capture any modification to the data, no
matter how it is made. Finally, the triggering code is run in the
context of the transaction of the modifying query and follows the
ACID compliant rules. Specifically, if the modifying code fails and
the transaction is rolled back, the entry into the event queue will
also be rolled back and removed.
[0430] FIG. 22 is a flowchart for translation of event queue
entries into rule execution queue entries from FIG. 20. The event
queue table data 4120 is consumed by a process at step 4131 that
reads entries from the queue 4120 and compares the contents of the
entry with the event definitions of all rules 4010. At step 4132,
for each rule for which the event definition includes the table and
column in the queue entry the process performs the following:
[0431] At step 4133, a rule execution queue entry is created that
includes a rule identifier, the table name, the column name, the
primary key values, and the action from the event queue entry.
[0432] At step 4134, the process examines the contents of a rule
execution queue table. A row in the rule execution queue table
includes the identity of a rule, the name of the triggering table,
the name of the triggering column, the primary key values of the
row that triggered the rule, the action that caused the trigger
(insert, delete, or update), the state of the entry, the priority
of the rule, and the date and time the row was placed in the queue.
[0433] At step 4135, if no entry was found in the rule execution
queue that matches the rule identifier, the table name, the column
name, the primary key values, and the action from the event queue
entry, a new rule execution queue entry is added at step 4136 that
includes the identity of the rule, the data from the event queue
table, the rule priority and current date and time. [0434] If an
entry was found at step 4135, then processing continues to step
4137 where the entry's state is examined and depending on its
value, one of the following actions is taken: [0435] If the state
is waiting to be run no action is taken. [0436] If the state is
failed, no action is taken. [0437] If the state is running, the
state is modified to running and waiting to be re-queued. [0438] If
the state is running and waiting to be re-queued no action is
taken.
[0439] At step 4138, if there are more rules that match the event
queue entry, then processing returns to step 4133 to process the
next rule. Upon completion of these actions the entry in the event
queue table is deleted at step 4138 and processing returns to step
4131 to process the next event queue entry. Each event queue entry
is handled in a transaction, ensuring that it either completes, and
is deleted, or rolled back, and stays in the queue.
[0440] FIG. 23 is a flowchart of rule execution logic of FIG. 20.
As noted above, execution of rules 4020 can be done in parallel by
multiple processes, and can be distributed where execution
processes run on multiple servers. Each rule execution process
works from the rule execution queue 4140 (FIG. 20) by the rule
execution process continually executing the following logic: [0441]
Depending on how it is set up, a rule execution process can be
configured for a subset of possible priorities. In a single
transaction, the highest priority, oldest (defined by the
submission date and time) rule execution queue entry that matches
the priority configuration of the process, and has a state of
waiting to be run is selected at step 4021. At step 4022, its state
is changed to running, and the transaction is committed. The code
of the rule is then called at step 4023, passing the data from the
queue entry as parameters. [0442] If the code returns without
failure at step 4024, the queue entry is retrieved again (it may
have been modified in the meantime), and its state is examined and
the following actions taken based on the state: [0443] If the state
is running at step 4026, the queue entry is removed at step 4027.
[0444] If the state is running and waiting to be re-queued at step
2046, the state is modified to waiting to run at step 4028. [0445]
If the rule code returns a failure at step 4024, the current
transaction is committed, a new transaction is started and the
queue entry state is modified to failed at step 4029. [0446] The
current transaction is then committed to the database.
[0447] In addition to the above, database event triggers can be
automatically created. By examining the totality of rules the
aggregate set of rule-triggering table/column pairs can be
ascertained. By maintaining a strict naming convention for the
rules engine-generated database triggers the rules engine can
automate the management of them. When a rule is created, deleted or
modified, the rules engine will generate the source code for the
required database triggers. If the database engine provides a
facility for examining the source of installed triggers, the engine
can compare those required with those installed and delete those no
longer required, create new ones required and modify those where
the generated source is different from the installed.
[0448] Furthermore, rules in a running rules engine can be updated
with no disruption by updating the system as follows: [0449] Stop
processing of the event queue. [0450] Wait until the rule execution
queue contains no entries for rules that will be deleted or
modified. [0451] Update the database triggers to conform with the
new configuration. [0452] Update the rule definition table. [0453]
Resume processing of the event queue.
[0454] Performance of the rules engine can be increased by caching
read-only data. In particular, when there is a high probability
that the same data will be executed multiple times in a single
process, the performance of the second and subsequent executions
can be increased by passing each instance of the rule a pointer to
an in-memory data structure that will be passed to all instances
running in that process. The first instance may determine that the
data structure does not contain the read-only data and read it from
the database or some other data source. Subsequent instances may
examine the data structure and determine that it contains the
read-only data and use the in-memory contents.
[0455] The same data structure can be used for instance-to-instance
communication within a single process that does not need to be
managed transactionally.
[0456] Finally, a failed rule instance (where the rule execution
queue state is failed) can be restarted by changing the state to
waiting to be run after the condition causing the failure has been
corrected. The failure correction can include updating the rule
logic as described above.
[0457] It may be desirable to run the failed rule without changing
its initial state for diagnostic purposes, or to validate that the
error-causing condition has been corrected. This can be done by
running a process (possibly under debugger control) that selects
the failed rule from the rule execution queue, but otherwise
follows the same logic as described.
[0458] If a rule action performs aggregate functions, such as
operating across multiple rows, it can be undesirable to have rule
instances for each modified row. For example, if a rule calculates
the sum of the values of a column across an entire table, the rules
engine can place multiple instances of the rule in the rule
execution queue, all waiting to be executed. When the first
instance executes, the sum will be calculated, and subsequent
instances will calculate the same sum and, in effect, do no useful
work.
[0459] To eliminate that wasted resource use, the particular rules
engine allows the rule so specify a piece of code to be executed as
the event queue entry is translated to a rule execution queue
entry. This code is granted modification access to the rule
execution queue entry before the queue is scanned for the same
entry. By modifying the entry it can manipulate which existing
queue entries it will match. For example, in the previous example,
if the field containing the primary key values is modified to a
constant value, triggering from different rows will create the same
rule execution queue entry and only one instance will exist in the
queue at any time.
[0460] FIG. 24 is a flowchart of a process for translation of event
queue entries into rule execution queue entries from FIG. 22 to
include queue entry modification. As shown, the modified
translation process 4130' includes the same steps as the
translation process 4130 of FIG. 22 except that after step 4133, a
call is made at step 4133' to modification code for the rule. In
that case, the process continues to step 4134 by using the returned
queue entry.
[0461] FIG. 25 is a block diagram of rule definition components of
FIG. 19 modified to support execution queue entry modification of
FIG. 24. The modified rule 4000' includes the event definitions
4010, actions 4020, and priority 4030 components of FIG. 19. As
shown, the modified rule 4000' includes execution queue
modification logic 4040'.
[0462] The ability to manipulate the rule execution queue entry is
extremely powerful and useful in a number of other instances.
[0463] Finally, the ability to schedule rule actions other than
through the previously described database triggers extends the
scope of events beyond the modification of database table values.
In effect, it allows any piece of software, including rule actions,
to raise events and trigger rule execution.
[0464] The particular rules engine provides three mechanisms to
programmatically trigger rules: [0465] 1. An Application
Programming Interface (API) call that adds an event queue entry.
[0466] 2. An API call to the event queue to rule execution queue
logic with arguments matching the contents of an event queue entry.
[0467] 3. An API call to the rule execution queue insertion logic
with arguments matching the contents of a rule execution queue
entry.
[0468] These API entries provide a completely generalized interface
for code that programmatically raise events and schedule rule
execution.
[0469] It is anticipated that the described technologies can be
applied to areas beyond facilities management and energy
conservation, and that those of ordinary skill in the art will
recognize many other application. Some other applications include,
but are not limited to: [0470] Market predictions (stock markets
are only one market; we could just as easily predict retail,
commodities, political forecasts, etc.) [0471] Energy rate
"surfing" that allows the customer to direct energy consumption
based on predicted energy-pricing market behaviors. [0472] Energy
grid management [0473] Retail spot-advertising (to appear on
screens in shopping malls when we predict >X numbers of people
of Y demographic will be in Z area. The demographic data can be
obtained by: [0474] Discern the data based on circumstances, such
as a movie getting out, time of day, calendar, activities at nearby
demographic-specific stores, etc., which form patterns over time.
[0475] Determine the data by associative behavior, such as the
reaction to specific adverts in the past or present. [0476] The
people provide the data by registering (social awards, gaming
theory, and other incentives) [0477] The people provide the data by
logging in through Google or Facebook. [0478] The people provide
the data by reacting to the advert, such as by: [0479] Logging in
to a web site or camera-shooting the geo-location code in the
advert for a coupon. [0480] Shooting the ad as a coupon and walking
into a store looking for a discount, where their demographic is
recorded for later correlation. [0481] Pattern recognition cameras
(often used in security systems). [0482] Spotters observe the
demographics and record for correlation. [0483] Medium or
long-range budget forecasting for anything related to human
patterns or space planning, such as energy budgets, technology
budgets, etc. [0484] Any prediction of a macro environment from a
micro environment.
[0485] Those of ordinary skill in the art should recognize that
methods involved in the automated facilities management system may
be embodied in a computer program product that includes a
computer-usable medium. For example, such a computer-usable medium
can include a readable memory device, such as a solid state memory
device, a hard drive device, a CD-ROM, a DVD-ROM, or a computer
diskette, having computer-readable program code segments stored
thereon. The computer-useable medium can also include a
communications or transmission medium, such as a bus or a
communications link, whether optical, wired, or wireless, having
program code segments carried thereon as digital or analog data
signals.
[0486] While this invention has been particularly shown and
described with references to particular embodiments, it will be
understood by those skilled in the art that various changes in form
and details may be made to the embodiments without departing from
the scope of the invention encompassed by the appended claims.
* * * * *