define.cpp

该程序用来实现发输电系统可靠性指标的计算。程序实现中定义的类的功能主要有计算负荷频率指标、形成停用表、并联卷积计算、发电机与负荷并联卷积、串联卷积、计算并输出可靠性指标的结果等。

#include<iostream>
#include<fstream>
#include<vector>
#include<iomanip>
#include<math.h>
#include "define.h"
using namespace std;

Load::Load()
	{
		fstep.open("data_load.txt");
		foutstep.open("load_table.txt");
		int temp1,max=0;
		T=0;
		x=10;
		while(fstep>>temp1)//寻找最大负荷
		{
			T++;
			if (max<temp1) max=temp1;
			load.push_back(temp1);
		}
		num=max/x;
		l=new load_state[num+1];
		for(int i=0;i<=num;i++)
		{
			l[i].num=i;
			l[i].capacity=i*x;
			l[i].time=0;
		}

	}

void Load::compute_probability()//计算负荷概率指标
{
	int i,temp2;
	for(i=0;i<T;i++)//统计各个负荷量出现的次数
	{
		temp2=load[i]/x;
		l[temp2].time++;
	}
	for(i=0;i<num+1;i++)
	{
		l[i].P=l[i].time/1.0/T;
	}
	l[num].PP=l[num].P;//计算累计概率
	for(i=num-1;i>=0;i--)
		l[i].PP=l[i].P+l[i+1].PP;

}

void Load::compute_frequent()//计算负荷频率指标
{
	int *f,*ff,i,k;
	f=new int [num+1];
	ff=new int[num+1];
	for(i=0;i<=num;i++)
		ff[i]=0;
	int NS,NS1;
	NS=load[T-1]/10+0.5;
	i=0;
	do
	{
		NS1=load[i]/10+0.5;
		if (NS1<NS) 
		{   
               k=NS1+1;
			   do
			   {
				   
				ff[k]=ff[k]+1;
				k++;
			   }while(k<=NS);
				   NS=NS1;
		        i++;
		}
		else 
		{  
			 NS=NS1;
			i++;
		}
	
	}while(i<T);
	for(i=0;i<=num;i++)
	{
    l[i].ff=ff[i];
	}
	l[num].f=l[num].ff;//根据累计频率计算增量频率
	for(i=num-1;i>=0;i--)
		l[i].f=l[i].ff-l[i+1].ff;

}
void Load::print()//输出计算结果
{
	foutstep<<setw(10)<<"i"<<setw(10)<<"X(MW)"<<setw(10)<<"time"<<setw(10)<<"P"<<setw(10)<<"PP";
	foutstep<<setw(15)<<"f"<<setw(15)<<"ff"<<endl;
	for(int i=0;i<num+1;i++)
	{
		foutstep<<setw(10)<<l[i].num<<setw(10)<<l[i].capacity<<setw(10)<<l[i].time<<setw(10)<<l[i].P<<setw(10)<<l[i].PP;
		foutstep<<setw(15)<<l[i].f<<setw(15)<<l[i].ff<<endl;
	}
}

form_unit_table::form_unit_table()
{
	fin.open("inputdata.txt");
	fout.open("result.txt");
	fin>>n;
	A=new unit[n];
	b=new unit_table [n];
	x=10;
	count=0;
	for(int i=0;i<n;i++)
	{
		fin>>A[i].capacity>>A[i].fault_rate>>A[i].repair_rate;
		A[i].repair_rate=1.0/A[i].repair_rate;
		A[i].q=A[i].fault_rate;
		A[i].fault_rate=A[i].q*A[i].repair_rate/(1-A[i].q);
		A[i].p=1-A[i].q;
		b[i].num=A[i].capacity/x;
		b[i].a=new unit_state [b[i].num+1];
		make_table(b[i],A[i]);
	}
	fin>>n1;
	T=new unit[n1];
	t=new unit_table[n1];
	for(i=0;i<n1;i++)
	{
		fin>>T[i].capacity>>T[i].fault_rate>>T[i].repair_rate;
		T[i].q=T[i].fault_rate;
		T[i].p=1-T[i].q;
		T[i].repair_rate=1.0/T[i].repair_rate;
		T[i].fault_rate=T[i].q*T[i].repair_rate/(1-T[i].q);
		t[i].num=T[i].capacity/x;
		t[i].a=new unit_state [t[i].num+1];
		make_table(t[i],T[i]);
		
	}
	
}//输入发电机以及线路、变压器的参数





