psse2psat

一个较好的MATLAB潮流程序

#!/usr/bin/perl -w
# PSSE2PSAT converts PSS/E data file into PSAT data file
#
# PSSE2PSAT <OPTIONS> FILEINPUT <FILEOUTPUT>
#
# Author:  Federico Milano
# Date:    19-July-2004
# Version: 1.0.0
#
#E-mail:    [e-mail]
#Web-site:  http://thunderbox.uwaterloo.ca/~fmilano

use strict;

# -----------------------------------------------------------------------
# variable declaration
# -----------------------------------------------------------------------
my $nargin = 0;
my $verbose = 0;
my $helpmsg = 0;
my ($i,$h,$k,$j);
my $format;
my $n = 0;
my $npv = -1;
my $nsw = -1;
my $npq = -1;
my $npl = -1;
my $nsh = -1;
my $ntr = -1;
#my (@idxpv, @idxsw, @idxpq, @idxsh);
my $title1 = 'Generic PSAP Data Format File '.$ARGV[0];
my $title2 = '   ';
my $pbas = 100;
#my $iter = 20;
#my $toler = 0.0001;
my $nbus = -1;
my $nline = -1;
my $narea = -1;
my $flag_bus = 0;
my $flag_line = 0;
my $flag_area = 0;
my $flag_trsf = 0;
my $flag = 1;
my @data;
my (@busidx,@bustype,@busname);
my (@ein,@ang,@pag,@prg,@qmi,@qma,@tap,@pac,@prc,@psh,@qsh,@kae,@kzo,@kvb);	    
my %kvbase;
#my (@busfr,@busto);
#my (@rest,@reat,@susc,@tfas,@tfmi,@tfma,@phsf,@nbci,@cano,@caem,@sbas);	    
my (@areaidx,@areabus,@areaexp,@areaint,@areaname,@areaload,@arealoss);

# -----------------------------------------------------------------------
# check inputs
# -----------------------------------------------------------------------
$nargin = @ARGV;
$nargin || die "Error: No input data file.\n";

# -----------------------------------------------------------------------
# check options
# -----------------------------------------------------------------------
while ($ARGV[0] =~ /^-/) {
    if ($ARGV[0] =~ /v/) {$verbose = 1;}
    if ($ARGV[0] =~ /h/) {$helpmsg = 1;}
    shift(@ARGV);
    $nargin--;
    if ($nargin == 0) { 
	last;
    }
}

# -----------------------------------------------------------------------
# help (if requested)
# -----------------------------------------------------------------------
if ($helpmsg) {
    print "\nPSSE2PSAT converts PSS/E data files into PSAT data files.\n\n";
    print "psse2psat <options> fileinput <fileoutput>\n";
    print "  -v   verbose\n";
    print "  -h   print this help and exit\n\n";
    print "Author:   Federico Milano\n";
    print "Date:     19-July-2004\n";
    print "Version:  1.0.0\n\n";
    print "E-mail:   fmilano\@thunderbox.uwaterloo.ca\n";
    print "Web-site: http://thunderbox.uwaterloo.ca/~fmilano\n";
    die "\n";
}

# -----------------------------------------------------------------------
# define output file name (if necessary)
# -----------------------------------------------------------------------
if ($nargin == 1) {
    $ARGV[1] = $ARGV[0];
    $ARGV[1] =~ s/^/d_/;
    $ARGV[1] =~ s/^d_d/d_/;
    $ARGV[1] =~ s/[^a-zA-Z0-9_\.]/_/g;
    $ARGV[1] =~ s/\..*/.m/;
} elsif ($nargin == 0) {
    die "Error: Input file name is missing.\n";
}

# -----------------------------------------------------------------------
# open input data file
# -----------------------------------------------------------------------
print "Opening PSS/E file \"$ARGV[0]\"...\n";
carret();
open(IN,$ARGV[0]) || die "cannot open $ARGV[0]: $!\n";

# -----------------------------------------------------------------------
# scan input data file
# -----------------------------------------------------------------------

# read identification data

$_ = <IN>;
chomp;
@data = mysplit($_);
if ($data[1]) {$pbas = deblank($data[1]);}  # assign system base

$_ = <IN>;
chomp;
$title1 = $_;  # 1st header line

