WO2007133605A2

WO2007133605A2 - Electrical data related to a power monitoring system

Info

Publication number: WO2007133605A2
Application number: PCT/US2007/011247
Authority: WO
Inventors: Theresa Wall; Rekha Kaushik; Loretta Stokes; Andy Mark Mcinturff; Warren Patterson; Arvind Wadhawan; John J. Dodson
Original assignee: Square D Company
Priority date: 2006-05-11
Filing date: 2007-05-09
Publication date: 2007-11-22
Also published as: WO2007133605A3

Abstract

A method of partitioning and archiving electrical data received from a power monitoring system in a database including a plurality of tables organized by at least group and date. Data in the database is queried by first searching an electrical data catalog to determine whether the data exists in the database before searching the database. The data is targeted by group and by date, yielding faster response times and enhanced database scalability. An electrical data retention table includes a set of rules governing, for each group, the maximum age of the data that can be stored in the table in the database. A data table associated with a particular group whose age exceeds the maximum age provided in the set of rules is removed from the database and from the electrical data catalog. If desired, the entire data table can be imported back into the database.

Description

ELECTRICAL DATA RELATED TO A POWER MONITORING SYSTEM

FIELD OF THE INVENTION

[0001] This invention is directed generally to a power monitoring system and, in particular, to one or more of partitioning data within a database, to auto-discovery of configuration/identification information, to loading a chain of processors from an extensible markup language file and modifying a load sequence without having to hard code the modification, and to a globalization component for facilitating the translation of software applications into multiple human languages.

BACKGROUND OF THE INVENTION

PARTITIONING ELECTRICAL DATA WITHIN A DATABASE

[0002] Microprocessor-based electrical power equipment such as power monitors, lighting control systems, meters, circuit breaker controllers and the like accumulate considerable amounts of information concerning the electrical distribution systems to which they are connected, as well as the power equipment itself. The amount of such information generally increases over the operating life of the equipment, not only because of the retention of required historical information but also because of the increasingly complex functions being performed by such equipment.

[0003] The information from the power monitoring systems and the like can be stored in a database. By querying the database, certain categories of data can be requested from the database, which is interpreted or manipulated to produce useful reports or other informational tools for identifying patterns, problems, or other anomalies in a particular set of data. As the amount of data increases, the database response times increase because there is more data that must be searched to ensure a complete result. Much of that data may be irrelevant or not important for the particular query. For example, historical data older than three months may not be relevant to a query for data representing the currents and voltages at a particular metering point. Yet, the presence of such "stale" or aging historical data poses an i impediment to the database search engine, rendering it sluggish and slower to respond.

[0004] Slow database response times results in various disadvantages. Operators querying for data could lose patience with the lengthy response time and slow performance associated with data requests, and, .as a result may actually be discouraged from running such queries in a manner that adversely affects operations and productivity. In addition, as databases become filled with data that may be disjointed, disorganized, and enormous in size, more sophisticated processes are required in order to extract and analyze the data. The process of searching large amounts of data for patterns is typically referred to as data mining. There exists sophisticated commercial tools for data mining, such as OLAP (on line analytical processing) tools, but while these tools can enhance database performance, they are expensive, complex, and bug-susceptible, which increases overall complexity of designing, maintaining, and interacting with the database system.

[0005] Performance is also adversely affected with respect to archiving data. Over time, performance begins to decrease as the bulk of data stored in a database table increases. To archive old data, it must be retrieved, saved to an external file, and removed from the database table. After the archived data is removed, the database server must reorganize the remaining data, which also results in performance decrease.

TRANSFER OF ELECTRICAL DATA WITH AUTO-DISCOVERY OF SYSTEM CONFIGURATION

[0006] In a power monitoring system, various installations send electrical data from data collection nodes to a data collection server that is administered according to a known system configuration. However, the system configuration can change over time as new devices are added or existing devices are removed from the system or as the setup of devices are changed in the system, requiring constant server administration. For each new device added or existing device removed, the system configuration must be manually updated at the data collection server to reflect the change. The data collection nodes typically include microprocessor-based electrical power equipment, such as power monitors, lighting control systems, meters, circuit breaker controllers and the like, which accumulate considerable amounts of data concerning the electrical distribution systems to which they are connected, as well as the power equipment itself. Each device has a particular configuration that must be known by the server so that it can receive meaningful data from the device. Because the process is manual, it is prone to human error and time-consuming.

LOADING A CHAIN OF PROCESSORS FROM AN XML FILE

[0007] The collected electrical data may be processed (e.g., filtered, aggregated, etc.) or extracted from a database by an application program. The application program typically utilizes a number of assemblies (e.g., dynamically linked libraries (DLL)) to process the data. These assemblies are dynamically linked with the application program that uses them during program execution rather than being compiled with the main program. The advantage of such assemblies is that, because they need not be loaded into random access memory (RAM) together with the application program, space is saved in the RAM. When and if an assembly is needed, it is loaded into the RAM and run by the application program.

[0008] Typical application programs hard code the load sequence for the various assemblies into the application program itself. As such, when the load sequence for the assemblies is to be modified (e.g., the order of the assemblies is changed or an assembly is added or deleted) a programmer must modify the source code and recompile the application program to carry out such a modification.

GLOBALIZATION COMPONENT

[0009] Many software programs are written with a view toward translating them into multiple human languages for multi-cultural distribution (a process known as globalization). One software development platform used for such purpose is the .NET Framework by Microsoft® that provides a large standard library from which software developers can develop assemblies, which are basically code libraries. In the Microsoft® Windows® environment, an assembly takes the form of a process assembly (EXE) or a library assembly (DLL). The code in an assembly is partially compiled into a Common Intermediate Language (CIL), which is then fully compiled into machine language at runtime by a Common Language Runtime (CLR) virtual machine (VM). The standard .NET framework libraries include, among other things, standard classes, a resource manager, and forms.

[00010] A challenge for software developers developing software destined for multiple countries is that all the resources (typically text strings) must be extracted from the .NET assembly (or other assembly, such as an Internet-based assembly) so that the strings can be translated into other languages. The .NET Framework includes a standard ResourceManager class that will extract resources from embedded resource files or from satellite assemblies. But a disadvantage to embedded resources is that they are "embedded" into the assembly, which must be compiled with all necessary culture-specific resource files for each target language. In short, each translation requires that the code be recompiled. Corrections to existing resources (such as a typographical error in a string) also undesirably require that the code be recompiled, a time-consuming and error-prone process. [00011] Another undesirable solution is to use satellite assemblies, each compiled for a specific culture. However, changes to resources of a satellite assembly or the development of a new satellite assembly for a new culture would require that the code be recompiled and that one or more configuration files be shipped with the new or modified files. This is necessitated by the fact that recompiling any .NET assembly often introduces incompatibilities between other related assemblies that were not recompiled. Introducing configuration files allows the developer to eliminate any specific incompatibilities that arise; however, producing and deploying these configuration files is a complicated process and creates additional work for the developers. Additionally, for every control in every form in an assembly, the software developer must include additional code that detects the culture and extracts resources from the pre-programmed file locations. This process is very tedious, prone to error, and significantly increases code size.

[00012] Thus, a need exists for an improved apparatus and method. The present invention is directed to satisfying one or more of these needs and solving other problems.

SUMMARY OF THE INVENTION

[00013] A method of partitioning and archiving electrical data received from a power monitoring system in a database including a plurality of tables organized by at least group and date. Data in the database is queried by first searching an electrical data catalog to determine whether the data exists in the database before searching the database. The data is targeted by group and by date, yielding faster response times and enhanced database scalability. An electrical data retention table includes a set of rules governing, for each group, the maximum age of the data that can be stored in the table in the database. A data table associated with a particular group whose age exceeds the maximum age provided in the set of rules is removed from the database and from the electrical data catalog. If desired, the entire data table can be imported back into the database.

[00014] In an embodiment of the present invention, a method of partitioning electrical data in a database includes receiving data from a monitoring system that monitors measurable quantities of a utility, the data including time data representing at least the date the monitored data was acquired; creating a plurality of tables in the database, each table being associated with a group and a date that are distinct from every other table in the database; and storing a value of the monitored data in one of the plurality of tables based on at least the group to which the value belongs and the date the value was acquired. In various embodiments, the method may farther include querying the database for first monitored data belonging to a first group and acquired on a first date; determining whether the first monitored data is present in the database by searching a data catalog stored in the database, the data catalog being logically distinct from the plurality of tables; and responsive to the determining, if the data catalog indicates the presence of the first monitored data, retrieving the first monitored data from the table associated with the first group and the first date. The method may still further include, responsive to the determining, if the data catalog does not indicate the presence of the first monitored data, searching an archive database for the first monitored data based on its associated first group and first date.

[00015] In various embodiments, the method may further include storing a set of data retention rules in the database, the rules indicating, for each group with which the tables are associated, a retention date range during which monitored data is stored in the database; and based on the data retention rules, archiving monitored data to an archive database when a date associated with the monitored data to be archived falls outside of the retention date range associated with the group to which the monitored data to be archived belongs. If the value of the monitored data does not belong to any group in the database, the method may write the monitored data received to a table of rejected data.

[00016] In some embodiments, a computer readable storage medium encoded with instructions for directing a controller to perform any of the methods herein. The utility may be selected from the group consisting of water, air, gas, energy, steam, and weather. The monitoring system is preferably a power monitoring system, the utility is preferably energy, and the monitored data is electrical data. The at least one group may, in various embodiments, be a group that includes topics that relate to electrical energy, electrical current, power quality, or electrical demand, to name a few. In the electrical energy group, the topics may include real energy, reactive energy, and apparent energy. In the electrical current group, the topics may include current, average current, and maximum current. In the power quality group, the topics may include total harmonic distortion (THD) current, THD voltage, harmonic factor, distortion power factor, total demand distortion, crest factor, and K- factor. In the electrical demand group, the topics may include demand current, K-factor demand, peak demand current, coincident demand, demand power, peak demand power, KW demand, KVAR demand, and KVA demand.

[00017] In another embodiment of the present invention, a method of archiving electrical data includes creating in a database a plurality of tables, each table being associated with a distinct group and a distinct date relative to all other tables in the database; storing electrical data that includes data corresponding to a group and a date in the corresponding one table associated with that corresponding group and that corresponding date, the electrical data being received from a power monitoring system; providing a set of rules for retaining data in the database, the set of rules indicating on a per group basis the maximum age of data that can be stored in each group; and removing from the database a first table whose data corresponds to a date that exceeds the corresponding maximum age for the group to which the first table belongs as provided in the set of rules.

[00018] The method may further include archiving the first table in a data archive, and the archiving may be carried out remote from the database. The set of rules may be stored in an electrical data retention table in the database. In some embodiments, the method may further include storing the first table in an archive database; providing an electrical data catalog in the database that includes at least a plurality of entries identifying the tables and their corresponding groups and dates; and responsive to removing from the database the first table, removing from the electrical data catalog the entry corresponding to the first table. In other embodiments, the method may further include importing from the archive database the first table into the database; and writing into the electrical data catalog an entry corresponding to the first table.

[00019] Automatic discovery of configuration or identification information published by a local computer (publisher) is connected to electrical monitoring devices in a power monitoring system and to a server that determines whether to approve data packets sent by the publisher. The publisher attempts to send a data packet including identification information to the server, which throws an exception with error code(s) indicating which information is missing in order for the server to approve the pending data transfer. The publisher interprets the error code(s) and sends back to the server the missing information, which may be identification information, configuration information, or both. This process of the server throwing an exception and the publisher attempting to send data packets or configuration information again may iterate more than once until the server approves the publisher, the device, and all topic information associated with the device and accepts the data for storage in the server database.

[00020] In another embodiment of the present invention, a method of auto-discovering information associated with devices arranged in a monitoring system (such as a power monitoring system) that monitors measurable quantities of a utility (such as water, air, gas, energy, steam, or weather) is provided. The method includes receiving configuration information from a local computer in the monitoring system at a server, the local computer attempting to send a data packet associated with a device to the server; determining from the configuration information whether the local computer is approved to have the data packet accepted by the server, the determining including comparing the configuration information against system configuration stored in the server; throwing from the server to the local computer an exception indicating that the configuration information includes information not recognized by the server; responsive to the determining, if the local computer is approved, determining whether the device is approved to have the data packet accepted by the server; and responsive to the determining, if the local computer is not approved, automatically approving the local computer by updating the system configuration with the configuration information. The exception may be selected from among a plurality of exception types, each exception type indicating that information which is required by the server to approve the device. The receiving may be optionally carried out behind a firewall imposed between the local computer and the server, the throwing including throwing from the server to the device the exception through the firewall.

[00021] The method may further include queuing the data packet in the local computer or the server until the data packet is accepted by the server. The data packet in some embodiments includes measured electrical data. In some embodiments, the local computer includes the server. In some embodiments, the configuration information includes local computer information, device information, and topic information.

[00022] In some embodiments, a first exception type indicates that the local computer information, the device information, or the topic information is not approved by the server. The topic information may be a topic that relates to an electrical characteristic.

[00023] In some embodiments, the data packets include identification information, and the method further includes determining from the identification information whether the device is approved to have the data packet accepted by the server; if the device is approved, accepting the data packet at the server and storing the data packet in a database of the server; and if the device is not approved, throwing an exception from the server to the local computer, the exception indicating which identification information is required by the server to accept the data packet, and automatically approving the device. This method may still further include queuing the data packet in a queue of the local computer; responsive to the device not being approved and automatically approving the device, receiving the data packet from the queue and storing the data packet in the database.