unit_table form_unit_table::make_table(unit_table &S,unit A)//形成停运表
{
	
	for(int i=S.num;i>=0;i--)
	{
		S.a[i].num=i;
		S.a[i].capacity=A.capacity-i*x;
		S.a[i].non_capacity=i*x;
		S.a[i].P=0;
		S.a[i].PP=0;
		if (i==0) 
			S.a[i].P=A.p;
		if (i==S.num) 
			S.a[i].P=A.q;
		if (i==S.num) 
			S.a[i].PP=S.a[i].P;
		else
			S.a[i].PP=S.a[i].P+S.a[i+1].PP;
		S.a[i].up_rate=S.a[i].down_rate=0.0;
		if (i==0) 
		{
			S.a[i].up_rate=0.0;
			S.a[i].down_rate=A.fault_rate;
		}
		if (i==S.num)
		{
			S.a[i].up_rate=A.repair_rate;
			S.a[i].down_rate=0.0;
		}
		S.a[i].f=S.a[i].P*(S.a[i].up_rate-S.a[i].down_rate);
		if (i==S.num)
			S.a[i].ff=S.a[i].f;
		else
			S.a[i].ff=S.a[i].f+S.a[i+1].ff;
		
	}
	
	print(S);
	return S;
}

void form_unit_table::convolve_duration()
{
	b1=b[0];
	for(int i=1;i<n;i++)
	{
		b2=b[i];
		b3=calculate_convolve(b1,b2);
		b1=b3;
	}//三台发电机并联
	b1=t[0];
	for(i=1;i<3;i++)
	{
		b2=t[i];
		b_trans_line=calculate_convolve(b1,b2);
		b1=b_trans_line;
	}//三条输电线路并联
	b_transformer=calculate_convolve(t[3],t[4]);//两台变压器并联等效为一台变压器
	b_1=series(b_trans_line,b_transformer);//等效变压器和输电线路串联
	Load_table();
	system_table();
	b1=b_system;
	b2=series(b1,b_1);
	b_system=calculate_convolve(b2,b_system);//形成最终的A+B系统
    compute_indice();//计算可靠性指标
}

unit_table form_unit_table::calculate_convolve(unit_table b1,unit_table b2)//并联卷积计算
{
	unit_table b3;
	b3.num=b1.num+b2.num;
	b3.a=new unit_state[b3.num+1];
	int capacity;
	capacity=b1.a[0].capacity+b2.a[0].capacity;
	double sum1,sum2;
	for(int i=b3.num;i>=0;i--)
	{
		b3.a[i].num=i;
		b3.a[i].capacity=capacity-i*x;
		b3.a[i].non_capacity=i*x;
		b3.a[i].P=0;
		b3.a[i].f=0;
		b3.a[i].PP=0;
		b3.a[i].ff=0;
		sum1=0.0;
		sum2=0.0;
		for(int j=0;j<=b1.num;j++)
		{
			if (i-j>=0 && i-j<=b2.num)
			{
				sum1=sum1+b1.a[j].P*b2.a[i-j].P;
				sum2=sum2+b1.a[j].P*b2.a[i-j].f+b1.a[j].f*b2.a[i-j].P;
			}
		
		}
		b3.a[i].P=sum1;
		b3.a[i].f=sum2;
	}
	for( i=b3.num;i>=0;i--)
	{
		if (i==b3.num)
		{
			b3.a[i].ff=b3.a[i].f;
			b3.a[i].PP=b3.a[i].P;
		}
		else
		{
			b3.a[i].ff=b3.a[i].f+b3.a[i+1].ff;
			b3.a[i].PP=b3.a[i].P+b3.a[i+1].PP;
			if (fabs(b3.a[i].ff)<0.000000001) b3.a[i].ff=0.0;
		}
	}

	print(b3);
	return b3;
}


void form_unit_table::print(unit_table b)//输出结果;
{
	
	count++;
	fout<<count<<endl;
	fout<<setw(10)<<"i"<<setw(10)<<"X(MW)"<<setw(10)<<"N_X"<<setw(15)<<"确切概率P"<<setw(15)<<"累计概率PP"<<setw(15)<<"增量频率f";
	fout<<setw(15)<<"累计频率ff"<<endl<<endl;
	for(int i=0;i<b.num+1;i++)
	{
		fout<<setw(10)<<b.a[i].num<<setw(10)<<b.a[i].capacity<<setw(10)<<b.a[i].non_capacity<<setw(15)<<b.a[i].P;
		fout<<setw(15)<<b.a[i].PP<<setw(15)<<b.a[i].f<<setw(15)<<b.a[i].ff<<endl;
	}
	fout<<endl<<endl;

}