$_ = <IN>;
chomp;
$title2 = $_;  # 2nd header line

# bus data
my ($swbus,@idxsh,$nisl,@islbus);
$nisl = -1;
while (<IN>) {

    @data = mysplit($_);
    if ($data[0] == 0) { last; }

    $nbus++;
    $busidx[$nbus] = int($data[0]);
    $bustype[$nbus] = $data[3];
    $busname[$nbus] = $data[1];
    $kvb[$nbus] =  $data[2];
    $ein[$nbus] =  $data[8];
    $ang[$nbus] =  0.0175*$data[9];
    $kae[$nbus] =  $data[6];
    $kzo[$nbus] =  $data[7];
    $kvbase{$busidx[$nbus]} = $kvb[$nbus];

    if ($data[3] == 3) { $nsw++; $swbus = $data[0]; }
    if ($data[3] == 4) {
    #printf "Isolated bus " . $data[0] . " will be ignored.\n";
    printf "Bus " . $data[0] . " is an isolated bus.\n";
    #$nbus--;
    #$nisl++;
    #$islbus[$nisl] = int($data[0]);	
    #pop(@busidx);
    #pop(@bustype);
    #pop(@busname);
    #pop(@kvb);
    #pop(@ein);
    #pop(@kae);
    #pop(@kzo);
    #pop(@ang);
    }
    if (($data[4] != 0  || $data[5] != 0) && $data[3] != 4) {
	$nsh++;
	$idxsh[$nsh] = int($data[0]);
	$psh[$nsh] = $data[4]/$pbas;	
	$qsh[$nsh] = $data[5]/$pbas;	
    }
}

# load data
my (@plbus,@plip,@pliq,@plyp,@plyq);
my (@pqbus,@pqpl,@pqql);
while (<IN>) {

    @data = mysplit($_);
    if ($data[0] == 0) { last; }       
    if (isidx(int($data[0]))) {next;}

    $j = pqidx(int($data[0]));
    if ($j) { 
	# add powers if there are multiple 
	# PQ loads at the same bus
	$pqpl[$j] += $data[5]/$pbas;
	$pqql[$j] += $data[6]/$pbas;
    } else {
	$npq++;
	$pqbus[$npq] = int($data[0]);
	$pqpl[$npq] = $data[5]/$pbas;
	$pqql[$npq] = $data[6]/$pbas;	
    }
    if ($data[7] != 0 || $data[8] != 0 || 
	$data[9] != 0 || $data[10] != 0) {	
	$npl++;
	$plbus[$npl] = int($data[0]);
	$plip[$npl] = $data[7]/$pbas;
	$pliq[$npl] = $data[8]/$pbas;
	$plyp[$npl] = $data[9]/$pbas;
	$plyq[$npl] = $data[10]/$pbas;
    }

}

# generator data
my (@pvbus,@pvpg,@pvqt,@pvqb,@pvvs,@pvsb,@pvpt,@pvpb);
my ($swpg,$swqt,$swqb,$swvs,$swsb,$swpt,$swpb);
while (<IN>) {

    @data = mysplit($_);
    if ($data[0] == 0) { last; }    
    if (isidx(int($data[0]))) {next;}
    
    if ($data[0] == $swbus) { 
	$swsb = $data[8];
	if ($swsb == 0) { $swsb = $pbas; }
	$swbus = int($data[0]);
	$swpg = $data[2]/$swsb;
	$swqt = $data[4]/$swsb;
	$swqb = $data[5]/$swsb;
	$swvs = $data[6];
	$swpt = $data[16]/$swsb;
	$swpb = $data[17]/$swsb;
    } else {
	$j = pvidx(int($data[0]));
	if ($j) {
	    # add powers if there are multiple 
	    # PV generators at the same bus
	    $pvpg[$j] += $data[2]/$pvsb[$j];
	    $pvqt[$j] += $data[4]/$pvsb[$j];
	    $pvqb[$j] += $data[5]/$pvsb[$j];
	    $pvpt[$j] += $data[16]/$pvsb[$j];
	    $pvpb[$j] += $data[17]/$pvsb[$j];	    
	} else {
	    $npv++;
	    $pvsb[$npv] = $data[8];
	    if ($pvsb[$npv] == 0) { $pvsb[$npv] = $pbas; }
	    $pvbus[$npv] = int($data[0]);
	    $pvpg[$npv] = $data[2]/$pvsb[$npv];
	    $pvqt[$npv] = $data[4]/$pvsb[$npv];
	    $pvqb[$npv] = $data[5]/$pvsb[$npv];
	    $pvvs[$npv] = $data[6];
	    $pvpt[$npv] = $data[16]/$pvsb[$npv];
	    $pvpb[$npv] = $data[17]/$pvsb[$npv];
	}
    }
}