[00024] According to another embodiment of the present invention, a method of automatically approving the acceptance of data packets at a server in a power monitoring system includes receiving configuration information at a server from a computer, the computer attempting to publish a data packet associated with an electrical monitoring device in the power monitoring system, the data packet including data indicative of a measured electrical characteristic and identification information; throwing an exception from the server to the computer in response to the server not recognizing some or all of the configuration information; automatically approving at least some of the unrecognized configuration information; and sending the data packet until the server accepts the data packet.

[00025] The sending may include queuing the data packet in the local computer or the server until the server accepts the data packet. The exception may be selected from among a plurality of exception types, each exception type indicating a different type of configuration information that is required by the server. The configuration information may be information relating to the local computer and/or information relating to the device. The identification information may include information relating to at least the identity of the originator of the data packet, the computer, and the device.

[00026] According to another embodiment, method for loading a plurality of dynamically linked assemblies during the execution of an application program is disclosed. The application program reads a configuration file that includes a load sequence for the plurality of dynamically linked assemblies and a class associated with each dynamically linked assembly. The plurality of dynamically linked assemblies are loaded in accordance with the load sequence read from the configuration file. Each class has a common dataset and each of the plurality of dynamically linked assemblies is independent from the other of the plurality of dynamically linked assemblies. A process request defined by the associated class is sent to at least a first of the plurality of dynamically linked assemblies.

[00027] According to another embodiment of the present invention, a method for loading a plurality of dynamically linked assemblies during the execution of an application program is disclosed. The method comprising reading, by the application program, a configuration file that includes a load sequence for the plurality of dynamically linked assemblies and a class associated with each dynamically linked assembly. The method further comprising loading the plurality of dynamically linked assemblies in accordance with the load sequence read from the configuration file. Each class has a common dataset. Each of the plurality of dynamically linked assemblies is independent from the other of the plurality of dynamically linked assemblies. The method further comprising sending a process request defined by the associated class to at least a first of the plurality of dynamically linked assemblies.

[00028] According to another embodiment of the present invention, a method for manipulating data from a power-monitoring database with an application program is disclosed. The method comprising reading, by the application program, a configuration file to determine a process order for a plurality of dynamically linked libraries and to determine a respective class associated with each of the plurality of dynamically linked libraries. The method further comprising loading the plurality of dynamically linked libraries in accordance with the process order. Each class of the plurality of dynamically linked libraries has an associated common dataset. The method further comprising responsive to the loading, sending a process request to at least a first of the plurality of dynamically linked libraries in accordance with the process order to cause the first of the plurality of dynamically linked libraries to be executed.

[00029] According to another embodiment, a globalization component includes a base class NewResourceManager that provides a layer of abstraction from the Microsoft Resource Manager and a new WinForm class that inherits from the .NET Windows Form and utilizes NewResourceManager. The globalization component uses culture information and resource folder information from the registry to set a culture-specific resource folder and file. Decoupled assembly culture-specific resource files include all string resources in the target language and can be stored in any folder. New culture-specific resource files are easily generated without having to recompile the assembly or any satellite assemblies and without having to modify any configuration files. The NewWϊnForm class can also iterate through all controls on the form and if values are missing from an associated resource file, the resource manager will save the missing controls to a text file. Translators need only receive this text file to translate from one human language to another.

[00030] In another embodiment of the present invention, a method of decoupling resource files from an assembly includes providing an assembly that is executable by a computer, the assembly including forms having associated resources, the forms being defined by a form class, the resources being managed by a resource manager class. The method further includes defining a resource manager class that obtains culture information indicating a human language of an operating system running on the computer, reads resource folder information from a registry external to the assembly, the resource folder information indicating a location of at least one resource file, and searches the resource folder for a culture-specific resource file having a filename based on the culture information. A computer readable storage medium may be encoded with instructions for directing a controller to perform any method according to any embodiment herein.

[00031] The method may further include defining a form class that for at least some controls on a form, requests from the resource manager class a resource associated with each of the at least some controls, and if the resource manager class returns an indication that the control or the associated resource does not exist, adds the name of the missing control and the name of its associated form to a file. The method may further include determining, from the resource manager class, whether the requested control exists in the resource file. The computer may be coupled to a monitoring system that monitors measurable quantities of a utility. The utility may be selected from the group consisting of water, air, gas, energy, steam, and weather. The monitoring system may be a power monitoring system.

[00032] The method may further include creating a new resource file having text strings in a different human language from the text strings in the at least one resource file; and reading automatically from the assembly the new resource file without recompiling the assembly to read the new resource file.

[00033] In some embodiments, the assembly is developed in accordance with the .NET framework. In other embodiments, the assembly is developed in accordance with an Internet- based framework. The form class from which the forms in the assembly are derived may inherit from the standard form class provided by the .NET framework. The resource manager class may create an instance of the standard resource manager provided by the .NET framework. The file may be a text file, and the method may further include converting the text file to a resource file. The operating system may be a Windows-based operating system. The resource file(s) may be stored in a folder or folders different from the folder in which the assembly is stored. A change to the resources may not require any recompiling of the assembly in accordance with some embodiments.

[00034] According to another embodiment of the present invention, a globalization method includes providing an assembly that is executable by a computer in a monitoring system (such as a power monitoring system) that monitors measurable quantities of a utility, the assembly being programmed in accordance with a .NET framework; defining a globalization resource manager class within the .NET framework; and defining a globalization form class within the .NET framework.

[00035] The globalization resource manager class creates an instance of a default resource manager in the .NET framework, reads, from a registry external to the assembly, resource folder information indicating the location of at least one resource file, identifies a culture of the operating system on which the assembly is running, the culture including a human language, and specifies a resource file having a name based on at least the culture and a location based on at least the resource folder information.

[00036] The globalization form class identifies at least some controls on a form having a name, determines whether each of the at least some controls includes a text component, if the control of the at least some controls includes a text component, for each such control, requests from the globalization resource manager class the value corresponding to text component associated with such control, and stores the name of the form and the name of such control in a text file when the globalization resource manager class returns no value responsive to the request by the form class. The globalization form class inherits from the default form in the .NET framework, and any form a user creates inherits from the globalization form class instead of the default .NET framework form class.

[00037] The method may further include creating a new resource file having text strings, for the at least some controls that include a text component, the text strings being in a different human language from the human language of the culture; and reading, from the assembly, the text strings in the new resource file without recompiling the assembly as a result of the new resource file. The method may further include storing the resource file in a folder different from the folder in which the assembly is stored or storing in the registry the folder location of the resource file. The method may further include translating the values corresponding to the text components associated with each of the at least some controls into a human language different from the human language of the culture without recompiling the assembly as a result of the translation.

[00038] According to another embodiment of the present invention, a method of developing an assembly includes developing an assembly displaying string resources in a first human language. The assembly is programmed from source code that includes a globalization resource manager class that obtains (a) culture information from the operating system on which the assembly is running and (b) the folder location of at least one resource file from a registry external to the assembly. The method further includes compiling the at least one resource file, which includes the string resources; automatically generating a list of controls in the at least one resource file for which there is no associated value in a second human language; providing to a translator the list of controls whose associated string resources are to be translated from the first human language to a second human language; and compiling a new resource file that includes string resources in the second human language, wherein the compiling is carried out without having to recompile the assembly as a result of the providing and without having to distribute any configuration files as a result of providing the new resource file.

[00039] Any of the foregoing methods may be performed by one or more controllers that are directed by instructions encoded in a computer readable storage medium.

[00040] Additional aspects of the invention will be apparent to those of ordinary skill in the art in view of the detailed description of various embodiments, which is made with reference to the drawings, a brief description of which is provided below.

BRIEF DESCRIPTION OF THE DRAWINGS

[00041] The invention may best be understood by reference to the following description taken in conjunction with the accompanying drawings, in which:

[00042] FIG. 1 is a functional block diagram of a system including a database for storing partitioned electrical data according to an aspect of the present invention;

[00043] FIG. 2 is a functional block diagram of a query for electrical data from the database shown in FIG. 1 according to an aspect of the present invention;

[00044] FIG. 3 is a functional block diagram of a query that returns no electrical data from the database shown in FIG. 1 according to an aspect of the present invention;

[00045] FIG. 4 is a functional block diagram illustrating a data writer component that attempts to write new data into the database shown in FIG. 1 according to an aspect of the present invention;

[00046] FIG. 5 is a flow chart diagram of a method for partitioning electrical data according to an aspect of the present invention;

[00047] FIG. 6 is a functional block diagram of a monitoring system in which the present invention may be utilized;

[00048] FIG. 7 is a system flow diagram 2200 of the auto-discovery aspect of the present invention; [00049] FIG. 8 illustrates exemplary fields of information that may be included within a data packet, configuration information, and an exception, according to an aspect of the present invention;

[00050] FIG. 9 is a flow chart diagram of an auto-discovery method according to an aspect of the present invention;

[00051] FIG. 10 is a flow chart diagram of a method of automatically learning an unrecognized publisher according to an aspect of the present invention;

[00052] FIG. 11 is a flow chart diagram of a method of automatically learning unrecognized topic information from a new device or an existing device according to an aspect of the present invention;

[00053] FIG. 12 is a flow chart diagram of a method of automatically discovering missing information according to an aspect of the present invention;

[00054] FIG. 13 is a functional block diagram of a prior art application program;

[00055] FIG. 14 is a functional block diagram of an application program and configuration file, according to one embodiment of the present invention;

[00056] FIG. 15 is a functional block diagram of an application program and a configuration file for use with a power monitoring system, according to one embodiment of the present invention;

[00057] FIG. 16 is a flow chart diagram illustrating a processing model for loading and using dynamically linked assemblies, according to one embodiment of the present invention;

[00058] FIG. 17 is a flow chart diagram illustrating a process for modifying a load sequence, according to one embodiment of the present invention;

[00059] FIG. 18 is a functional block diagram of a system including a new resource class abstracted from the default Microsoft® Resource Manager in accordance with an embodiment of the present invention;

[00060] FIG. 19 is a functional block diagram of the system of FIG. 18 illustrating a form class MyForm that derives from the new globalization form class NewWinForm instead of the default.NET framework class;

[00061] FIG. 20 is a functional block diagram of the system of FIG. 18 illustrating the mapping of various controls to a resource file according to an embodiment of the present invention;

[00062] FIG. 21 is a flow chart diagram of a globalization method in accordance with an embodiment of the present invention; and [00063] FIG. 22 is a flow chart diagram of a globalization method in accordance with another embodiment of the present invention.

DETAILED DESCRIPTION OF THE ILLUSTRATED EMBODIMENT

[00064] Although the invention will be described in connection with certain preferred embodiments, it will be understood that the invention is not limited to those particular embodiments. On the contrary, the invention is intended to include all alternatives, modifications and equivalent arrangements as may be included within the spirit and scope of the invention as defined by the appended claims.

PARTITIONING ELECTRICAL DATA WITHIN A DATABASE

[00065] Referring now to the drawings, and initially to FIG. 1, a block diagram is shown of a monitoring system 100 coupled to a database or database server 102. The monitoring system 100 is connected to a client computer 104 that runs an electrical reporting application 106, which generates reports based on electrical data received from the monitoring system 100. These reports are displayed on the client computer 104 for various trouble-shooting, diagnostic, monitoring, and other purposes. It should be emphasized that as used herein the monitoring system 100 may be any system that monitors measurable characteristics of a utility, including water, air, gas, energy, steam (collectively abbreviated as WAGES), and weather. An implementation is a power monitoring system, and the illustrated embodiments herein are directed to a power monitoring system; however, it should be understood that the present invention applies as equally to power monitoring systems as to other WAGES monitoring or weather station systems.

[00066] A power monitoring system 100 is typically arranged in a hierarchy with monitoring devices such as electrical meters installed at various levels of the hierarchy. Monitoring devices measure various characteristics of the electrical signal (e.g., voltage, current, waveform distortion, power, etc.) passing through the conductors, and the data from each monitoring device is collected by local data collection points within the system and communicated to a central reporting system for further massaging or analysis. The central reporting system includes a client computer 104 that generates reports based on the data received from the power monitoring system 100. As used herein, the client computer 104 may be comprised of a single computer or multiple computers. [00067] The client computer 104 runs various software applications, including an electrical reporting application 106 and an electrical data collection application 108. Both interface with an electrical data engine 110 that includes a query engine 112, a data writer 114, and a data archiver 116. The electrical data engine 110 is coupled to the database or database server 102.

[00068] Data flow between the client computer 104 and the database server 102 may be generally described as follows. The electrical reporting application 106 makes a request for electrical data (1-1), and the request is passed to the query engine 112 of the electrical data engine 110. The query engine 112 converts the request into an appropriate language, such as structured query language (SQL), multidimensional expressions (MDX), or other suitable query language. Because the operator may not be familiar with SQL or MDX, a more simplified and intuitive GUI is provided for the operator to input requests for data, and the query engine 112 converts those requests into a language that the database server 102 can understand.

[00069] After formulating the appropriate query, the query engine 112 sends a targeted request for data to the database server 102 (1-2). The database server 102 includes tables of multi-dimensional electrical data 118 that are organized by time (for example month and year) and data group (examples of data groups are provided below). The multi-dimensional electrical data 118 is a conceptual illustration of the organization of data within a table. Examples of how electrical data is stored in multiple tables is described in connection with FIGS. 2-4 below.

[00070] The database server 102 may be a standalone computer remote from the client computer 104 in an embodiment, or, alternatively, in other embodiments, the database server 102 and the client computer 104 may be part of a single computer. The database 102 would take the form of a hard drive or hard drive array that may be physically or logically separate from the memory structures that comprise the client applications 106, 108. In still other embodiments, the client computer 104 may be connected to the database server 102 via a network, such as a LAN, the Internet, and the like.