void form_unit_table::system_table()//发电机与负荷并联卷积
{
	b_system.num=b3.num+B.num;
	b_system.a=new unit_state[b_system.num+1];
	int capacity;
	capacity=b3.a[0].capacity;
	double sum1,sum2;
	for(int i=b_system.num;i>=0;i--)
	{
		b_system.a[i].num=i;
		b_system.a[i].capacity=capacity-i*x;
		b_system.a[i].non_capacity=i*x;
		b_system.a[i].P=0;
		b_system.a[i].f=0;
		b_system.a[i].PP=0;
		b_system.a[i].ff=0;
		sum1=0.0;
		sum2=0.0;
		for(int j=0;j<=b3.num;j++)
		{
			if (i-j>=0 && i-j<=B.num)
			{
				sum1=sum1+b3.a[j].P*B.l[i-j].P;
				sum2=sum2+b3.a[j].P*B.l[i-j].f+b3.a[j].f*B.l[i-j].P;
			}
		
		}
		b_system.a[i].P=sum1;
		b_system.a[i].f=sum2;
	}
	for( i=b_system.num;i>=0;i--)
	{
		if (i==b_system.num)
		{
			b_system.a[i].ff=b_system.a[i].f;
			b_system.a[i].PP=b_system.a[i].P;
		}
		else
		{
			b_system.a[i].ff=b_system.a[i].f+b_system.a[i+1].ff;
			b_system.a[i].PP=b_system.a[i].P+b_system.a[i+1].PP;
			if (fabs(b_system.a[i].ff)<0.000000001) b_system.a[i].ff=0.0;
		}
	}

	print(b_system);
}

unit_table form_unit_table::series(unit_table b1,unit_table b2)//串联卷积计算
{
	unit_table b3,b_temp1,b_temp2;
	int capacity,i;
	if (b1.num<=b2.num)
	{
		b3=b1;
		b1=b2;
		b2=b3;
	}
	
	b3.num=b2.num;
	capacity=b2.a[0].capacity;
	b_temp1.num=b3.num;
	b_temp1.a=new unit_state [b_temp1.num+1];
	for(int j=0;j<=b1.num;j++)
		if (b1.a[j].capacity==0)
		{
			for( i=b2.num;i>0;i--)
			{
				b_temp1.a[i]=b1.a[j];
				j--;
			}
			break;
		}
		b_temp1.a[i].ff=0;
		b_temp1.a[i].PP=1;
		b_temp2=b2;
		
		b3.a=new unit_state [b3.num+1];
		for(i=0;i<=b3.num;i++)
		{
			b3.a[i].PP=b_temp1.a[i].PP+b_temp2.a[i].PP-b_temp1.a[i].PP*b_temp2.a[i].PP;
			b3.a[i].ff=b_temp1.a[i].ff*(1.0-b_temp2.a[i].PP)+b_temp2.a[i].ff*(1-b_temp1.a[i].PP);
			if (fabs(b3.a[i].ff)<0.0000000001) b3.a[i].ff=0.0;
		}
		
		for( i=b3.num;i>=0;i--)
		{
			b3.a[i].capacity=capacity-i*x;
			b3.a[i].non_capacity=i*x;
			b3.a[i].num=i;
			if (i==b3.num)
			{
				b3.a[i].f=b3.a[i].ff;
				b3.a[i].P=b3.a[i].PP;
			}
			else
			{
				b3.a[i].f=b3.a[i].ff-b3.a[i+1].ff;
				b3.a[i].P=b3.a[i].PP-b3.a[i+1].PP;
				
			}
		}
		print(b3);
		return b3;
		
}

void form_unit_table::compute_indice()
{
	for(int i=0;i<b_system.num;i++)
		if(b_system.a[i].capacity<0)
		{
			LOLP=b_system.a[i].PP;
			LOLF=b_system.a[i].ff;
			break;
		}
		EENS=0.0;
	 for(;i<b_system.num;i++)
	 {
		 EENS+=b_system.a[i].capacity*(-1)*b_system.a[i].P;
	 }
	 EENS=EENS*24;
	 D=LOLP/LOLF*24;
	 ofstream out("final indice.txt");
        if(! out)
		{ 
		 cout<<"Cannot open the  file.\n";
         exit(1);
		}
	  out<<"最终可靠性指标"<<endl;
	  out<<"LOLP="<<setw(10)<<LOLP<<endl;
	  out<<"LOLF="<<setw(10)<<LOLF<<"次/天"<<endl;
	  out<<"EENS="<<setw(10)<<EENS<<"MWh"<<endl;
	  out<<"D="<<setw(10)<<D<<"h"<<endl;
	  out.close();
}