gat.cpp

该程序是用来计算互联发电系统的可靠性。该系统是由两个发电系统A、B

#include <iostream.h>
#include <math.h>
#include <fstream.h>
#define N0 100//N0为全局变量，开辟对象数组时定义数组的大小，并且开辟空间存放负荷参数，可根据实际情况来改变
int NN;//NN为全局变量，用于系统中存放元件的数目，增加程序的通用性
class load;
class apparatus//元件类，可以生成发电机对象数组，变压器对象数组，线路对象数组
{
public :
	apparatus(){capacity=0;repairrate=0;FOR=0;buchang=10;}////构造函数，分别生成对象发电机，变压器，线路，对其参量进行初始化，
	void put(double c,double r,double f);//输入元件的数据
	void probability();//元件的概率模型
    void frequency();//元件的频率模型
	void display();//显示元件的停运表
	void parallelconnection_ap(int,apparatus ap[N0],apparatus temp[N0],load &ld);//元件并联公式——计算元件的并联，参数分别为
	                                                                             //原件编号，元件对象数组，用于存放并联结果的
	                                                                             //数组，以及负荷对象
    apparatus change_system(apparatus &finalgen,apparatus &b);//发电系统裕度表的修改，最终计算等效支援发电系统时用到
	void parallelconnection_system(apparatus &a,apparatus &b);//系统并联公式——用于计算最终的互联系统
	apparatus serialconnection(apparatus &a,apparatus &b);//串联公式——计算输电系统，以及等效支援系统
private:
	int N;//停运表大小
	double capacity;//容量
	double repairrate;//修复率
	double failurerate;//故障率
	double FOR;//停运率
	double buchang;
    double X[N0];//裕度数组
	double P[N0];//确切概率
	double PP[N0];//累计概率
	double F[N0];//确切频率
	double FF[N0];//累计频率
};
apparatus generator_A[N0],generator_B[N0],transformer[N0],line[N0];//声明元件对象数组
//分别为A系统的发电机对象数组，B系统的发电机对象数组，变压器对象数组，线路对象数组
apparatus tempgen_A[N0],tempgen_B[N0],temptran[N0],templine[N0],tempfinal[N0];//声明并联等效元件
//分别为A系统的并联发电机对象数组，B系统的并联发电机对象数组，并联变压器对象数组，并联线路对象数组
class load
{
public:
	load (){buchang=10;};//构造函数，给步长赋值
	void input(int choose);//负荷的输入函数，选择所要打开的负荷文件，时序负荷赋值，load_0为系统A的负荷，load_1为系统B的负荷
	void probability();//负荷转换函数，将时序负荷转换成负荷概率模型
	void frequency();//负荷的频率模型
	void display();//显示负荷停运表
	friend void apparatus::parallelconnection_ap(int num,apparatus ap[N0],apparatus temp[N0],load &ld);//元件并联公式,声明apparatus中的
	                                       //gl_parallelconnection函数为友元成员函数，参数分别为元件编号，元件对象数组，
	                                       //用于存放并联结果的数组，以及负荷对象
private:
	int T; //负荷功率表大小
	int k;//负荷时段长度
	double timeload[N0];//时序负荷
	double L[N0];//负荷表负荷	
	double buchang;//步长
	double max;//最大负荷
	double appearancetime[N0];//各个负荷持续的时间
	double P[N0];//确切概率
	double PP[N0];//累计概率
	double F[N0];//确切频率
	double FF[N0];//累计频率
	int scan[N0][N0];//负荷频率扫描表
};
void apparatus::put(double c,double r,double f)//apparatus类的构造函数
{
    capacity=c;
	repairrate=r;
	FOR=f;
	N=int(capacity/buchang);
}
void apparatus::probability()//apparatus类的概率模型
{
	P[N]=FOR;//初始化确切频率
	P[0]=1-FOR;
	PP[N]=P[N];
	for(int i=1;i<N;i++) P[i]=0;
	for(i=N-1;i>=0;i--)//求相应编号的裕度以及累计概率
		PP[i]=P[i]+PP[i+1];
	for(i=0;i<=N;i++)
		X[i]=i*buchang;
}
void apparatus::frequency()//apparatus类的频率模型
{
	F[N]=FOR*repairrate;//初始化确切频率
	F[0]=-F[N];
	FF[N]=F[N];
	for(int i=1;i<N;i++) F[i]=0;
	for(i=N-1;i>=0;i--)//求累计频率
		FF[i]=F[i]+FF[i+1];
}
void apparatus::display()//显示元件停运表的函数
{
	cout<<"i   "<<"    -X   "<<"         P      "<<"      PP      "<<"      F      "<<"    FF   "<<endl;
	for(int i=0;i<=N;i++)
		cout<<i<<" "<<X[i]<<" "<<P[i]<<" "<<PP[i]<<" "<<F[i]<<" "<<FF[i]<<endl; 
}
load ld_A,ld_B;//定义两个负荷对象，ld_A,ld_B
void load::input (int choose)//负荷的输入函数，choose为0时为A系统的负荷，choose为1时为B系统的负荷
{
	buchang=10;
	ifstream input;
	if(choose==0) input.open("load_0.txt",ios::in);
	if(choose==1) input.open("load_1.txt",ios::in);
	int i=0;
	while(!input.eof())
	{
		input>>timeload[i];
		i++;
	}
	k=i;//给时序负荷时间段的长度赋值
}
void load::probability()//load类的负荷转换，转换成为概率模型
{
	max=timeload[0];//找出最大负荷
	for(int i=1;i<N0;i++)
		if(timeload[i]>max)  max=timeload[i];
	T=int(max/buchang);//定义负荷功率表大小，并且求出对应的负荷功率
	for(i=0;i<=T;i++)
		L[i]=i*buchang;
	cout<<endl;
	for(i=0;i<=T;i++)//求出各负荷功率出现的确切概率
	{
		appearancetime[i]=0;
		for(int j=0;j<k;j++)
			if(L[i]==timeload[j]) appearancetime[i]++;
		P[i]=appearancetime[i]/k;
	}
	cout<<endl;
	PP[T]=P[T];
	for(i=T-1;i>=0;i--)//求出累计概率
		PP[i]=P[i]+PP[i+1];
}
void load::frequency()//load类的频率模型
{
	int n,m,mi,i,j;
	for(i=0;i<=T;i++)//初始化扫描表，元素均为0
		for(j=0;j<k;j++)
			scan[i][j]=0;
	n=int((timeload[k-1]-timeload[0])/buchang);//初始化扫描表第一列
	m=int(timeload[k-1]/buchang);
	scan[m][0]=int(n/fabs(n));
	for(mi=1;mi<int(fabs(n));mi++)
		scan[m+mi][0]=scan[m][0];
	m=m-n;
	for(j=1;j<=k-1;j++)//形成扫描表的第二列到最后一列
	{
		n=int(timeload[j-1]-timeload[j])/int(buchang);
		if(n<0) 
		{
			for(mi=0;mi<int(fabs(n));mi++)
				scan[m+mi][j]=-1;
		}
		else 
			if(n>0)
			{
				for(mi=0;mi<n;mi++)
					scan[m-mi][j]=1;
			}
			else scan[m][j]=0;
		m=m-n;
	}
	for(i=0;i<=T;i++)  {F[i]=0;FF[i]=0;}
	for(i=0;i<=T;i++)//确切频率
		for(j=0;j<k;j++)
			F[i]=F[i]+scan[i][j];
	FF[T]=F[T];//累计频率
	for(i=T-1;i>=0;i--) 
		FF[i]=FF[i+1]+F[i];
}
void load::display()//显示负荷停运表
{
	cout<<"-----------------------------负荷的停运表----------------------------"<<endl;
	cout<<"i   "<<"   -X   "<<"        P    "<<"       PP       "<<"       F   "<<"        FF   "<<endl;
	for(int i=0;i<=T;i++)
		cout<<i<<" "<<L[i]<<" "<<P[i]<<" "<<PP[i]<<" "<<F[i]<<" "<<FF[i]<<endl; 
}
int input(int choose)//调用文件，choose为0时调用"generator_0.txt"为A系统发电机参数，
//choose为1时调用"generator_1.txt"为B系统发电机参数,choose为2时调用"transformer.txt"为变压器参数
//choose为3时调用"line.txt"为线路参数
{	double a,b,c;
	int i=0;
	ifstream input0,input1,input2,input3;//文件输入对象
	if(choose==0)//choose为0时读入发电机的参数,"generator_0.txt"
	{
		input0.open("generator_0.txt",ios::in);
		while(!input0.eof())
		{
			input0>>a;
			input0>>b;
			input0>>c;
			generator_A[i].put(a,b,c);
			i++;
		}
	}
	if(choose==1)//choose为0时读入发电机的参数,"generator_1.txt"
	{
		input1.open("generator_1.txt",ios::in);
		while(!input1.eof())
		{
			input1>>a;
			input1>>b;
			input1>>c;
			generator_B[i].put(a,b,c);
			i++;
		}
	}
	if(choose==2)//choose为1时读入变压器参数,"transformer.txt"
	{
		input2.open("transformer.txt",ios::in);
		while(!input2.eof())
		{
			input2>>a;
			input2>>b;
			input2>>c;
			transformer[i].put(a,b,c);
			i++;
		}
	}
	if(choose==3)//choose为2时读入线路参数,"line.txt"
	{
		input3.open("line.txt",ios::in);
		while(!input3.eof())
		{
			input3>>a;
			input3>>b;
			input3>>c;
			line[i].put(a,b,c);
			i++;
		}
	}
	return i-1;
	input0.close();
	input1.close();
	input2.close();
	input3.close();
}
void apparatus::parallelconnection_ap(int num,apparatus ap[N0],apparatus temp[N0],load &ld)//apparatus类的并联公式——计算元件的并联
{
	int n1,n2,i,j,k,m;
	n1=int(temp[num].capacity/temp[num].buchang);//等效元件裕度表的数目
	if(num==NN-1)//用num的值来判断是否并联负荷，当num为元件最后一台时，ap[num+1]各成员赋ld的各成员值
	{
		n2=ld.T;//负荷表裕度的数目
		ld.probability();
		ld.frequency();
		ld.display();
		for(i=0;i<=n1+n2;i++)//形成元件停运表的裕度
			temp[num+1].X[i]=(n1-i)*temp[num+1].buchang;
		for(k=0;k<=n1+n2;k++)//确切概率
			for(i=0;i<=n2;i++)
				temp[num+1].P[k]=temp[num+1].P[k]+ld.P[i]*temp[num].P[k-i];
	    temp[num+1].PP[n1+n2]=temp[num+1].P[n1+n2];
	    for(i=n1+n2-1;i>=0;i--)//累计概率
		temp[num+1].PP[i]=temp[num+1].P[i]+temp[num+1].PP[i+1];
		for(m=0;m<=n1+n2;m++)//确切频率
			for(j=0;j<=n2;j++)
				temp[num+1].F[m]=temp[num+1].F[m]+(temp[num].P[m-j]*ld.F[j]+temp[num].F[m-j]*ld.P[j]);
		temp[num+1].FF[n1+n2]=temp[num+1].F[n1+n2];//累积频率
		for(k=n1+n2-1;k>=0;k--)
		temp[num+1].FF[k]=temp[num+1].F[k]+temp[num+1].FF[k+1];		
		cout<<endl<<"-----------------------整个发电系统并联的停运表----------------------"<<endl;
		cout<<"i  "<<"    -X     "<<"         P        "<<"    PP       "<<"    F    "<<"      FF   "<<endl;//输出并联后的停运表
		for(i=0;i<=n1+n2;i++)
			cout<<i<<" "<<temp[num+1].X[i]<<" "<<temp[num+1].P[i]<<" "<<temp[num+1].PP[i]<<" "<<temp[num+1].F[i]<<" "<<temp[num+1].FF[i]<<endl; 
		
		ofstream output;
		output.open("out_paralleconnection.txt");//将发电系统并联结果输入至"out_paralleconnection.txt"文件中
		output<<endl<<"-----------------------整个发电系统并联的停运表----------------------"<<endl;
		output<<"i  "<<"    -X     "<<"         P        "<<"    PP       "<<"    F    "<<"      FF   "<<endl;//输出并联后的停运表
		for(i=0;i<=n1+n2;i++)
			output<<i<<" "<<temp[num+1].X[i]<<" "<<temp[num+1].P[i]<<" "<<temp[num+1].PP[i]<<" "<<temp[num+1].F[i]<<" "<<temp[num+1].FF[i]<<endl; 
	}
	else//当num不为最后一台元件时，不并入负荷