[00071] If the electrical data requested by the query engine 112 is present in the database 102, the database 102 returns the result set to the query engine 112 (1-3). The query engine 112 may format or massage the electrical data before returning the result set to the electrical reporting application 106 (1-4), which uses the electrical data to generate reports concerning the power monitoring system 100. [00072] The other client application, the electrical data collection application 108, is operable to insert new data into the database 102. The electrical data collection application 108 is coupled to local data collection points in the power monitoring system 100 and is operable to request and/or collect data received from the monitoring devices within the power monitoring system 100. When new data is received by the electrical data collection application 108, it is provided to the data writer 1 14 of the electrical data engine 1 10 (2-1), which formats the new data for insertion into the database 102 (2-2). The database 102 either accepts the new data and stores it in an appropriate table therein, or it rejects the new data, whereupon it may be stored in a queue or returned to the electrical data collection application 108 with an appropriate explanatory message. Data insertion will be explained in more detail below in connection with FIGS. 4 and 5.

[00073] Finally, the data archiver 116 of the electrical data engine 110 requests aged data (3-1) either from the database 102 or from an archive database 206. The archived data may be stored in the database 102 (such as in a physically or logically separate area of the database 102) where up-to-date data is also stored or in another database. As will be explained below, an aspect of the present invention is that when data is archived, entire tables are archived for ease of later retrieval. As a result of archiving entire tables of data, the present invention decreases response times and increases the efficiency of importing archived data.

[00074] As mentioned above, an aspect of the present invention is that electrical data is organized by group and also by date (for example, month and year). A group is a logical category comprising multiple topics that relate to the group. For example, a non-exhaustive illustrative example of groups include: Currents, Voltages, Powers, Demand Readings, Energies, Power Factors, Power Quality, Unbalance Readings, Fundamental Phasors, Minimum Readings, Maximum Readings, Ratings, Demand Voltages, Spectral Components, Breaker/Trip Unit Status, Cycle-by-Cycle, Trending, Input Metering, Water, Air, Gas, Steam, and Weather Station. Each group includes a number of topics, where each topic logically relates to the group name. A topic is also referred to as a characteristic or a measurement. For example, the following Table 1 illustrates some examples of group names and topics (characteristics):

Table 1

[00075] It should be understood that the foregoing list of groups/topics is exemplary only, and fewer or more or different groups and topics may be used in various embodiments of the present invention. The general idea here is that data values that relate to a common logical theme are grouped together. Tables in the database 102 are organized by group, and data values that relate to those topics (characteristics) associated with each group are stored in separate tables. The tables are further organized by date (month and year in an exemplary embodiment) so that there is a separate table per group per date for every group in the database 102. Aged tables associated with dates that are aged are removed from the database 102 and archived for later retrieval. The removal of aged tables from the database 102 increases retrieval performance and database scalability because there is less data to wade through in response to queries and because the data that is searched is organized in a disciplined way. Archiving of aged tables is handled by a set of rules stored in an electrical data retention table 204 (see FIG. T), and each rule may differ by group. For example, certain data may have a shorter life cycle than other data and should be archived on a quicker basis. For example, current and voltage data have a relatively short life cycle and therefore may need to be archived on a monthly basis (in other words, when the data is over a month old, tables containing current and voltage data older than a month are automatically archived by the database 102 into a data archive). On the other hand, trending data may have a longer life cycle and should be retained longer. The set of rules governing which groups of data are archived and when they should be archived are stored in the electrical data retention data table 204 shown in FIG. 2, which is discussed in more detail below in connection with FIG. 2.

[00076] Multiple groups may also be categorized under a single data type, such as Alarms, Events, and Historical Data. Thus, the following terminology is used to refer to increasingly specific components associated with any given table: type, group, topic, value.

[00077] FIG. 2 illustrates the flow of a request for electrical data that results in data being passed back to the requesting source from the database 102. The electrical reporting application 106 sends to the electrical data engine 110 a request for electrical data. In the example shown, the request is for January 2001 Energy Data. In the request, the group is "Energy," and the date is "January 2001." The query engine 112 formats the request into the appropriate query language for the database 102 and sends the query command to the database 102. The database 102 searches an electrical data catalog 202 to determine whether the requested data exists. The electrical data catalog 202 is essentially a table or index of tables that presently exist in the database 102. If a table is archived and removed from the database, the index in the electrical data catalog 202 is updated to remove (or mask) that table from the listing in the index of the electrical data catalog 202. The electrical data catalog 202 significantly increases performance and scalability in that the numerous tables in the database 102 do not need to be searched to determine whether data pertaining to the request (Jan 2001 Energy Data) exists in the database 102 in the first instance.

[00078] If the group and date combination associated with the requested data is found in the electrical data catalog 202, the database 102 targets the requested data from the appropriate table. In FIG. 2, six exemplary tables 200a-f are shown (obviously, there are numerous other tables that are not shown for ease of illustration). The targeted table is table 20Oe, which represents the Energy data for January 2001. Note that the tables 200a-f all relate to the Energy group, and there is a separate table for each month/year combination (Jan 2005, Jan 2004, and so forth). The resulting data from the targeted table 200e is returned to the query engine 112, which passes the data back to the electrical reporting application 106. The partitioning schema of the present invention avoids having to search through all the data of a database in order to locate the requested data. It also avoids having to use sophisticated, complex, and expensive database tools such as OLAP to manipulate and organize the data in the database before efficient searching can be carried out. However, the present invention does not preclude the use of sophisticated database tools such as OLAP tools.

[00079] Another aspect of the present invention shown in FIG. 2 is table-archiving. Archiving and importing of tables according to an embodiment of the present invention is performed on a per-table basis. The archived tables are removed from the database 102 and stored in data archives 206, which may be logically separate from the physical storage medium where the tables 200a-f are stored, physically separate and remote therefrom, or stored on a separate hard drive or different logical or physical partition of a hard drive within the database server 102. Wherever they are stored, they are removed from the database 102 on a per-table basis and stored in the archives 206 on a per-table basis. When aged data from an archive 206 is requested, the relevant table(s) containing the aged data are imported in their entireties back into the database 102. They can then be returned to the archives 206 (and removed or masked from the electrical data catalog 202) after the targeted data has been passed back to the requesting source.

[00080] The timing of when data is archived is determined by a set of rules provided in an electrical data retention table 204 in the database 102. The electrical data retention table 204 includes a set of rules that indicate, on a per-group basis, the maximum age of data that can be stored in each group. For example, a rule may be simply an entry in the electrical data retention table 204 that has two fields: the name of a group and a period of time indicating how long that group can remain in the database 102. For example, a rule may provide: current and 3 months. Such a rule would instruct the database 102 to archive on a per-table basis any tables belonging to the current group whose data is older than 3 months. Another rule may provide: maximum readings and 1 year. Such a rule would instruct the database 102 to archive on a per-table basis any tables belonging to the maximum readings group whose data is older than one year. When a table is removed from the database 102, its corresponding entry is also removed (or masked) from the electrical data catalog 202. By "masked" it is meant that the entry may simply be hidden or otherwise dormant or inaccessible until unmasked. In other words, it is not necessary to actually remove or delete the entry; rather it may simply be masked or hidden so that searches ignore the entry.

[00081] In FIG. 3, the database 102 does not have the requested data (here, January 1999 Energy data). Again, the electrical data catalog 202 is queried to determine whether the requested data exists, which reports that it does not. No data is returned to the electrical reporting application 106 and software running on the client computer 104 may inform the operator that the requested data does not exist in the database 102.

[00082] The operator may then run a targeted query in the data archives 206 for the archived data (Jan 1999 Energy data), or the operator may request that the relevant data archive be imported back into the database 102 (and the electrical data catalog 202 correspondingly updated) so that queries can return the requested data from the database 102 without having to extract the aged data separately from the archives 206. Later, the aged data may be returned to the data archives 206 and removed from the electrical data catalog 202 when it is no longer needed.

[00083] Turning now to FIGS. 4 and 5, a procedure is illustrated for inserting new data into the database 102. The electrical data collection application 108 sends new electrical data (January 2006 Energy data in the illustrated example) to the data writer 114 of the electrical data engine 110, which formats the data for insertion into the database and sends it to the database 102. The database 102 queries the electrical data catalog 202 to determine whether a table exists in the database 102 for the data requested to be inserted. In this example, there does not exist any table in the database 102 for Energy data for January 2006 (though it may exist elsewhere, such as in the data archives 206).

[00084] FIG. 5 illustrates a flow chart diagram of a sequence of events for writing new data to a table. Electrical data is received (500) that includes a table 501 comprising a Device ID, a Topic ID, a Value, and Time information (which includes date data). The Device ID (identification) in table 501 is an identification number associated with the device from which the data was received (such as a particular electrical meter, for example). The Topic ID in table 501 corresponds to the topic or characteristic of the data received, such as any of the Topic IDs set forth in Table 1 above. The Value in table 501 corresponds to the value of the characteristic or topic specified by the Topic ID. For example, if the Topic ID is Currents, then the Value is the current value in amps that was measured by the Device. The Time information in table 501 includes any combination of second, minute, hour, day, month, and/or year at which the Value was measured by the Device. The database 102 extracts the Month and Year from the Time information (502) in table 501 (here, January 2006). The data groups are retrieved (504) from, for example, the electrical data catalog 202. The data groups include a data group table 505 that comprises a Group ID, a Group Name, and associated Topic IDs. The Group ID is a number assigned to each Group Name. The Group Name can be any of the group names specified in Table 1 above, and the Topic IDs correspond to the topics associated with the Group Name, such as specified in Table I above.

[00085] The database 102 determines whether the Topic ID from table 501 belongs to a group (506), and if so, the database 102 forms a Data Table Name 509 (508) that is composed of alphanumerical characters including the Organization name, the Type of data contained within the table (such as Alarms, Events, or Historical Data), the Group Name (such as Energy), the Month corresponding to the data (such as Jan), and the Year corresponding to the data (such as 2006). Using these components, the database 102 forms a new table that has a name created from these components. Each table would therefore be unique from all other tables, because a change in any of the component information, such as the Month or Year, results in a new table being created. In addition, a consistent naming regimen simplifies database design and querying. In other embodiments, the tables 200 may be identified by another naming scheme or even an arbitrary naming scheme, so long as each table is uniquely distinguishable from all other tables.

[00086] After forming the Data Table Name 509, the database 102 searches the electrical data catalog 202 to determine whether the table exists in the database 102 (510). Because all the table names conform to a predetermined naming scheme, the table name to be compared can be generated "on the fly" and compared against table names already stored in the electrical data catalog 202. If the table does exist in the database 102, the data in the data table 501 is written to that database table (512). In the illustrated example, the data in the data table 501 would be written to the table with a name ending in Energy_Jan_2006. If the table does not exist in the database 102, a new table is created (514) using the naming scheme specified above, and the data in the data table 501 is written to the new table. A corresponding rule may be created and stored in the electrical data retention table 204 for the new table. In the case of a new group, the rule-creation may occur automatically (for example, all new groups may default to a default age, such as one year) or manually (in response to a valid age inputted by the operator).

[00087] Returning to 506, if the Topic ID in the table 501 does not belong to a known group in the database 102, the data in the table 501 is written to a rejected data table (516) that may be stored in the database 102 or in a storage device external to the database 102. Optionally, the electrical data catalog 202 may include entries for the rejected data tables so that when queries are run on the database 102 for data corresponding to the rejected data tables, the operator can be informed that attempts have been made to write unauthorized or unrecognizable data to the database 102.

TRANSFER OF ELECTRICAL DATA WITH AUTO-DISCOVERY OF SYSTEM CONFIGURATION

[00088] Referring to FIG. 6, a monitoring system 2100 is shown. The monitoring system 2100 may be any system that monitors measurable characteristics of a utility, including water, air, gas, energy, steam (collectively abbreviated as WAGES), and weather. An implementation is a power monitoring system, and the illustrated embodiments herein are directed to a power monitoring system; however, it should be understood that the present invention applies as equally to power monitoring systems as to other WAGES monitoring or weather station systems.

[00089] A power monitoring system 2100 is typically arranged in a hierarchy with monitoring devices such as electrical meters 2120, 2122 installed at various levels of the hierarchy. Monitoring devices measure various characteristics of the electrical signal (e.g., voltage, current, waveform distortion, power, etc.) passing through the conductors, and the data from each monitoring device 2120, 2122 is collected by local data collection points 2106, 2108 within the monitoring system 2100 and communicated to one or more servers 2110, 21 12 for storage or analysis.

[00090] FIG. 6 shows two installations 2102, 2104 each comprising respective local data collection points or nodes 2106, 2108. The points or nodes 2106, 2108 may be implemented in hardware as a computer. The meters 2120, 2122 send their respective data to the appropriate local data collection point 2106, 2108, which have local configuration information 2126, 2128 regarding the devices 2120, 2122 to which each node is connected. Each node 2106, 2108 can communicate with either or both servers 2110, 2112 via communication links directly or via a network. In an embodiment, the computer 2106 includes the server 2110. In other embodiments the computers and servers are different computers. The computers 2106, 2108 and servers 2110, 21 12 may be comprised of a single computer or multiple computers. The computers 2106, 2108 may also be referred to herein as publishers and the servers 2110, 2112 may be referred to as subscribers. A publisher includes a software application that attempts to push data out to a subscriber.