# branch data
my (@busfr,@bustt);
my (@rest,@reat,@susc,@ratea,@rateb,@ratec,@phas,@lbas,@ratio);	    
while (<IN>) {

    @data = mysplit($_);
    if ($data[0] == 0) { last; }    
    if (isidx(int($data[0])) || isidx(abs($data[1]))) {next;}
    
    $nline++;
    $busfr[$nline] = int($data[0]);
    $bustt[$nline] = abs($data[1]);
    $lbas[$nline] = $pbas;
    $rest[$nline] = $data[3];
    $reat[$nline] = $data[4];
    $susc[$nline] = $data[5];
    $ratio[$nline] = 0;
    $phas[$nline] = 0;
    $ratea[$nline] = $data[6]/$pbas;
    $rateb[$nline] = $data[7]/$pbas;
    $ratec[$nline] = $data[8]/$pbas;

    # additional shunt admittance at "from" bus
    if ($data[9] != 0 || $data[10] != 0) {
	$nsh++;
	$idxsh[$nsh] = int($data[0]);
	$psh[$nsh] = $data[9];	
	$qsh[$nsh] = $data[10];		
    }
    # additional shunt admittance at "to" bus
    if ($data[11] != 0 || $data[12] != 0) {
	$nsh++;
	$idxsh[$nsh] = int($data[1]);
	$psh[$nsh] = $data[11];	
	$qsh[$nsh] = $data[12];		
    }
}

# transformer data
my (@data1,@data2,@data3,@data4,@data5);
my (@bustw1,@bustw2,@bustw3);
my ($ntw,$three_winding);
my (@r12,@r23,@r13,@x12,@x23,@x13,@rt1a,@rt1b,@rt1c,
    @rt2a,@rt2b,@rt2c,@rt3a,@rt3b,@rt3c);
my ($nltc,@ltc_busfr,@ltc_busto,@ltc_busct,@ltc_r,@ltc_dm,
    @ltc_x,@ltc_bas,@ltc_vma,@ltc_vmi,@ltc_ctr,@ltc_ref);
my ($nphs,@phs_busfr,@phs_busto,@phs_r,@phs_x,@phs_bas,
    @phs_vma,@phs_vmi,@phs_ref);
