Professional Documents
Culture Documents
08 Chapter 3
08 Chapter 3
CHAPTER 3
3.1 INTRODUCTION
U (3.1)
The FOR calculated for a long period of time (e.g. 365 days), is the
same index as the unavailability defined in Equation (3.1). The FOR is a
good approximation for the two-state model. The next step in building a
generation model is to combine the capacity and availability of the individual
unit to estimate available generation in the system. The result of this
combination will be a capacity model, where each generating unit is
represented by its nominal capacity, Ci and its unavailability, Ui (or FOR).
The capacity or the outage capacity, X is considered to be a random variable
in power system reliability analysis. The capacity or outage capacity is
discrete and obeys an exponential distribution. The unit model is the
probability table of a generator unit’s capacity state. The probability model of
a two-state generator model has only two states; in operation or on outage.
There are 2n possible different capacity states. The individual state
probability can be described in Equation (3.3).
1 q x i Ci
P(X x i ) (3.3)
q xi 0
0 xi 0
P(X x i ) q 0 x i Ci (3.4)
q xi Ci
There will be a forced outage rate for every capacity Ci, and the
individual state probability and cumulative state probability are summarized
in Equations (3.5) and (3.6) respectively.
where P (X) and P(X) are the cumulative probability of the capacity outage
state of X MW before and after the unit is added.
60
n
P(X) p i P' (X Ci ) (3.8)
i 1
Loss of load occurs when the system load exceeds the generating
capacity available for use. Loss of Load Probability (LOLP) is a projected
value of how much time, in the long run, the load on a power system is
expected to be greater than the capacity of the available generating resources.
62
pj t j
LOLP P[C A C j ] P[L C j ] (3.9)
j j 100
where P - Probability
L - Expected load
CA - Available generation capacity
Cj - Remaining generation capacity
pj - Probability of capacity outage
tj - Percentage of time when the load exceeds Cj
Capacity outage less than the amount of reserves will not contribute
to a loss of load. When a particular capacity outage is greater than the
reserve, the risk in this case will be pj x tj.
where • T = 365 days (if the load model is an annual continuous load
curve with day maximum load; the LOLE unit is in days per
year)
• T = 8760 hours (if the load model is an hourly load curve; the
LOLE unit is in hours per year)
n n
LOLE Pk t k (t k t k 1 )Pk (3.11)
k 1 k 1
n
LOEE p E (3.12)
K 1 k k
The LOEE can be normalized using the total energy under the load
duration curve as shown in Equation (3.13).
n
LOEE p.u pk E k / E (3.13)
K 1
@Target(value={ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Upload
{
67
String className();
String contextRoot();
String urlPattern();
}
@interface RunAtServer
{
String applicationServer();
}
@interface InputData
{
String powerSystem();
int noOfBuses();
}
@Upload(className="LolpServlet", contextRoot="lolp",
urlPattern="LolpService")
@RunAtServer(applicationServer="tomcat")
@InputData(powerSystem="ieee-rts", noOfBuses=24)
public class AnnotatedClass { }
provider, which is “ieee-rts.xml” data file that represents the power system
data for the IEEE Reliability Test System with 24 buses.
STEP 3.1 : Reading the values associated with the elements of the custom
annotations.
STEP 3.3 : Establish the connection to the service provider and upload the
“lolp.war” file along with the name of the context root and the
identification of the application server.
STEP 3.4: Upload the data file “ieee-rts.xml” for the IEEE Reliability Test
System for 24 Buses to the service provider.
STEP 4 : Creation of server application which will receive the “war” file,
necessary information regarding context root, the data file name
and the data itself in a byte sequence form and will store them in
the appropriate directories of the application server.
The server application has to listen and accept the client request at a
specific port. The code segment of the server application to store the
“lolp.war” file for deployment and the necessary data file in the appropriate
directories on the server side is given in Appendix 2. The server is listening
at port 5000 for reliability estimation service requests from the clients.
Socket s = null;
if(appServer.equals("tomcat")) {
try {
s = new Socket("127.0.0.1", 8080);
}catch(SocketException e) {
Runtime rt = Runtime.getRuntime();
Process p2 = rt.exec("cmd /c start test.bat");
}
}
name is specified in the string ‘contextRoot’ and is ready to listen to the client
requests. Using the contextRoot and urlPattern given in the annotations, i.e.,
‘lolp’ and ‘LolpService’ respectively, the URL to be used to access the
service is “http://localhost:8080/lolp/LolpService”.
services are required. The SOAP response is parsed on the client side and the
attached service is extracted, launched and invoked using a reflective
middleware. Thus the concept of “Reliability Estimation as a Service” is
achieved.
SOAP
Response getService() launchService()
(execute) (download)
<power:lolpService xmlns="http://power">
<power:priority>4</power:priority>
<power:serviceType>execute</power:serviceType>
<generator_system>
<totalcapacity>3405</totalcapacity>
<generator_group>
<groupId>1</groupId>
<unitId>U12</unitId>
<unitType>OilorSteam</unitType>
<numofUnits>5</numofUnits>
<unitSize>12</unitSize>
<forcedOutageRate>0.02</forcedOutageRate>
74
<mttf>2940</mttf>
<mttr>60</mttr>
<scheduledMaintenance>2</scheduledMaintenance>
</generator_group>
</generator_system>
<load_system>
<maximum_load>2850</maximum_load>
<week>
<weekid>1</weekid>
<percentageofpeak>86.2</percentageofpeak>
<actualpeakload>2456.7</actualpeakload>
</week>
</load_system>
</power:lolpService>
For each and every request sent to the server, appropriate message
contexts are created within the SOAP communication model in order to
receive the SOAP request payload from the client and then to send the SOAP
response payload to the requested client. The complete SOAP envelope of
the request sent by the client for launching the service is as follows:
<serviceGroup>
<service name="ReliabilityService">
<description>
Reliability Estimation Service – SOAP with Attachment Model
</description>
<parameter name="enableSwA">true</parameter>
<parameter name="ServiceClass" locked="false">
power.ReliabilityEstimationService
</parameter>
<operation name="launchService">
<actionMapping>urn:launchService</actionMapping>
<messageReceiver
class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
</operation>
</service>
</serviceGroup>
The client sends a SOAP message to the server requesting for the
required service to be launched. The SOAP Envelope for the SOAP request
Message is created using SOAPFactory, as shown below:
The client can retrieve the requested service to be launched using the service
ID in association with the DataHandler. The service class in the form of
binary content is available as SOAP Attachment. Using the service ID, which
has been sent by the ReliabilityService, the DataHandler retrieves the
attachment and provides the requested reliability estimation service to the
client and the code used to retrieve the service class is given below:
href="cid:urn:uuid:72EA2136F948A489CD2393312780553"/>
</swa:lolpServiceResponse>
</soapenv:Body>
</soapenv:Envelope>
The client receives the SOAP response and extracts the reliability
estimation service as byte stream from the attachment as referred by service
ID and stores it in the same name of the service in the location from where the
client application is executing. The client application uses a reflective
middleware for invoking the ‘lolpService()’ service which is encapsulated in
the ‘ReliabilityEstimationService’ class. The code segment of the reflective
middleware to invoke the service is as follows:
Class c = Class.forName("ReliabilityEstimationService");
Object o = c.newInstance();
Object [] objectParameters = { new OMElement("ieee-rts.xml") };
Class [] classParameters = { objectParameters[0].getClass() };
Method m = c.getMethod("lolpService", classParameters);
OMElement element = (OMElement) m.invoke(o, objectParameters);
Power Systems
Service Registry Publish Reliability
Service
Discover Reliability ebXML 2
service and its Registry
Binding information
3
GSR Service Provider
services are Generation System Reliability Services, the WSDL file is termed
as GSRS-WSDL. This is in the form of XML that makes the services
available in the Power Systems Service Registry.
Discovery Layer
ebXML
Reliability service registry Registry
Information Layer
XML- PSR
XMLised XML- PSR
Power system reliability data
Each layer is performing its intended task and interacts with each
other to evaluate the generation system adequacy. The implementation details
of these layers are explained in the following sections.
<definitions name="reliabilityService"
targetnamespace="urn:reliability">
<types>
<schema targetnamespace="urn:reliability"
xmlns:tns="urn:reliability"
xmlns:soap11-enc=
"http://schemas.xmlsoap.org/soap/encoding/">
<doubletype name="estimateLolp">
</doubletype>
<element name="estimateLolp" type="tns:estimateLolp"/>
<element name="computelolpresponse" type ="string"/>
</types>
<message name="lolp_estimateLolp">
<portType name="lolp">
<operation name="estimateLolp">
<input message="tns:lolp_estimateLolp"/>
<output message="tns:lolp_estimateLolpresponse"/>
</operation>
</portType>
<binding name="lolpbinding" type="tns:lolp">
<soap:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document"/>
<operation name="estimateLolp">
<soap:operation soapaction=""/>
<soap:body use="literal"/>
</operation>
</binding>
<service name="reliabilityService">
<port name="lolpPort" binding="tns:lolpbinding">
<soap:address location="replace_with_actual_url"/>
</port>
</service>
</definitions>
transmitted between the client and the service provider. The <portType>
element defines the abstract definition of the operation (estimateLolp) of the
service, request and response messages. The <binding> element specifies a
concrete protocol (SOAP) used for representing messages. The <service>
element represents the service to be invoked over multiple bindings. The
<port> element specifies an address (lolpPort) for binding to the service.
GSRS-WSDL makes the services available in the discovery layer through
power systems service registry.
Reliability Reliability
Service Requesters Service Provider
HTTP HTTP GSR Services
Engine Engine LOLP
SOAP Request
for LOLE
GSR Services
LOEE
SOAP SOAP LOEP
Engine Engine
<SOAP-ENV:Envelope
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/>
< SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/encoding/">
<SOAP-ENV:Header/><SOAP-ENV:Body>
93
<load_system_data>
<week>
<week_id>1</week_id>
<ppl>86.5</ppl>
<apl type="MW">2456.7</apl>
</week>
..........................
< /load_system_data>
94
<env:Envelope
xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:enc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:ns0="urn:Reliability"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<env:Body>
<ns:computeResponse>
<result>
<adequacy_evaluation>
<gsrindices>
<lolp>0.0412</lolp>
<lole>0.1505</lole>
......................
</gsrindices>
</result>
</ns:computeResponse>
</env:Body>
</env:Envelope>
Step 2 : If U1 < FOR (0.01), then unit 1 is deemed to be in the down state
(C1 = 0) otherwise unit 1 is available with full capacity (C1 = 40)
Step 8 : N=N+l
The value for LOLE index obtained using the Monte Carlo
Simulation approach is: 0.159999538 day / year. Due to small value of forced
outage rate is used; the number of samples required may seem to be very large
even for this small sample test system.
<web-app >
<servlet>
<servlet-name>GenerationSystemReliabilityMonteCarlo</servlet-name>
<servlet-class>gsrcloud.GSRServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>GenerationSystemReliabilityMonteCarlo</servlet-name>
<url-pattern>/GSRServlet</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>gsrmontecarlo.jsp</welcome-file>
</welcome-file-list>
</web-app>
version identifier for the latest version of the application. The App Engine
based Web application configuration is given as follows:
<appengine-web-app xmlns="http://appengine.google.com/ns/1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://kenai.com/projects/nbappengine/
download/schema/appengine-web.xsd appengine-web.xsd">
<application>gsrmontecarlo</application>
<version>1</version>
</appengine-web-app>
i.e., Round Trip Time and throughput are estimated and compared for
different power system reliability estimation services using different models
deployed in the Google App Engine, Tomcat Web Server and Sun
Application Server. To reduce the computation time, outage capacities are
rounded to regular intervals so as to reduce the number of states in the
capacity outage probability table. The QoS measures are obtained by varying
the number of requests to the distributed reliability estimation services.
Initially, the reliability estimation services have been implemented using RMI
framework for testing the behaviours. The RMI framework uses the Java
Remote Method Protocol, which in turn uses TCP/IP for its communication.
Through an open port, the RMI client communicates with the RMI server.
Whenever there is a firewall, the communication is blocked which is a major
drawback whenever RMI based applications are to communicate between
different local area networks.
3.9 CONCLUSION