[00091] Each publisher 2106, 2108 has an associated publisher identification that uniquely identifies it in the power monitoring system 2100. Each device 2120, 2122 also has an associated device identification that uniquely identifies the device in the power monitoring system 2100. Thus, a data packet from meter 2120a, for example, will include a publisher identification (ID) that identifies the installation 2102 in which the meter 2120a exists as well as a device ID that uniquely identifies the device 2120a from all other devices 2120b, 2120c and 2122a,b,c. In addition, the data packet also includes an originator ID that identifies the originating installation of the data packet. For example, the publisher 2106 may send a data packet from meter 2120a to the publisher 2108. That data packet includes an originator ID that identifies the installation 2102 as the originator, a publisher ID (which is the same as the originator ID), and a device ID. When that data packet is sent to one of the servers 21 10, 2112, the publisher ID is changed to reflect that publisher 2108 has sent the data packet, but the originator ID remains unchanged such that the server 2110, 2112 knows that the data packet originated from installation 2102 and not installation 2104. As used herein, the originator ID, publisher ID, and device ID are referred to as identification information. FIG. 8 illustrates an example of a data packet 2300 including data and identification information.

[00092] In addition to data packets, the publishers 2106, 2108 also include local configuration information 2126, 2128. The configuration information 2126, 2128 includes any one or more of the following information: the type of device, the type of data (topical information such as current, voltage, power, energy, and the like), unit of measurement, the group to which the data belongs, user-defined quantities, alarms, system health information, watchdog, audit events, hierarchical information about the monitoring system 2100, system context (e.g., the contextual relationship of the meters 2120, 2122 within the system 2100), power-distribution layout information (e.g., how the feeders and meters 2120, 2122 are distributed on the grid), and environmental data. Examples of fields that may be included within a configuration information 2302 is shown in FIG. 8. Examples of group names and their associated topics are found in Table 1 below. [00093] The system configurations 2130, 2132 in the servers 21 10, 2112 store all local configuration information that has been approved. When a new publisher, for example, attempts to send data to one of the servers 2110, 2112, the local configuration information for the new publisher must be learned by the servers 2110, 2112 before data packets will be accepted from the new publisher. This aspect of the present invention is described more fully below.

[00094] FIG. 7 is a system flow diagram 2200 of an auto-discovery aspect according to the present invention. When a new device is added to the power monitoring system 2100 (2202), the local configuration 2126 for that publisher 2106 is updated (2204). Data packets from the new device are stored in an optional message queue 2206 for reasons that are explained in more detail below. Generally, the message queue 2206 can be used to guarantee that data packets will be delivered and stored on the server 2110, and serve as a buffer for data packets awaiting approval by the server 2110 while the publisher 2106 attempts to comply with the requests for further information from the server 2110. As mentioned above, each new data packet from the new device includes identification information (e.g., originator ID, publisher ID, and device ID).

[00095] Assuming the publisher 2106 is already approved by the server 2110, the publisher 2106 sends the new data packet to the server 21 10 (2208). The server 2110 checks its system configuration 2130 to determine whether it can accept the new data packet. Because the device is a new device, the server 2110 throws an exception or error code to the publisher 2106 indicating which information is prerequisite to a successful completion of the data transfer. The exception, for example, may indicate that the configuration information for the new device is invalid or unknown to the server 21 10 (FIG. 8 shows an example of some exemplary error codes of an exception 2304). The publisher 2106 responds by sending the information embedded in the exception, such as the new configuration information for the new device, and resends the data packet. Once the publisher 2106 publishes all of the required configuration information requested by the server 2110, the server 2110 accepts the new data packet and the new device. When the publisher 2106 subsequently attempts to send data packets from the new device, they are accepted by the server 2110 without exception and the approval process is completed without manual intervention by the operator.

[00096] On the server 2110 (or subscriber) side, the present invention contemplates a process of auto-discovery (2210) that automatically learns and/or automatically approves identification information and/or configuration information. A software program running on the server 2110 implements the auto-discovery feature of the present invention, and the software program interfaces with a central database 2212 within the server 2110 where the accepted data packets are stored for later retrieval or analysis.

[00097] In automatic learning mode, the auto-discovery 2210 block can learn identification information or configuration information without necessarily approving it. To do so, the server 2110 stores the identification information or configuration information in the database 2212. In automatic approval mode, the auto-discovery 2210 block can actually approve identification information or configuration information that it has learned. Approval may be setting a flag that indicates approval in the database 2212. Only when approval is granted by the server 2110 will the server accept data packets from the publisher 2106.

[00098] FIG. 9 is a flow chart diagram of an auto-discovery method (2400) according to an embodiment of the present invention. References will be made to the publisher (or local computer) 2106 and the server (or subscriber) 2110 for ease of discussion. The publisher 2106 publishes a data packet 2300 by sending it to the subscriber 2110 (2402). The data packet 2300, which is received from a monitoring device like the meter 2102a in the power monitoring system 2100, may be buffered in the optional message queue 2206 while the subscriber 2110 processes the publication request of the publisher 2106. The subscriber 2110 examines the publisher ID embedded in the data packet 2300 to determine whether the publisher 2106 is authenticated or authorized to have its data accepted by the subscriber 2110 (2404). The authentication/authorization aspect prevents unauthorized publishers from accessing the database 2212.

[00099] If the publisher 2106 is authenticated or authorized, the subscriber 2110 determines whether the publisher 2106 is a member of an enterprise system (2406), and if not, assigns a default company to the incoming data packet 2300 and retains all identification information for routing purposes (2422). If the publisher 2106 is a member of an enterprise system, the subscriber 2110 determines whether the company is known (2408), and, if not, the subscriber 21 10 rejects all data (2420). Optionally, the subscriber 2110 maintains a log of all failed attempts to store data in the database 2212 for later trouble-shooting or security purposes. By checking the enterprise status of the system, the aspects of the present invention may be readily incorporated into legacy systems.

[000100] The subscriber 2110 determines whether the company is known (2410), and if it is not, rejects all data (2420). If the company is known (2410), the subscriber 2110 determines whether the device ID in the data packet 2300 is known (2412). If the device ID is known (2412), the subscriber validates the originator ID and the publisher ID in the data packet 2300 and updates these fields if they have changed (2414). The subscriber 2110 determines whether the device 2102a is approved (2416), and if so. stores the data in the data packet 2300 in the database 2212 (2418).

[000101] Returning to block (2412), if the device ID is not known, the subscriber 2110 determines whether the publisher ID in the data packet 2300 is known (2424). If so, the subscriber 2110 learns the device 2102a (2428), described in more detail below. If not, the subscriber 2110 automatically learns the publisher ID and the originator ID in the data packet 2300 (2426) and learns the device 2102a (2428). The subscriber 2110 learns the device 2102a by storing in the database 2212 at least the device ID from the data packet 2300. The next time the device 2102a attempts to send a data packet, its device ID will already be stored in the database 2212 of the subscriber 2110. Note that learning the device 2102a does not necessarily mean that the device 2102a is approved.

[000102] The subscriber 2110 determines whether to automatically approve the device 2102a (2430). The operator may select an option to automatically or manually approve devices, and this option is known to the subscriber 2110. If the option is not to automatically approve devices, the operator must manually approve the device and the publisher (2436), whereupon the subscriber 2110 will reject all data (2420) from that publisher 2106 and device 2102a.

[000103] If the option is to automatically approve devices, the subscriber 2110 will automatically approve the device 2102a (2432) such as by setting a flag in the database 2212 that indicates the device 2102a has been approved. If the device is approved (2434), the data in the data packet 2300 is stored in the database (2418); otherwise it is rejected (2420).

[000104] FIG. 10 is a flow chart diagram illustrating a method of automatically approving a new publisher according to an embodiment of the present invention (2500). The publisher 2106 publishes a data packet 2300 (2402), which is optionally stored in the message queue 2206 (2502). The subscriber 2110 determines from the publisher ID field of the data packet 2300 whether the publisher is approved (2504). If so, the subscriber determines whether the publisher is authenticated or authorized (2404) and proceeds from there with the method set forth in FIG. 9.

[000105] If the publisher 2106 is not approved (2504), the subscriber 2110 throws an exception 2304 with at least one error code indicating an invalid publisher ID has been received (2506). The exception 2304 travels back to the publisher 2106, which interprets the invalid-publisher-ID error code and sends its configuration information to the subscriber 2110. If the subscriber 2110 is operating in an auto-learn mode, the subscriber 2110 automatically learns the publisher 2106 (2510) by storing at least its publisher ID in the database 2212. The subscriber 2110 determines whether to automatically approve the publisher 2106 (2512). If automatic approval is not set by the operator, the operator must manually approve the publisher 2106 (2436), and the subscriber 21 10 rejects the data (2420). Otherwise, the subscriber 2110 automatically approves the publisher 2106 (2514), and the data packet 2300 is sent either from the publisher 2106 or from its message queue 2206 to the subscriber 2110 (2516), which stores it in the database 2212 (2418).

[000106] FIG. 11 is a flow chart diagram illustrating a method of automatically approving new topic information from a data packet in the monitoring system 2100 according to an embodiment of the present invention (2600). The subscriber 2110 determines whether all the topics in the configuration information 2302 associated with the device 2102a are known. If so, the data in the data packet 2300 is stored in the database 2212 (2418). Otherwise, the subscriber 2110 throws an exception 2304 with at least one error code indicating that an invalid topic information has been received (2604). The exception 2304 travels back to the publisher 2106, which interprets the invalid-topic-information error code and publishes the missing topic information (there may be one or more missing topics) back to the subscriber 2110 (2606), which automatically learns the missing topic information by updating the topic information field(s) in the configuration information 2302 associated with the device 2102a with the missing topic information.

[000107] The subscriber 2110 determines whether to automatically approve the missing topic(s) (2610), and if not, the operator must manually approve the missing topic(s) (2616), and the subscriber 2110 rejects the data (2420). Otherwise, the subscriber 2110 automatically approves the missing topic(s) (2612) by, for example, setting one or more flags in the configuration information 2302 indicating that the missing topics are approved. The data packet 2300 is sent from the publisher 2106 or its message queue 2206 to the subscriber 2110, which stores the data in the database 2212 (2418).

[000108] FIG. 12 is a flow chart diagram illustrating a method of auto-approving identification or configuration information according to an embodiment of the present invention. The publisher 2106 publishes a data packet 2300 (2402). The subscriber 2110 analyzes the identification information in the data packet 2300 and identifies information that is unknown or invalid (2702). In this embodiment, multiple pieces of information are unknown to the subscriber 21 10, which creates an exception 2304 including multiple error codes each representing each item of unknown or invalid information. For example, with reference to FIG. 8, the subscriber 2110 may recognize the device 2102a, but not the publisher 2106. The exception 2304 would include an error code indicating an invalid originator ID, an invalid publisher ID, and invalid configuration information. The exception 2304 is thrown to the publisher 2106, which interprets the error codes in the exception 2304 to determine which items of information are missing.

[000109] The publisher 2106 publishes the missing information, such as in the example above the originator ID, the publisher ID, and the configuration information (2706). The publisher 2106 may also publish any new topic information (2706) in order to head off further exception handling by the subscriber 2110. If the subscriber is in auto-approve mode, the missing published information is automatically approved (2710) by writing the missing information to appropriate identification information and configuration information fields in the database 2212 associated with the publisher 2106, and the data in the data packet 2300 is accepted by the server 2110 and stored in its database 2212. If the subscriber 2110 is in manual-approve mode, the missing published information must be manually entered by the operator (2714).

[000110] As mentioned above, the following table lists exemplary group names and topics that may be published:

Group Name Topic ID (separate topics delimited by commas or slashes)

Alarm Status, Phase Rotation Alarm Status, Load Shed Current Alarm Status, Load Shed Power Alarm Status, Current Unbalance Pre-Alarm Status

Cycle-by-Cycle Cycle-by-cycle current, Cycle-by-cycle voltage

Trending Meter Register Number, Scale Factor, 1 -Minute/1 -Hour/1 - Day/1 -Month Reading Last

Second/Minute/Hour/Day /Month/Year, 1 -Minute/ 1 -Hour/ 1 - Day/ 1 -Month Statistics Avg Reading, Daily/Hourly Forecast Std Deviation/Avg Reading, Summary of Hourly/Weekly Statistics Avg/Min/Max/Std Dev

Input Metering Consumption Units, Rate Units, Demand Last, Present Demand, Avg Demand CaIc, Peak Demand, Cumulative Usage

Water Water Flow, Water Flow Previous Day Total, Water Flow Current Day Total, Water Flow Incremental, Water Flow Rate, Water Flow Rate Min/Max/Hourly Average/Daily Average/Weekly Average/Monthly Average, Water Heat Flow, Water Heat Flow Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Monthly Avg, Water Temperature Supply, Water Temperature Supply Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg, Water Temperature Return, Water Temperature Return Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg, Water Flow Rate, Water Flow Rate Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg, Sewage Flow Rate, Sewage Flow Rate Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg

Air Air Pressure, Air Pressure Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg, Air Flow, Air Flow Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg, Air Temperature, Air Temperature Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg

Gas Gas Flow, Gas Flow Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg, Gas Flow Rate, Gas Flow Rate Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg, Gas Temperature, Gas Temperature Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg, Gas Pressure, Gas Pressure Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg

Steam Steam Flow, Steam Flow Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily Avg, Steam Flow Rate, Steam Flow Rate Min/Max/Hourly Avg/Daily Avg/Weekly Avg/Daily

Table 2

LOADING A CHAIN OF PROCESSORS FROM AN XML FILE

[000111] Referring to FIG. 13, a prior art application program 3100 is shown. The application program 3100 includes a load sequence for a plurality of dynamically linked assemblies (e.g., processors 3104a-d). This load sequence, in prior art application program 3100, is hard coded directly within the application program 3100 itself. Each of the plurality of dynamically linked assemblies that may be required by the application program 3100 is listed in a special table in the executable called, for example, a function import table. This table contains all the names of functions that need to be linked dynamically and the names of libraries (e.g., dynamically linked libraries) in which the assemblies reside. When the application program 3100 runs, the libraries, whose names appear in the function import table, are loaded and references to the function calls in the assemblies are resolved with the actual address of the function code.