$ntw = -1;
$nltc = -1;
$nphs = -1;
while (1) {

    # read first line
    $three_winding = 0;
    $_ = <IN>;
    chomp;
    @data1 = mysplit($_);

    # check for end of transformer data
    if ($data1[0] == 0) { last; }    

    # read second line
    $_ = <IN>;
    chomp;
    @data2 = mysplit($_);

    # read third line
    $_ = <IN>;
    chomp;
    @data3 = mysplit($_);

    # read fourth line
    $_ = <IN>;
    chomp;
    @data4 = mysplit($_);

    # check for three-winding transformers
    if (int($data1[2]) != 0) {
	$three_winding = 1;
	$_ = <IN>;
	chomp;
	@data5 = mysplit($_);
    }

    if (isidx(int($data1[0])) || isidx(abs($data1[1]))) {next;}

    if ($three_winding == 0) {
	#if (abs($data3[6]) == 0 || abs($data3[6]) == 4) {
	if (1) {
	    # standard transformer
	    $nline++;
	    $ntr++;
	    $busfr[$nline] = int($data1[0]);
	    $bustt[$nline] = int($data1[1]);
	    if (abs($data3[6]) == 4) {
		printf "DC line control for transformer #" . 
		    $ntr . " is ignored.\n";
		}
	    $rest[$nline] = $data2[0];
	    $reat[$nline] = $data2[1];
	    $susc[$nline] = 0;
	    if ($data1[4] == 1) {
		$ratio[$nline] = $data4[0];
	    } else {
		$ratio[$nline] = 1;		
	    }
	    $phas[$nline] = 0.175*$data3[2];
	    if ($data1[5] == 1) {
		$lbas[$nline] = $pbas;
		$ratea[$nline] = $data3[3]/$pbas;
		$rateb[$nline] = $data3[4]/$pbas;
		$ratec[$nline] = $data3[5]/$pbas;
	    } elsif ($data1[5] == 2) {
		$lbas[$nline] = $data2[2];
		$ratea[$nline] = $data3[3]/$data2[2];
		$rateb[$nline] = $data3[4]/$data2[2];
		$ratec[$nline] = $data3[5]/$data2[2];
	    } else {
		$lbas[$nline] = $data2[2];
		if ($data3[1] == 0) {
		    $j = $kvbase{$busfr[$nline]};
		} else {
		    $j = $data3[1];		
		}
		$h = $data2[2]*$data2[2]/3/$j/$j;
		$rest[$nline] = $rest[$nline]/$h;
		$ratea[$nline] = $data3[3]/$data2[2];
		$rateb[$nline] = $data3[4]/$data2[2];
		$ratec[$nline] = $data3[5]/$data2[2];	
	    }    
	} elsif (abs($data3[6]) == 3) {
	    # phase shifting transformer
	    $nphs++;
	    $phs_busfr[$nphs] = int($data1[0]);
	    $phs_busto[$nphs] = int($data1[1]);
	    $phs_r[$nphs] = $data2[0];
	    $phs_x[$nphs] = $data2[1];
	    $phs_vma[$nphs] = 0.175*$data3[8];
	    $phs_vmi[$nphs] = 0.175*$data3[9];
	    if ($data1[5] == 1) {
		$phs_bas[$nphs] = $pbas;
	    } elsif ($data1[5] == 2) {
		$phs_bas[$nphs] = $data2[2];
	    } else {
		$phs_bas[$nphs] = $data2[2];
		if ($data3[1] == 0) {
		    $j = $kvbase{$phs_busfr[$nphs]};
		} else {
		    $j = $data3[1];		
		}
		$h = $data2[2]*$data2[2]/3/$j/$j;
		$phs_r[$nphs] = $phs_r[$nphs]/$h;
	    }   	
	    $phs_ref[$nphs] = 0.5*($data3[10]+$data3[11])/$phs_bas[$nphs];
	} elsif (abs($data3[6]) == 1 || abs($data3[6]) == 2) {
	    # under load tap changer
	    $nltc++;
	    $ltc_busfr[$nltc] = int($data1[0]);
	    $ltc_busto[$nltc] = int($data1[1]);
	    $ltc_busct[$nltc] = int(abs($data3[7]));
	    if ($ltc_busct[$nltc] == 0)
	    {
		$ltc_busct[$nltc] = $ltc_busto[$nltc];	
	    }
	    $ltc_ctr[$nltc] = abs($data3[6]);
	    if ($ltc_busct[$nltc] != $ltc_busfr[$nltc] || 
		$ltc_busct[$nltc] != $ltc_busto[$nltc]) 
	    {
		$ltc_ctr[$nltc] = 3;	    
	    }
	    $ltc_r[$nltc] = $data2[0];
	    $ltc_x[$nltc] = $data2[1];
	    $ltc_vma[$nltc] = $data3[8];
	    $ltc_vmi[$nltc] = $data3[9];
	    if (int($data3[12]) == 0) {
		$ltc_dm[$nltc] = 0;
	    } else {
		$ltc_dm[$nltc] = 0; #($data3[8]-$data3[9])/$data3[12];
	    }
	    $ltc_ref[$nltc] = 0.5*($data3[10]+$data3[11]);
	    if ($data1[5] == 1) {
		$ltc_bas[$nltc] = $pbas;
	    } elsif ($data1[5] == 2) {
		$ltc_bas[$nltc] = $data2[2];
	    } else {
		$ltc_bas[$nltc] = $data2[2];
		if ($data3[1] == 0) {
		    $j = $kvbase{$ltc_busfr[$nltc]};
		} else {
		    $j = $data3[1];		
		}
		$h = $data2[2]*$data2[2]/3/$j/$j;