[000112] During execution of the application program 3100, the dynamically linked libraries (DLLs) are loaded and the references to the function calls are resolved (i.e., function calls are replaced with the exact addresses of the assemblies in memory). To facilitate this type of linking, DLLs typically have a special table called an export table, containing names of functions that can be linked to dynamically by other application programs or DLLs and the actual addresses for the assemblies. Only functions that appear in the DLL's export table can be linked to dynamically by the application program 3100.

[000113] When the application program 3100 is used, the computer first loads the application program 3100 and looks for the DLL names in the application program's 3100 import list. The application program 3100 checks whether the DLL specified in the import list is already loaded in memory by other application. If the specified DLL is already present in memory then references are resolved with the same instance of the DLL. If the DLL is not already present in memory, a fresh instance is loaded and references are resolved with this newly created instance. All later references to the DLL calls can be resolved with this instance until the DLL is unloaded from the memory.

[000114] As illustrated, the hard-coded load sequence is such that the plurality of processors 3104a-d (e.g., DLLs) is dynamically loaded into a Random Access Memory (RAM) by a request sent by the application program 3100. Once the plurality of processors 3104a-d has been loaded into the RAM, the application program 3100 sends a request 3108a to the first processor 3104a specifying the data set for the first processor 3104a to process. A second request 3108b is then sent to the second processor 3104b, a third request 3108c is sent to the third processor 3104c, and finally, a fourth request 3108d is sent to the fourth processor 3104d. Each of the plurality of processors 3104a-c processes the specified data set and provides an output that the subsequent processor 3104b-d can recognize and process. The fourth processor 3104d, in the illustrated example, outputs the final results 3112 requested by the application program 3100.

[000115] As discussed, the load sequence of the plurality of processors 3104a-d in the prior art application program 3100 is hard coded into the application program 3100 itself. As such, if a user desires to rearrange the plurality of processors, add a processor, or delete a processor, the user must modify and compile the application program 3100 to make such a modification.

[000116] Turning now to FIG. 14, an application program 3200 incorporating the present invention is illustrated, according to one embodiment of the present invention. The application program 3200 is adapted to load a plurality of dynamically linked assemblies 3204 (also called processors) based on a load sequence specified in a configuration file 3210. The configuration file 3210 is a parseable, text file that contains at least one load sequence for the plurality of dynamically linked assemblies 3204 that is readable by the application program 3200. In an embodiment, each of the dynamically linked assemblies is independent from the other dynamically linked assemblies.

[000117] According to one embodiment, the configuration file 3210 is in an extensible markup language (XML) format. The configuration file 3210, in an XML format, can be processed purely as data by a program, can be stored with similar data on another computer, or can be displayed. By utilizing XML, a user or programmer can create common information formats and share both the format and the data.

[000118] The configuration file 3210 specifies the assemblies that are to be loaded, the order the individual assemblies are to be loaded, and the class or classes that will be used for processing. The class implements a standard method that serves as the entry point into the assembly 3204. Each of the assemblies 3204 implements a standard method within a specific class. Because the method is common to all of the assemblies 3204, the configuration file 3210 calls the assembly 3204 by the standard method to initiate any of the assemblies 3204. Therefore, although the signature for each of the plurality of assemblies 3204 is the same, the implementation for the plurality of assemblies 3204 may be different.

[000119] In the illustrated embodiment, when the application program 3200 requires dynamically linked assemblies to process data, the application program 3200 reads the settings 3202 from the configuration file 3210. The application program 3200 reads the settings 3202 to determine the assemblies 3204 required, the order to load the assemblies, and the class to use for processing the assemblies 3204.

[000120] Once the application program 3200 has determined the load sequence from the configuration file 3210, the application program 3200 loads each of the plurality of assemblies 3304 in the determined order. A first load signal 3206a is sent to load a first processor 3204a into the RAM (e.g., into the application program's 3200 memory space). A second load signal 3206b is sent to load the next processor (i.e., a second processor 3204b), a third load signal 3206c is sent to load the third processor 3204c, and additional load signals are sent until a final load signal 3206d is sent to load the final processor 3204d into the RAM.

[000121] After all of the plurality of processors 3204a-d are loaded into the RAM, a first process request 3208a is sent to the first processor 3204a. A process request is a call to a processor with the class to be used for processing. Once the first processor 3204a has finished processing and returned execution back to the application program 3200, the application program 3200 calls the second processor 3204b by sending a second process request 3208b. Once the execution from the second processor 3204b has been returned to the application program 3200, a third process request 3208c is sent to the third processor 3204c by the application program 3200, and this cycle continues until a final process request 3208d is sent to the final processor 3204d. The results 3112 from the final processor 3204d are communicated to the application program 3200.

[000122] As discussed above, each of the assemblies 3204 utilizes a common dataset. In one embodiment, each of the assemblies 3204 utilizes the .NET framework dataset. Thus, the outputs from each of the processors 3204a-d are stored in a .NET framework dataset and the application program interfaces (APIs) for the .NET framework dataset enable the next assembly in the sequence to determine the contents of the dataset being passed to the assembly. Once the results of a query have been fetched from a .NET framework dataset, any changes made to the contents of the dataset by the plurality of assemblies 3204 do not affect the database.

[000123] In an embodiment, the dataset represents a set of data arranged in tables and includes information about how the data is ordered and constrained within the tables, as well as information specifying the relationships among the tables. The .NET framework dataset allows the contents of the dataset to be saved and loaded to and from files as XML configuration documents. In addition, the .NET framework dataset also allows schema information (e.g., table, column, and constraint information) to be separated into an XML schema file.

[000124] Turning now to FIG. 15, an application program 3300 and a configuration file 3310 for use with a' monitoring system is illustrated, according to another embodiment of the present invention. The monitoring system may be any system that monitors measurable characteristics of a utility, including water, air, gas, energy, steam (collectively abbreviated as WAGES), and weather. An implementation is a power monitoring system, and the illustrated embodiment is directed to a power monitoring system; however, it should be understood that the present invention applies as equally to power monitoring systems as to other WAGES monitoring or weather station systems.

[000125] A power monitoring system is typically arranged in a hierarchy with monitoring devices such as electrical meters installed at various levels of the hierarchy. Monitoring devices measure various characteristics of the electrical signal (e.g., voltage, current, waveform distortion, power, etc.) passing through the conductors, and the data from each monitoring device is collected by local data collection points within the monitoring system and communicated to one or more power-monitoring databases 3320 for storage or analysis.

[000126] In an embodiment, the application program 3300 processes data and generates reports on the information in the power-monitoring database 3320. The application program 3300 can be utilized to develop a plurality of reports from the power-monitoring database 3320, such as an "electrical cost summary," illustrated in FIG. 15. When an electrical cost summary is desired, the application program 3300 reads the settings 3302 from the configuration file 3310 to determine the required dynamically linked assemblies 3304 (e.g., processors 3304a-d), the order to load the assemblies, and the class to use for processing.

[000127] Once the application program 3300 has determined the load sequence from the configuration file 3310, the application program 3300 loads each of the plurality of assemblies 3304 in the determined order. Each of the plurality of assemblies 3304 includes at least one function required for developing the electrical cost summary. A first load signal 3306a is sent to load a first processor 3304a into the RAM (e.g., into the application program's 3200 memory space). A second load signal 3306b is sent to load the next processor (i.e., a second processor 3204b), a third load signal 3306c is sent to load the third processor 3304c, and additional load signals are sent until a final load signal 3306d is sent to load the final processor 3304d into the RAM.

[000128] After all of the plurality of processors 3304a-d are loaded into the RAM, a first process request 3308a is sent to the first processor 3304a. The first processor 3304a provides a data extraction function. The first processor 3304a, in the illustrated embodiment, is in communication with the power-monitoring database 3320 can query the power- monitoring database 3320 and request data therefrom. This data is then formed into a dataset by the first processor 3304a that can be recognized and processed by the next assembly in the process order as provided in the configuration file 3310.

[000129] Once the first processor 3304a has finished processing and returned an execution to the application program 3300, the application program 3300 calls the second processor 3304b by sending a second process request 3308b. The second processor 3304b, in the illustrated example, provides an energy usage function. Thus, the second processor 3304b is programmed to determine the energy usage information from the dataset output by the first processor 3304a.

[000130] Once the execution from the second processor 3304b has been returned to the application program 3300, a third process request 3308c is sent to the third processor 3304c. The third processor 3304c, in the illustrated embodiment, provides a demand function. Thus, the second processor 3304c is adapted to determine the demand information from the dataset output by the second processor 3304b. This cycle of calling the loaded assemblies 3304 continues until a final one of the plurality of assemblies 3304 is reached.

[000131] Once the final one of the plurality of assemblies is reached, a final process request 3308d is sent to a final processor 3304d. The final processor 3304d, in the illustrated embodiment, provides an aggregation function. Thus, the final processor 3304d is adapted to aggregate the dataset in various ways. The results 3212 from the final processor 3304d are communicated to the application program 3300 and the application program 3300 further manipulates, stores, or displays these results as the electrical cost summary.

[000132] Turning now to FIG. 16, a processing model for loading and using dynamically linked assemblies is illustrated, according to one embodiment of the present invention. An configuration file 3410 (e.g., an XML configuration file) is read by the application program 3200 at step 3414. By reading the configuration file 3410, the application program 3200 is able to determine the process order, assembly name, and assembly class information 3420 for each of the plurality of dynamically linked assemblies 3204 to be loaded and used. The application program 3200 utilizes the process order and assembly name information to load the processing assemblies 3204 in the load sequence at step 3418. Once all of the assemblies 3204 have been loaded into the memory, the application program 3200 makes a process request 3208a into the first processor 3204a. The first processor 3204a performs the processing operation at step 3426 and a resulting dataset 3430 is generated.

[000133] The application program 3200 then determines, at decision box 3434, whether additional assemblies 3204 remain within the process order. If the program 3200 determines that there are additional processors remaining in the process order, a process request is made into the next assembly 3204 at step 3438. The next assembly 3204 performs the processing operation at step 3442 on the resulting dataset 3430 (generated by the previous assembly 3204) and another resulting dataset 3450 is generated. The application program 3200 then determines, at decision box 3434, whether additional assemblies 3204 remain within the process order. This process continues until the determination is made, at decision box 3434, that the final processor 3204d has performed its processing operation.

[000134] Referring now to FIG. 17, a process for modifying a load sequence is illustrated, according to one embodiment of the present invention. As discussed above, to determine the load sequence, the application program 3200 reads the configuration file 3210 and determines the assembly names and the process order for the assemblies 3204. Therefore, to modify the load sequence (e.g., rearrange the assemblies, add an assembly, or remove an assembly) only the configuration file 3210 needs to be modified. Because the application program 3200 is hard coded to determine the load sequence by reading the configuration file 3210, and the configuration file is a parseable text file, the textual load sequences within the configuration file 3210 can be modified without coding the new sequence into the application program 3200. It should be apparent to those skilled in the art that the modification of the load sequence can be accomplished without recoding and recompiling the application program 3200 and, in some embodiments, without recoding the configuration file 3210.

[000135] As illustrated in FIG. 17, a determination is made, at decision box 3510, whether the load sequence requires modification. If the load sequence does require modification, the configuration file 3210 is modified at step 3520 to reflect the new load sequence. This modification to the load sequence occurs without the need for recoding or recompiling the application program 3200. Once the configuration file 3210 has been modified at step 3520, or if the determination is made, at decision box 3510, that the load sequence does not require modification, the application program 3200 reads the configuration file 3210 at step 3530. The application program 3200 loads the plurality of dynamically linked assemblies 3204 into the memory at step 3540 according to the load sequence set forth in the configuration file 3210, and a process request is sent to the first dynamically linked assembly 3204 at step 3550.

GLOBALIZATION COMPONENT

[000136] An embodiment of the present invention provides for a globalization component that eliminates the need to recompile assemblies for multiple translations or for changes to resources. Only the resource text files need to be modified; no binary assembly code needs to be modified and no configuration files need be modified or distributed. According to an embodiment of the present invention, a new class (hereafter called NewResourceManager) provides a layer of abstraction from the standard Microsoft® Resource Manager, which extracts resources from embedded resource files or satellite assemblies. The NewResourceManager class specifies the locations of the resource files based on culture information, allowing the same binary to work across operating systems in different human languages. Only the resource files would differ depending upon the human language (e.g., English, French, Spanish) of the operating system. The preferred development environment for the globalization component is Microsoft® Visual Studio®, though it should be understood that any suitable development environment may be utilized to develop Windows®, Mac OS®, or Internet-based assemblies. Advantages of the present invention include simplifying code development, reducing the amount of code, which reduces the frequency of errors and bugs, facilitating the globalization of code into multiple human languages, and providing a debugging tool for quickly identifying missing or invalid string resources. As applied to a monitoring system, such as a power monitoring system, the advantages become paramount because developing software for such systems is very complex involving a multitude of software modules, mining and analysis of huge quantities of data, and cross-regional database management.

[000137] Referring to FIG. 18, a .NET framework assembly 4100 is shown, which includes a globalization component called NewResourceManager 4102 that is abstracted from the default Microsoft® Resource Manager 4104 provided in the standard .NET Framework. As used herein, an assembly may include one or more process and/or dynamically linked library assemblies. The assembly 4100 further includes culture information 4106 and reads resource folder information from a registry 4108. Assembly Resource File A 4110 and Assembly Resource File B 4112 have been decoupled from the assembly 4100. The resource files 4110, 41 12 are generated from a resource text file using a resource generator, such as resgen.exe, such that the text strings are obfuscated. The culture information 4106 includes a human language ID associated with the operating system on which the assembly 4100 is running.

[000138] The resource files 4110, 4112 include resources (such as text strings) whose values are written in a particular human language. For example, Resource File A may include all the resources for an English-language operating system, and Resource File B may include all the resources for a French-language operating system. If it is desired to provide the assembly for use with a Spanish-language operating system, Resource File C 4114 may be generated without having to recompile the assembly 4100 to accommodate the new resource file 4114. The translator would be provided with the resource text file corresponding to the Resource File A 4110, and would translate all the text strings in that resource text file into the target human language (in this example, Spanish). Then, the resource text file C would be compiled into the Resource File C 4114 using a resource generator such as resgen.exe. No recompiling of the assembly 4100 would be necessary. When the assembly 4100 is run on a Spanish-language operating system, the assembly 4100 would automatically pull the resources from the Resource File C 41 14. When the same assembly 4100 is run on a French-language operating system, the assembly 4100 would automatically pull the resources from the Resource File B 4112. Any number of additional resource files in different human languages can be developed without modifying any source code in the assembly 4100 and without modifying or distributing any configuration files.

[000139] The assembly 4100 requests a resource from the NewResourceManager class 4102, which requests the resource folder location from the external registry 4108. Because the NewResourceManager class 4102 has knowledge of where the resource files are located, the software developer has the flexibility to store resource files in any folder. The NewResourceManager class 4102 creates an instance of the .NET framework Resource Manager class 4104 and sets the resource folder information read from the registry 4108. The NewResourceManager class 4102 sets the culture-specific resource file using the culture information 4106. The Resource Manager 4104 requests the resource from the Resource File A 4110, which returns the culture-specific resource string corresponding to the requested resource to the Resource Manager 4104. The target resource string is provided from the Resource Manager 4104 to the NewResourceManager class 4102, which returns it to the assembly 4100.

[000140] In FIG. 19, the .NET assembly 4100 is called MyProject and includes the NewResourceManager class 4102 (globalization component), a .NET form class 4204 called NewWinForm, and a form 4206 called MyForm, which inherits from the base class NewWinForm 4204 instead of the default form class provided in the .NET framework (all other child forms in the assembly 4100 also inherit from the base class NewWinForm 4204). The MyForm form 4206 includes three controls or widgets, a buttonl control 4208a, a button2 control 4208b, and a textboxl control 4208c. The NewWinForm base class 4204 recursively iterates over each string-containing child control 4208a, 4208b, 4208c on the MyForm form 4206 and requests the string resources from the NewResourceManager class 4202. The string resources for the controls 4208a,b,c in the MyForm form 4206 are stored in a text file called MyProject. text 4210, which includes the name of each child control (myform.caption, myform.buttonl .text, and so forth) and its corresponding value ("OK," "Cancel," and so forth). The MyProject.text file 4210 is compiled into a resource file MyProject.resources 4212 by a resource generator, such as resgen.exe. The NewWinForm base class 4204 automatically detects all controls in each child form, such as the MyForm form 4206, and sets their respective text properties using the corresponding string resource in the MyProject.resources resource file 4212.

[000141] Each control 4208 in the MyForm form 4206 is mapped to a corresponding resource in the MyProject.resources resource file 4212 as shown in FIG. 20. The MyProject.resources file 4212 does not have to be located in the same folder as the assembly 4100, because the locations of the file resources are read from the registry 4108 based on the culture information 4106. For example, the resources for the MyProject assembly 4100 may be found in a file named myproject.fr.resources if the operating system on which the assembly 4100 is running is in the French language. Similarly, the resources for the MyProject assembly 4100 may be found in a file named myproject.de.resources if the operating system on which the assembly 4100 is running is in the German language. When the culture information 4106 informs the NewResourceManager class 4102 that the operating system is in the French language, the resource file selected is myproject.fr.resources. The resource file name is automatically generated by inserting the ".fr" extension into the file name. To translate the string resources in all of the controls in the assembly 4100 from French to German, only the resource text file corresponding to myprojectfr.resources needs to be provided to the French-German translator who translates each string accordingly. The assembly 4100 does not need to be recompiled in order for the text strings displayed on the MyForm form 4206 to appear in the German language instead of the French language. Only the German version of the text file corresponding to the French resource text file needs to be compiled into a corresponding resource file, such as myproject.de.resources and saved in the resource folder containing German-language resources. When the assembly 4100 is run on a German operating system, the assembly 4100 will automatically pull the resources from the myproject.de.resources file without any modification to the source code of the assembly 4100.

[000142] The mapping scheme shown in FIG. 20 allows the NewWinForm base class 4204 to extract the appropriate string resource for each control 4208 by reading from the MyProject.resources resource file 4212.

[000143] FIG. 21 is a flow chart diagram of a method of identifying missing string resources from a resource file (4400). The assembly 4100 opens a form with the NewWinForm class 4204 (4402), which inherits the standard .NET framework form class. The NewWinForm class 4204 examines each control on the form to determine whether the control has a text component (for example, a text box will include a text component that has a value or text string associated with it). For each such control, the NewWinForm class 4204 requests from the NewResourceManager class 4102 a string resource corresponding to a first control on the form in question (4404). The NewResourceManager class 4102 determines the location of the resource file that includes the first control and its associated string resource based on the resource folder information stored in the registry 4108 and the culture information 4106 (4406). The NewResourceManager class 4102 requests the string resource from the located resource file. If the control exists in the resource file (4410), the string resource for that control is loaded (4412) and the assembly 4100 proceeds to the next control (4416).

[000144] If the control in question does not exist in the located resource file (i.e., the control is missing) (4410) or if no corresponding string resource is found for the control (i.e., the control is orphaned), the NewWinForm class 4204 adds the name of the missing or orphaned control (along with its associated form name) to a text file, such as missingresource.txt. For example, in FIG. 19, there is no string resource or value associated with the control myform.textboxl .text, and therefore, the name of that control would be added to missingresource.txt. The software developer can quickly determine from viewing the missingresource.txt file all of the orphaned controls that do not have any string resources (values) associated with them.

[000145] In the case of a new translation, when the assembly 4100 is executed on an operating system in a new human language, for example, Swedish, then all of the controls for the form in question will be listed on the missingresource.txt file because the NewResourceManager class 4102 will not find any localized resource file for the controls on that form and will default to a standard-language resource file, such as English. The translator can be provided this missingresource.txt file and can populate the missing controls with the appropriate string resources in the target human language — in this example Swedish. All this can be done without having to recompile the assembly 4100 or provide any binary assembly files to the translator. After the translator provides all the missing string resources in the target human language, the software developer simply names the text file appropriately and converts it to a resource file using a resource generator application such as resgen.exe. During install, the "Swedish" resource file(s) would be saved in the folder that is specified in the registry 4108. [000146] If there are more controls on the form in question to be iterated through (4416), the NewWinForm class 4204 requests the string resource for the next control on the form from the NewResourceManager class 4102, which in turn requests the string resource from the appropriate resource file in the appropriate resource folder based on the resource folder information in the registry 4108 and the human language ID in the culture information 4106 (4418).

^■ [000147] The software developer can open the MissingResource.txt file and quickly determine which string resources are missing. The MissingResource.txt file also provides instant notification to the software developer of embedded strings within a project, which decreases localization bugs when, for example, testing the assembly 4100 for different human languages. No longer does the software developer have to write separate code to pull strings from a resource file, an endeavor that was compounded for user-interface components that had complex layouts and required many resources. With the present invention, controls on a form are automatically populated with the appropriate text strings that can be located in any folder, and any missing controls are automatically added to a text file that logs the name of the control.

[000148] For example, if a resource file has been generated for the English language only, and it is desired for the assembly 4100 to run on a French operating system,. only a French-language resource file needs to be developed; no recompiling of the assembly 4100 would be necessary. When the assembly 4100 is run on a French operating system, the NewResourceManager 4102 will not open the proper resource file because the culture information (French) will direct the NewResourceManager 4102 to look for a filename comprising the French extension (.fr, for example), which will not exist. A missing resource text file will be created (such as MissingResource.txt discussed in connection with FIG. 21) that will include all of the controls on any given form. This missing resource text file can be provided to a translator, for example, who simply adds the values (text strings) for each control in the French language. The present invention ensures that no controls will be overlooked or mistyped during the translation process, because they will be automatically populated in a text file created by the assembly 4100. Optionally, the English-language values (text strings) corresponding to each control may be included in the missing resource text file, and the translator would translate the English-language values into corresponding French-language values. [000149] The French-language resource text file is converted into a resource file using a resource generator, and then it is saved in a folder whose location information is saved to the registry 4108. When the assembly 4100 is now run on a French operating system, the same assembly 4100 without any modifications to its source code will automatically pull the resources from the French-language resource file (such as Assembly Resource File B 4112) as opposed to the English-language resource file (such as Assembly Resource File A 41 10).

[000150] FIG. 22 is a flow chart of a globalization method (4500) of releasing an assembly in multiple languages without having to recompile the assembly as a result of translations into the target languages. As used herein, an assembly may include one or multiple assemblies (such as one or more process assemblies and one or more DLLs). The assembly 4100 is developed based on a default culture (4502), such as English. The assembly 4100 is programmed using the NewResourceManager class 4102 and the NewWinForm class 4204. Each form in the assembly 4100 is based on the NewWinForm class 4204. Resources that populate the controls on the forms in the assembly 4100 are returned (if located) by the NewResourceManager class 4102 in response to requests from the NewWinForm class 4204 for the requested resources.

[000151] The resource file(s) 41 10, 4112 for the assembly 4100 are compiled from text files that include the string resources in the default language (English) for the assembly 4100 (4504). The assembly 4100 together with the resource file(s) 4110, 4112 are released for the default language (English) (4506). A text list (generated by the NewWinForm class 4204) of string resources from the resource files is provided to one or more translators (4508). The text list includes a list of the names of the forms along with the names of their associated controls for which a resource value is missing for the target culture language. No binaries need to be provided to the translators.

[000152] After the text lists have been translated, they are received for one or more different cultures, such as for example, French and Spanish (4510). The translated text Iist(s) are converted into corresponding resource file(s) (4512) by a resource generator such as resgen.exe. The new resource file(s) 4114 are released without recompiling the assembly 4100 as a result of the translations (4514) and without releasing any new or modified configuration files for the assembly 4100. This means that the assembly 4100 may be recompiled for other reasons before being released, but not by reason of the translations of the string resources from one culture to another. In other words, the translations do not necessitate any recompiling of the assembly 4100; only the new resource files need to be compiled from the translated text files containing the string resources in the target human language. In this manner, any software application according to the present invention can be readily globalized into any human language, even after release in a first set of human languages, without requiring any recompiling of the assembly 4100.

[000153] In another embodiment, the assembly 4100 is released for all cultures after all resources files have been translated into the target human languages. Development of resources for a new culture, however, does not necessitate any recompiling of the assembly 4100 in accordance with the present invention. The new resource files can be created independently of the assembly 4100 without modifying any source code in the assembly 4100.

[000154] The embodiments of the present invention can be applied to any assembly that requires its string resources to be translated into multiple languages. In particular, embodiments of the present invention are applied to assemblies for use in monitoring systems that monitor measurable quantities of a utility, including water, air, gas, energy, steam (collectively abbreviated as WAGES), and weather. For example, embodiments of the present invention can be applied to the PowerLogic® System Manager Software™, Billing Module, Interactive Graphics Module, PCS Powerlink G3 Software, or Active Pager Module commercially available from Square D Company. These software applications and modules are very complex and benefit greatly from the aspects of the present invention described herein.

[000155] While particular embodiments and applications of the present invention have been illustrated and described, it is to be understood that the invention is not limited to the precise construction and compositions disclosed herein and that various modifications, changes, and variations may be apparent from the foregoing descriptions without departing from the spirit and scope of the invention as defined in the appended claims. ALTERNATIVE EMBODIMENT Al

[000156] A method of auto-discovering information associated with devices arranged in a monitoring system that monitors measurable quantities of a utility, comprising: receiving configuration information from a local computer in the monitoring system at a server, the local computer attempting to send a data packet associated with a device to the server; determining from the configuration information whether the local computer is approved to have the data packet accepted by the server, the determining including comparing the configuration information against system configuration stored in the server; throwing from the server to the local computer an exception indicating that the configuration information includes information not recognized by the server; responsive to the determining, if the local computer is approved, determining whether the device is approved to have the data packet accepted by the server; and responsive to the determining, if the local computer is not approved, automatically approving the local computer by updating the system configuration with the configuration information. ALTERNATIVE EMBODIMENT A2

[000157] The method of alternative embodiment AI, further comprising queuing the data packet in the local computer until the data packet is accepted by the server. ALTERNATIVE EMBODIMENT A3

[000158] The method of alternative embodiment Al, further comprising queuing the data packet in the server until the data packet is accepted by the server. ALTERNATIVE EMBODIMENT A4

[000159] The method of alternative embodiment Al, wherein the exception is selected from among a plurality of exception types, each exception type indicating that information which is required by the server to approve the device. ALTERNATIVE EMBODIMENT A5

[000160] The method of alternative embodiment Al₅ wherein the receiving is carried out behind a firewall imposed between the local computer and the server, the throwing including throwing from the server to the device the exception through the firewall. ALTERNATIVE EMBODIMENT A6

[000161 ] The method of alternative embodiment Al , wherein the utility is selected from the group consisting of water, air, gas, energy, steam, and weather. ALTERNATIVE EMBODIMENT A7

[000162] The method of alternative embodiment A6, wherein the monitoring system is a power monitoring system and the utility is energy. ALTERNATIVE EMBODIMENT A8

[000163] The method of alternative embodiment A7, wherein the data packet includes electrical data. ALTERNATIVE EMBODIMENT A9

[000164] The method of alternative embodiment Al, wherein the local computer includes the server. ALTERNATIVE EMBODIMENT AlO

[000165] The method of alternative embodiment A4, wherein the configuration information includes local computer information, device information, and topic information. ALTERNATIVE EMBODIMENT All

[000166] The method of alternative embodiment AlO, wherein a first exception type indicates that the local computer information is not approved by the server. ALTERNATIVE EMBODIMENT A12

[000167] The method of alternative embodiment AlO, wherein a first exception type indicates that the device information is not approved by the server. ALTERNATIVE EMBODIMENT A13

[000168] The method of alternative embodiment AlO, wherein a first exception type indicates that the topic information is not approved by the server. ALTERNATIVE EMBODIMENT A14

[000169] The method of alternative embodiment A 13 , wherein the topic information is a topic that relates to an electrical characteristic. ALTERNATIVE EMBODIMENT A15

[000170] The method of alternative embodiment Al, wherein the data packet includes identification information, the method further comprising: determining from the identification information whether the device is approved to have the data packet accepted by the server; if the device is approved, accepting the data packet at the server and storing the data packet in a database of the server; and if the device is not approved, throwing an exception from the server to the local computer, the exception indicating which identification information is required by the server to accept the data packet, and automatically approving the device. ALTERNATIVE EMBODIMENT A16

[000171] The method of alternative embodiment A15, further comprising: queuing the data packet in a queue of the local computer; responsive to the device not being approved and automatically approving the device, receiving the data packet from the queue and storing the data packet in the database. ALTERNATIVE EMBODIMENT A17

[000172] A method of automatically approving the acceptance of data packets at a server in a power monitoring system, comprising: receiving configuration information at a server from a computer, the computer attempting to publish a data packet associated with an electrical monitoring device in the power monitoring system, the data packet including data indicative of a measured electrical characteristic and identification information; throwing an exception from the server to the computer in response to the server not recognizing some or all of the configuration information; automatically approving at least some of the unrecognized configuration information; and sending the data packet until the server accepts the data packet. ALTERNATIVE EMBODIMENT A18

[000173] The method of alternative embodiment Al 7, wherein the sending includes queuing the data packet in the local computer or the server until the server accepts the data packet. ALTERNATIVE EMBODIMENT A19

[000174] A computer readable storage medium encoded with instructions for directing a controller to perform the method of alternative embodiment A 17. ALTERNATIVE EMBODIMENT A20

[000175] The method of alternative embodiment A 17, wherein the exception is selected from among a plurality of exception types, each exception type indicating a different type of configuration information that is required by the server. ALTERNATIVE EMBODIMENT A21

[000176] The method of alternative embodiment A 17, wherein the configuration information is information relating to the local computer. ALTERNATIVE EMBODIMENT A22

[000177] The method of alternative embodiment A 17, wherein the configuration information is information relating to the device. ALTERNATIVE EMBODIMENT A23

[000178] The method of alternative embodiment A17, wherein the identification information includes information relating to at least the identity of the originator of the data packet, the computer, and the device. ALTERNATIVE EMBODIMENT Bl

[000179] A method for loading a plurality of dynamically linked assemblies during the execution of an application program, comprising: reading, by the application program, a configuration file that includes a load sequence for the plurality of dynamically linked assemblies and a class associated with each dynamically linked assembly; loading the plurality of dynamically linked assemblies in accordance with the load sequence read from the configuration file, each class having a common dataset, each of the plurality of dynamically linked assemblies being independent from the other of the plurality of dynamically linked assemblies; and sending a process request defined by the associated class to at least a first of the plurality of dynamically linked assemblies. ALTERNATIVE EMBODIMENT B2

[000180] The method of alternative embodiment Bl, wherein the loading the plurality of dynamically linked assemblies is carried out prior to the sending the process request. ALTERNATIVE EMBODIMENT B3

[000181] The method of alternative embodiment Bl, further comprising storing the configuration file independently from the application program. ALTERNATIVE EMBODIMENT B4

[000182] The method of alternative embodiment Bl, further comprising creating the configuration file in an extensible markup language format. ALTERNATIVE EMBODIMENT B5

[000183] The method of alternative embodiment Bl, further comprising, modifying the load sequence of the plurality of dynamically linked assemblies without modifying the application program as a result of the modifying the load sequence. ALTERNATIVE EMBODIMENT B6

[000184] The method of alternative embodiment B5, wherein the modifying includes adding a at least one dynamically linked assembly to the plurality of dynamically linked assemblies. ALTERNATIVE EMBODIMENT B7

[000185] The method of alternative embodiment B5, wherein the modifying includes rearranging the load sequence of the plurality of dynamically linked assemblies. ALTERNATIVE EMBODIMENT B8

[000186] The method of alternative embodiment Bl₅ wherein the reading is carried out under the control of a computer coupled to a power monitoring system. ALTERNATIVE EMBODIMENT B9

[000187] The method of alternative embodiment Bl, wherein the plurality of dynamically linked assemblies are dynamically linked libraries. ALTERNATIVE EMBODIMENT BlO

[000188] A computer readable storage medium encoded with instructions for directing a controller to perform the method of alternative embodiment Bl. ALTERNATIVE EMBODIMENT BIl

[000189] A method for manipulating data from a power-monitoring database with an application program, the method comprising: reading, by the application program, a configuration file to determine a process order for a plurality of dynamically linked libraries and to determine a respective class associated with each of the plurality of dynamically linked libraries; loading the plurality of dynamically linked libraries in accordance with the process order, each class of the plurality of dynamically linked libraries having an associated common dataset; responsive to the loading, sending a process request to at least a first of the plurality of dynamically linked libraries in accordance with the process order to cause the first of the plurality of dynamically linked libraries to be executed. ALTERNATIVE EMBODIMENT B12

[000190] The method of alternative embodiment BI l, further comprising storing the configuration file independently from the application program.. ALTERNATIVE EMBODIMENT B13

[000191] The method of alternative embodiment BI l, further comprising creating the configuration file in an extensible markup language format. ALTERNATIVE EMBODIMENT B14

[000192] The method of alternative embodiment BI l, further comprising, modifying the configuration file to change the process order of the plurality of dynamically linked libraries without recompiling the application program as a result of the modifying. ALTERNATIVE EMBODIMENT BlS

[000193] The method of alternative embodiment B 14, wherein the modifying includes adding at least one additional dynamically linked library to the plurality of dynamically linked libraries. ALTERNATIVE EMBODIMENT B16

[000194] The method of alternative embodiment B 14, wherein the modifying includes rearranging the process order of the plurality of dynamically linked libraries. ALTERNATIVE EMBODIMENT B17

[000195] The method of alternative embodiment BI l, wherein the configuration file includes an assembly name for each of the plurality of dynamically linked processors, the process order for the plurality of named dynamically linked processors, and the class associated with each of the plurality of dynamically linked processors. ALTERNATIVE EMBODIMENT B18

[000196] The method of alternative embodiment BI l, wherein the common dataset for each class of the plurality of dynamically linked libraries is a dataset defined by the .NET framework. ALTERNATIVE EMBODIMENT B19

[000197] A computer readable storage medium encoded with instructions for directing a controller to perform the method of alternative embodiment BI l. ALTERNATIVE EMBODIMENT B20

[000198] The method of alternative embodiment BI l₅ wherein the power-monitoring database is coupled to and receives data from power monitoring devices. ALTERNATIVE EMBODIMENT Cl

[000199] A method of decoupling resource files from an assembly, comprising: providing an assembly that is executable by a computer, the assembly including forms having associated resources, the forms being defined by a form class, the resources being managed by a resource manager class; and defining a resource manager class that: obtains culture information indicating a human language of an operating system running on the computer, reads resource folder information from a registry external to the assembly, the resource folder information indicating a location of at least one resource file, and searches the resource folder for a culture-specific resource file having a filename based on the culture information. ALTERNATIVE EMBODIMENT C2

[000200] The method of alternative embodiment Cl , further comprising: defining a form class that: for at least some controls on a form, requests from the resource manager class a resource associated with each of the at least some controls, and if the resource manager class returns an indication that the control or the associated resource does not exist, adds the name of the missing control and the name of its associated form to a file; and determining, from the resource manager class, whether the requested control exists in the resource file. ALTERNATIVE EMBODIMENT C3

[000201] The method of alternative embodiment C2, wherein the computer is coupled to a monitoring system that monitors measurable quantities of a utility. ALTERNATIVE EMBODIMENT C4

[000202] The method of alternative embodiment C3, wherein the utility is selected from the group consisting of water, air, gas, energy, steam, and weather. ALTERNATIVE EMBODIMENT C5

[000203] The method of alternative embodiment C4, wherein the monitoring system is a power monitoring system. ALTERNATIVE EMBODIMENT C6

[000204] A computer readable storage medium encoded with instructions for directing a controller to perform the method of alternative embodiment Cl. ALTERNATIVE EMBODIMENT C7

[000205] The method of alternative embodiment Cl, wherein the assembly is developed in accordance with the .NET framework. ALTERNATIVE EMBODIMENT C8

[000206] The method of alternative embodiment C7, wherein the form class inherits from the standard form class provided by the .NET framework. ALTERNATIVE EMBODIMENT C9

[000207] The method of alternative embodiment C7, wherein the resource manager class further creates an instance of the standard resource manager provided by the .NET framework. ALTERNATIVE EMBODIMENT ClO

[000208] The method of alternative embodiment Cl, wherein a change to the resources do not require any recompiling of the assembly. ALTERNATIVE EMBODIMENT CIl

[000209] The method of alternative embodiment C2, further comprising: creating a new resource file having text strings in a different human language from the text strings in the at least one resource file; and reading automatically from the assembly the new resource file without recompiling the assembly to read the new resource file or without creating or modifying any configuration files. ALTERNATIVE EMBODIMENT C12

[000210] The method of alternative embodiment C2, wherein the file is a text file, the method further comprising converting the text file to a resource file. ALTERNATIVE EMBODIMENT C13

[000211] The method of alternative embodiment Cl, wherein the operating system is a Windows-based operating system. ALTERNATIVE EMBODIMENT C14

[000212] The method of alternative embodiment Cl, further comprising storing the at least one resource file in a folder different from the folder in which the assembly is stored. ALTERNATIVE EMBODIMENT C15

[000213] A globalization method, comprising: providing an assembly that is executable by a computer in a monitoring system that monitors measurable quantities of a utility, the assembly being programmed in accordance with a .NET framework; defining a globalization resource manager class within the .NET framework, which: creates an instance of a default resource manager in the .NET framework, reads, from a registry external to the assembly, resource folder information indicating the location of at least one resource file, identifies a culture of the operating system on which the assembly is running, the culture including a human language, and specifies a resource file having a name based on at least the culture and a location based on at least the resource folder information; and defining a globalization form class within the .NET framework, which: identifies at least some controls on a form having a name, determines whether each of the at least some controls includes a text component, if the control of the at least some controls includes a text component, for each such control, requests from the globalization resource manager class the value corresponding to text component associated with such control, and stores the name of the form and the name of such control in a text file when the globalization resource manager class returns no value responsive to the request by the form class, wherein the globalization form class inherits from the default form in the .NET framework. ALTERNATIVE EMBODIMENT CU

[000214] The method of alternative embodiment C 15, further comprising: creating a new resource file having text strings, for the at least some controls that include a text component, the text strings being in a different human language from the human language of the culture; and reading, from the assembly, the text strings in the new resource file without recompiling the assembly as a result of the new resource file or without creating or modifying any configuration files. ALTERNATIVE EMBODIMENT C17

[000215] The method of alternative embodiment Cl 5, further comprising storing the resource file in a folder different from the folder in which the assembly is stored. ALTERNATIVE EMBODIMENT C18

[000216] The method of alternative embodiment C 17, further comprising storing in the registry the folder location of the resource file. ALTERNATIVE EMBODIMENT C19

[000217] The method of alternative embodiment C 17, wherein the monitoring system is a power monitoring system. ALTERNATIVE EMBODIMENT C20

[000218] The method of alternative embodiment C 15, further comprising translating the values corresponding to the text components associated with each of the at least some controls into a human language different from the human language of the culture without recompiling the assembly as a result of the translation. ALTERNATIVE EMBODIMENT C21

[000219] A method of developing an assembly, comprising: developing an assembly displaying string resources in a first human language, the assembly being programmed from source code that includes a globalization resource manager class that obtains culture information from the operating system on which the assembly is running and the folder location of at least one resource file from a registry external to the assembly; compiling the at least one resource file, which includes the string resources; automatically generating a list of controls in the at least one resource file for which there is no associated value in a second human language; providing to a translator the list of controls whose associated string resources are to be translated from the first human language to a second human language; and compiling a new resource file that includes string resources in the second human language, wherein the compiling is carried out without having to recompile the assembly as a result of the providing.

Claims

What Is Claimed Is:

1. A method of partitioning electrical data in a database, comprising: receiving data from a monitoring system that monitors measurable quantities of a utility, the data including time data representing at least the date the monitored data was acquired; creating a plurality of tables in the database, each table being associated with a group and a date that are distinct from every other table in the database; and storing a value of the monitored data in one of the plurality of tables based on at least the group to which the value belongs and the date the value was acquired.

2. The method of claim 1 , further comprising: querying the database for first monitored data belonging to a first group and acquired on a first date; determining whether the first monitored data is present in the database by searching a data catalog stored in the database, the data catalog being logically distinct from the plurality of tables; and responsive to the determining, if the data catalog indicates the presence of the first monitored data, retrieving the first monitored data from the table associated with the first group and the first date.

3. The method of claim 2, further comprising, responsive to the determining, if the data catalog does not indicate the presence of the first monitored data, searching an archive database for the first monitored data based on its associated first group and first date.

4. The method of claim 1, further comprising: storing a set of data retention rules in the database, the rules indicating, for each group with which the tables are associated, a retention date range during which monitored data is stored in the database; and based on the data retention rules, archiving monitored data to an archive database when a date associated with the monitored data to be archived falls outside of the retention date range associated with the group to which the monitored data to be archived belongs.

5. The method of claim 1, if the value of the monitored data does not belong to any group in the database, writing the monitored data received to a table of rejected data.

6. A computer readable storage medium encoded with instructions for directing a controller to perform the method of claim 1.

7. The method of claim 1, wherein the utility is selected from the group consisting of water, air, gas, energy, steam, and weather.

8. The method of claim 1, wherein the monitoring system is a power monitoring system and the utility is energy.

9. The method of claim 8, wherein the monitored data is electrical data.

10. The method of claim 8, wherein the at least one group is a group that includes a plurality of topics that relate to electrical energy.

11. The method of claim 10, wherein the plurality of topics any one or more of real energy, reactive energy, and apparent energy.

12. The method of claim 8, wherein the at least one group is a group that includes a plurality of topics that relate to electrical current.

13. The method of claim 12, wherein the plurality of topics include any one or more of current, average current, and maximum current.

14. The method of claim 8, wherein the at least one group is a group that includes a plurality of characteristics that relate to power quality.

15. The method of claim 14, wherein the plurality of characteristics include any one or more of total harmonic distortion (THD) current, THD voltage, harmonic factor, distortion power factor, total demand distortion, crest factor, and K- factor.

16. The method of claim 8, wherein the at least one group is a group that includes a plurality of electrical measurements that relate to electrical demand.

17. The method of claim 16, wherein the plurality of electrical measurements include any one or more of demand current, K-factor demand, peak demand current, coincident demand, demand power, peak demand power, KW demand, KVAR demand, and KVA demand.

18. A method of archiving electrical data, comprising: creating in a database a plurality of tables, each table being associated with a distinct group and a distinct date relative to all other tables in the database; storing electrical data that includes data corresponding to a group and a date in the corresponding one table associated with that corresponding group and that corresponding date, the electrical data being received from a power monitoring system; providing a set of rules for retaining data in the database, the set of rules indicating on a per group basis the maximum age of data that can be stored in each group; and removing from the database a first table whose data corresponds to a date that exceeds the corresponding maximum age for the group to which the first table belongs as provided in the set of rules.

19. The method of claim 18, further comprising archiving the first table in a data archive.

20. The method of claim 18, wherein the archiving is carried out remote from the database.

21. The method of claim 18, wherein the set of rules are stored in an electrical data retention table in the database.

22. The method of claim 18, further comprising: storing the first table in an archive database; providing an electrical data catalog in the database that includes at least a plurality of entries identifying the tables and their corresponding groups and dates; and responsive to removing from the database the first table, removing from the electrical data catalog the entry corresponding to the first table.

23. The method of claim 22, further comprising: importing from the archive database the first table into the database; and writing into the electrical data catalog an entry corresponding to the first table.

24. A method of auto-discovering information associated with devices arranged in a monitoring system that monitors measurable quantities of a utility, comprising: receiving configuration information from a local computer in the monitoring system at a server, the local computer attempting to send a data packet associated with a device to the server; determining from the configuration information whether the local computer is approved to have the data packet accepted by the server, the determining including comparing the configuration information against system configuration stored in the server; throwing from the server to the local computer an exception indicating that the configuration information includes information not recognized by the server; responsive to the determining, if the local computer is approved, determining whether the device is approved to have the data packet accepted by the server; and responsive to the determining, if the local computer is not approved, automatically approving the local computer by updating the system configuration with the configuration information.

25. The method of claim 24, further comprising queuing the data packet in the local computer until the data packet is accepted by the server.

26. The method of claim 24, further comprising queuing the data packet in the server until the data packet is accepted by the server.

27. The method of claim 24, wherein the exception is selected from among a plurality of exception types, each exception type indicating that information which is required by the server to approve the device.

28. The method of claim 24, wherein the receiving is carried out behind a firewall imposed between the local computer and the server, the throwing including throwing from the server to the device the exception through the firewall.

29. The method of claim 24, wherein the utility is selected from the group consisting of water, air, gas, energy, steam, and weather.

30. The method of claim 29, wherein the monitoring system is a power monitoring system and the utility is energy.

31. The method of claim 30, wherein the data packet includes electrical data.

32. The method of claim 24, wherein the local computer includes the server.

33. The method of claim 27, wherein the configuration information includes local computer information, device information, and topic information.

34. The method of claim 33, wherein a first exception type indicates that the local computer information is not approved by the server.

35. The method of claim 33, wherein a first exception type indicates that the device information is not approved by the server.

36. The method of claim 33, wherein a first exception type indicates that the topic information is not approved by the server.

37. The method of claim 36, wherein the topic information is a topic that relates to an electrical characteristic.

38. The method of claim 24, wherein the data packet includes identification information, the method further comprising: determining from the identification information whether the device is approved to have the data packet accepted by the server; if the device is approved, accepting the data packet at the server and storing the data packet in a database of the server; and if the device is not approved, throwing an exception from the server to the local computer, the exception indicating which identification information is required by the server to accept the data packet, and automatically approving the device.

39. The method of claim 38, further comprising: queuing the data packet in a queue of the local computer; responsive to the device not being approved and automatically approving the device, receiving the data packet from the queue and storing the data packet in the database.

40. A method of automatically approving the acceptance of data packets at a server in a power monitoring system, comprising: receiving configuration information at a server from a computer, the computer attempting to publish a data packet associated with an electrical monitoring device in the power monitoring system, the data packet including data indicative of a measured electrical characteristic and identification information; throwing an exception from the server to the computer in response to the server not recognizing some or all of the configuration information; automatically approving at least some of the unrecognized configuration information; and sending the data packet until the server accepts the data packet.

41. The method of claim 40, wherein the sending includes queuing the data packet in the local computer or the server until the server accepts the data packet.

42. A computer readable storage medium encoded with instructions for directing a controller to perform the method of claim 40.

43. The method of claim 40, wherein the exception is selected from among a plurality of exception types, each exception type indicating a different type of configuration information that is required by the server.

44. The method of claim 40, wherein the configuration information is information relating to the local computer.

45. The method of claim 40, wherein the configuration information is information relating to the device.

46. The method of claim 40, wherein the identification information includes information relating to at least the identity of the originator of the data packet, the computer, and the device.

47. A method for loading a plurality of dynamically linked assemblies during the execution of an application program, comprising: reading, by the application program, a configuration file that includes a load sequence for the plurality of dynamically linked assemblies and a class associated with each dynamically linked assembly; loading the plurality of dynamically linked assemblies in accordance with the load sequence read from the configuration file, each class having a common dataset, each of the plurality of dynamically linked assemblies being independent from the other of the plurality of dynamically linked assemblies; and sending a process request defined by the associated class to at least a first of the plurality of dynamically linked assemblies.

48. The method of claim 47, wherein the loading the plurality of dynamically linked assemblies is carried out prior to the sending the process request.

49. The method of claim 47, further comprising storing the configuration file independently from the application program.

50. The method of claim 47, further comprising creating the configuration file in an extensible markup language format.

51. The method of claim 47, further comprising, modifying the load sequence of the plurality of dynamically linked assemblies without modifying the application program as a result of the modifying the load sequence.

52. The method of claim 51, wherein the modifying includes adding a at least one dynamically linked assembly to the plurality of dynamically linked assemblies.

53. The method of claim 51, wherein the modifying includes rearranging the load sequence of the plurality of dynamically linked assemblies.

54. The method of claim 47, wherein the reading is carried out under the control of a computer coupled to a power monitoring system. s

55. The method of claim 47, wherein the plurality of dynamically linked assemblies are dynamically linked libraries.

56. A computer readable storage medium encoded with instructions for directing a controller to perform the method of claim 47.

57. A method for manipulating data from a power-monitoring database o with an application program, the method comprising: reading, by the application program, a configuration file to determine a process order for a plurality of dynamically linked libraries and to determine a respective class associated with each of the plurality of dynamically linked libraries; loading the plurality of dynamically linked libraries in accordance with the s process order, each class of the plurality of dynamically linked libraries having an associated common dataset; responsive to the loading, sending a process request to at least a first of the plurality of dynamically linked libraries in accordance with the process order to cause the first of the plurality of dynamically linked libraries to be executed. 0

58. The method of claim 57, further comprising storing the configuration file independently from the application program.

59. The method of claim 57, further comprising creating the configuration file in an extensible markup language format.

60. The method of claim 57, further comprising, modifying the 5 configuration file to change the process order of the plurality of dynamically linked libraries without recompiling the application program as a result of the modifying.

61. The method of claim 60, wherein the modifying includes adding at least one additional dynamically linked library to the plurality of dynamically linked libraries. 0

62. The method of claim 60, wherein the modifying includes rearranging the process order of the plurality of dynamically linked libraries.

63. The method of claim 57, wherein the configuration file includes an assembly name for each of the plurality of dynamically linked processors, the process order for the plurality of named dynamically linked processors, and the class associated with each of the plurality of dynamically linked processors.

64. The method of claim 57, wherein the common dataset for each class of the plurality of dynamically linked libraries is a dataset defined by the .NET framework.

65. A computer readable storage medium encoded with instructions for directing a controller to perform the method of claim 57.

66. The method of claim 57, wherein the power-monitoring database is coupled to and receives data from power monitoring devices.

67. A method of decoupling resource files from an assembly, comprising: providing an assembly that is executable by a computer, the assembly including forms having associated resources, the forms being defined by a form class, the resources being managed by a resource manager class; and defining a resource manager class that: obtains culture information indicating a human language of an operating system running on the computer, reads resource folder information from a registry external to the assembly, the resource folder information indicating a location of at least one resource file, and searches the resource folder for a culture-specific resource file having a filename based on the culture information.

68. The method of claim 67, further comprising: defining a form class that: for at least some controls on a form, requests from the resource manager class a resource associated with each of the at least some controls, and if the resource manager class returns an indication that the control or the associated resource does not exist, adds the name of the missing control and the name of its associated form to a file; and determining, from the resource manager class, whether the requested control exists in the resource file.

69. The method of claim 68, wherein the computer is coupled to a monitoring system that monitors measurable quantities of a utility.

70. The method of claim 69, wherein the utility is selected from the group consisting of water, air, gas, energy, steam, and weather.

71. The method of claim 70, wherein the monitoring system is a power monitoring system.

72. A computer readable storage medium encoded with instructions for directing a controller to perform the method of claim 67.

73. The method of claim 67, wherein the assembly is developed in accordance with the .NET framework.

74. The method of claim 73, wherein the form class inherits from the standard form class provided by the .NET framework.

75. The method of claim 73, wherein the resource manager class further creates an instance of the standard resource manager provided by the .NET framework.

76. The method of claim 67, wherein a change to the resources do not require any recompiling of the assembly.

77. The method of claim 68, further comprising: creating a new resource file having text strings in a different human language from the text strings in the at least one resource file; and reading automatically from the assembly the new resource file without recompiling the assembly to read the new resource file or without creating or modifying any configuration files.

78. The method of claim 68, wherein the file is a text file, the method further comprising converting the text file to a resource file.

79. The method of claim 67, wherein the operating system is a Windows- based operating system.

80. The method of claim 67, further comprising storing the at least one resource file in a folder different from the folder in which the assembly is stored.

81. A globalization method, comprising: providing an assembly that is executable by a computer in a monitoring system that monitors measurable quantities of a utility, the assembly being programmed in accordance with a .NET framework; defining a globalization resource manager class within the .NET framework, which: creates an instance of a default resource manager in the .NET framework, reads, from a registry external to the assembly, resource folder information indicating the location of at least one resource file, identifies a culture of the operating system on which the assembly is running, the culture including a human language, and specifies a resource file having a name based on at least the culture and a location based on at least the resource folder information; and defining a globalization form class within the .NET framework, which: identifies at least some controls on a form having a name, determines whether each of the at least some controls includes a text component, if the control of the at least some controls includes a text component, for each such control, requests from the globalization resource manager class the value corresponding to text component associated with such control, and stores the name of the form and the name of such control in a text file when the globalization resource manager class returns no value responsive to the request by the form class, wherein the globalization form class inherits from the default form in the .NET framework.

82. The method of claim 81, further comprising: creating a new resource file having text strings, for the at least some controls that include a text component, the text strings being in a different human language from the human language of the culture; and reading, from the assembly, the text strings in the new resource file without recompiling the assembly as a result of the new resource file or without creating or modifying any configuration files.

83. The method of claim 81, further comprising storing the resource file in a folder different from the folder in which the assembly is stored.

84. The method of claim 83, further comprising storing in the registry the folder location of the resource file.

85. The method of claim 83, wherein the monitoring system is a power monitoring system.

86. The method of claim 81, further comprising translating the values corresponding to the text components associated with each of the at least some controls into a human language different from the human language of the culture without recompiling the assembly as a result of the translation.

87. A method of developing an assembly, comprising: developing an assembly displaying string resources in a first human language, the assembly being programmed from source code that includes a globalization resource manager class that obtains culture information from the operating system on which the assembly is running and the folder location of at least one resource file from a registry external to the assembly; compiling the at least one resource file, which includes the string resources; automatically generating a list of controls in the at least one resource file for which there is no associated value in a second human language; providing to a translator the list of controls whose associated string resources are to be translated from the first human language to a second human language; and compiling a new resource file that includes string resources in the second human language, wherein the compiling is carried out without having to recompile the assembly as a result of the providing.