digsilent2psat

电力系统分析计算程序

#!/usr/bin/perl -w
# DIGSILENT2PSAT converts DIGSILENT data file into PSAT data file
#
# DIGSILENT2PSAT <OPTIONS> FILEINPUT <FILEOUTPUT>
#
# Author:  Federico Milano
# Date:    12-Dec-2007
# Version: 2.0.0
# 
# E-mail: [e-mail]

use strict;

# -----------------------------------------------------------------------
# variable declaration
# -----------------------------------------------------------------------
my $nargin = 0;
my $verbose = 0;
my $helpmsg = 0;
my ($i,$h,$k,$w,$n,$m);
my $j = 0;
my $pi = 3.141592653589793;
my $checklnesec = 0;
my $ntitle = -1;
my $nbus = -1;
my $nsw = -1;
my $nsyn = -1;
my $nasm = -1;
my $npq = -1;
my $nsh = -1;
my $ntw = -1;
my $nline = -1;
my $nsec = -1;
my $nzo = -1;
my $ntr = -1;
my $nmn = -1;
my $nopv = -1;
my $nopq = -1;
my $nopsyn = -1;
my $nopasm = -1;
my $nopext = -1;
my $noptr = -1;
my $noptw = -1;
my $next = -1;
my $flglne = -1;
my $swpg = 0;
my ($version,$msg,$crd,%card,$format,@data);
my @title;
my $pbas = 100;
my (@busfr,@bustt,@dline,@tline,%uline,%rline,%xline,%bline,%iline);
my (@pqbus,@nload,@tload,@pqpl,@pqql,%kpu,%kqu);
my (@shbus,@qshnt,@pshnt);
my (@sname,@stype,@pvbus,%sbas,%vbas,%xd,%xq,
    %xdsss,%rstr,%xdsat,%satur);
my (@synstt,@opmode,@pvpg,@pvqg,@pvqt,@pvqb,@pvvs);
my (@ename,@exbus,@extstt,@expg,@exqg,@exqt,@exqb,@exvs);
my $swan = 0;
my $tysw;
my (@busidx,@busname,@kvb,@kae,%busnum,%buskvb);
my (@bustfr,@busttt,@ttrasf,%utrasf,%ktrasf,%rtrasf,%xtrasf,
    %phs,%tap,@utr,@ntap,%strasf);
my (@twname,@bustw1,@bustw2,@bustw3,%twname,%twsb,%kv1,%kv2,
    %kv3,%x12,%x31,%x23,%r12,%r23,%r31,%twdu,@utw,@ntaptw);
my (@kzonum,@kzoname,%kzo);
my (@busasm,@tasm,@npasm,%kvasm,%fnasm,$eta,%snasm,@pasm,@uasm,
    $cage,$imode,$cosphi,$ze,$xe,$re,$qn,$sigma,$p,$W0,$Wn,
    %xsasm,%xr1asm,%rr1asm,%xr2asm,%rr2asm,%xmasm,%rsasm);

# -----------------------------------------------------------------------
# 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 "\nDIGSILENT2PSAT converts DIGSILENT data files into PSAT data files.\n\n";
    print "DIGSILENT2psat <options> fileinput <fileoutput>\n";
    print "  -v   verbose\n";
    print "  -h   print this help and exit\n\n";
    print "Author:   Federico Milano\n";
    print "Date:     12-Dec-2007\n";
    print "Version:  2.0.0\n\n";
    print "E-mail:   Federico.Milano\@uclm.es\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/^d_d_/d_/;
    $ARGV[1] =~ s/[^a-zA-Z0-9_\.]/_/g;
    $ARGV[1] =~ s/\..*//;
    $ARGV[1] =~ s/^d__/d_/;
    $ARGV[1] = $ARGV[1] . ".m";
} elsif ($nargin == 0) {
    die "Error: Input file name is missing.\n";
}

# -----------------------------------------------------------------------
# open input data file
# -----------------------------------------------------------------------
print "Scanning DIGSILENT data file \"$ARGV[0]\"...\n";
open(IN,$ARGV[0]) || die "cannot open $ARGV[0]: $!\n";

# -----------------------------------------------------------------------
# scan input data file
# -----------------------------------------------------------------------
$_ = <IN>; # discard first line

# read comments and case information
while (<IN>) {
    chomp;
    $_ =~ s/^\*//g;
    next if !/\d+/;
    last if /^\$\$\w+/; 
    $ntitle++; 
    $title[$ntitle] = $_;
    $title[$ntitle] =~ s/\s+/+/g;
    $title[$ntitle] =~ s/\+/ /g;
}

$crd = $_;
%card = fields();

while (<IN>) {

    chomp;
    next if /^\*/;
    next if /^.$/;
    next if !/\d+/;
    if (/^\$\$\w+/) {
	$crd = $_;
	%card = fields();
	next;
    }
    @data = mysplit($_);

    if ($crd =~ /^\$\$General/) {
	
	if ($data[1] eq "Version") {
	    $data[2] =~ s/\W$//;
	    print "Data Exchange Version " . $data[2] . "\n";
	    $version = $data[2];
	}
	
    } elsif ($crd =~ /^\$\$ElmAsm/) { # read asynchronous motors el. data

	$nasm++;
	$busasm[$nasm] = assign("Station1",);
	$tasm[$nasm] = assign("typ_id",);
	$npasm[$nasm] = assign("ngnum",1);

    } elsif ($crd =~ /^\$\$TypAsm/) {

	$n = assign("Name",);
	$kvasm{$n} = assign("ugn",1);
	$fnasm{$n} = assign("frequ",1);
	$eta = assign("effic",100)/100;
	$cosphi = assign("cosn",1);
	$snasm{$n} = assign("pgn",1000*$pbas)/$cosphi/1000/$eta;
	$imode = assign("i_mode",0);
	if ($imode) { # use electrical parameters
	    $xmasm{$n} = assign("xm",5);
	    $xsasm{$n} = assign("xstr",0.01);
	    $rsasm{$n} = assign("rstr",0.001);
	    $cage = assign("i_cage",1);
	    if ($cage == 1) { # single cage
		$xr1asm{$n} = assign("xrtrA",0.01);
		$rr1asm{$n} = assign("rrtrA",0.001);
		$xr2asm{$n} = 0;
		$rr2asm{$n} = 0;
	    } else { # double cage
		$xr1asm{$n} = assign("x0",0.01);
		$rr1asm{$n} = assign("r0",0.001);
		$xr2asm{$n} = assign("x1",0.01);
		$rr2asm{$n} = assign("r1",0.001);
	    }
	} else { # use slip/torque characteristic
	    $p = assign("nppol",2);
	    $W0 = 2*$pi*$fnasm{$n}/$p;  
	    $Wn = 2*$pi*assign("anend",$W0)/60;
	    $sigma = ($W0-$Wn)/$W0;
	    # locked rotor current: assign("aiazn",)
	    # locked rotor torque:  assign("amazn",)
	    $xe = 0.5/assign("amkzn",2.5);
	    $qn = sin(atan2(sqrt(1-$cosphi**2),$cosphi));
	    $rr1asm{$n} = $sigma;
	    $rsasm{$n} = $rr1asm{$n};
	    $xr1asm{$n} = $xe/2;
	    $xsasm{$n} = $xe/2;
	    $xr2asm{$n} = 0;
	    $rr2asm{$n} = 0;
	    $xmasm{$n} = 1/($qn-$xe/($xe*$xe+($rsasm{$n}+$rr1asm{$n}/$sigma)**2));
	}

    } elsif ($crd =~ /^\$\$OP_ElmAsm/) {

	$nopasm++;
	$pasm[$nopasm] = assign("pgini",0);
	$uasm[$nopasm] = !assign("outserv",0);

    } elsif ($crd =~ /^\$\$ElmLnesec/) { # print warning message
	
	$checklnesec++;
	next if $checklnesec;
	print "WARNING: Line sections are discarded in the current filter.\n";
	
    } elsif ($crd =~ /^\$\$ElmLne/) { # read line element data

	$nline++;
	$busfr[$nline] = assign("Station1",);
	$bustt[$nline] = assign("Station2",);
	$dline[$nline] = assign("dline",1);
	$tline[$nline] = assign("typ_id",);

    } elsif ($crd =~ /^\$\$TypLne/) { # line type data

	$n = assign("Name",);
	$uline{$n} = assign("uline",220);
	$k = $uline{$n}*$uline{$n}/$pbas;
	$rline{$n} = assign("rline",0)/$k;
	$xline{$n} = assign("xline",0)/$k;
	$bline{$n} = 0.0003769911*$k*assign("cline",0); # assuming f = 60 Hz
	$iline{$n} = 1.73205*$uline{$n}*assign("sline",0)/$pbas;

    } elsif ($crd =~ /^\$\$ElmLod/) { # load element data

	$npq++;
	$nload[$npq] = assign("Name",);
	$n = assign("typ_id",);
	$kpu{$n} = 0;
	$kqu{$n} = 0;
	$tload[$npq] = $n;
	$pqbus[$npq] = assign("Station1",);
	
    } elsif ($crd =~ /^\$\$TypLod/) { # load type data

	$n = assign('Name',1);
	$kpu{$n} = assign('kpu',0);
	$kqu{$n} = assign('kqu',0);
	if ($kpu{$n} || $kqu{$n}) {
	    $nmn++;
	}
	
    } elsif ($crd =~ /^\$\$OP_ElmLod/) { # load operational data

	$nopq++;
	$pqpl[$nopq] = assign("plini",0)/$pbas;
	$pqql[$nopq] = assign("qlini",0)/$pbas;
	
    } elsif ($crd =~ /^\$\$ElmShnt/) { # shunt element data

        $nsh++;
        $shbus[$nsh] = assign('Station1',);
        $qshnt[$nsh] = assign('qcapn',0)/$pbas;
        $pshnt[$nsh] = 0;
	
    } elsif ($crd =~ /^\$\$ElmSym/) { # sychronous machine element data

	$nsyn++;
	$sname[$nsyn] = assign("Name",);
	$stype[$nsyn] = assign("typ_id",);
	$pvbus[$nsyn] = assign("Station1",);

    } elsif ($crd =~ /^\$\$ElmXnet/) { # external network element data

	$next++;
	$ename[$next] = assign("Name",);
	$exbus[$next] = assign("Station1",);

    } elsif ($crd =~ /^\$\$OP_ElmXnet/) { # external network operational data

	$nopext++; 
	$extstt[$nopext] = !assign('outserv',0);
	$expg[$nopext] = assign('pgini',0)/$pbas;
	$exqg[$nopext] = assign('qgini',0)/$pbas;
	$exqt[$nopext] = assign('q_min',0);
	$exqb[$nopext] = assign('q_max',0);
	$exvs[$nopext] = assign('usetp',1);

	# assign slack generator
	if ($expg[$nopext] > $swpg || $nopext == 0 || assign("bustp","PV") eq "SL") {
	    $nsw = $nopext;
	    $tysw = "EXT";
	    $swpg = $expg[$nopext];
	    $swan = 0.01745329251994*assign('phiini',0);
	}

    } elsif ($crd =~ /^\$\$TypSym/) { # sinchronous machine type data

	$n = assign("Name",1);
	$sbas{$n} = assign("sgn",100);
	$vbas{$n} = assign("ugn",1);
	$xd{$n} = assign("xd",1.9);
	$xq{$n} = assign("xq",1.7);
	$xdsss{$n} = assign("xdsss",0.204);
	$rstr{$n} = assign("rstr",0);
	$xdsat{$n} = assign("xdsat",0);
	$satur{$n} = assign("satur",0); # Machine IEC909

    } elsif ($crd =~ /^\$\$OP_ElmSym/) { # synchronous machine operational data

	$nopsyn++; 
	$synstt[$nopsyn] = !assign('outserv',0);
	$opmode[$nopsyn] = assign('iv_mode',99);
	$pvpg[$nopsyn] = assign('pgini',0)/$sbas{$stype[$nopsyn]};
	$pvqg[$nopsyn] = assign('qgini',0)/$sbas{$stype[$nopsyn]};
	$pvqt[$nopsyn] = assign('q_min',0);
	$pvqb[$nopsyn] = assign('q_max',0);
	$pvvs[$nopsyn] = assign('usetp',1);

	# assign slack generator
	next if $nopext >= 0;
	if ($pvpg[$nopsyn] > $swpg || $nopsyn == 0) {
	    $nsw = $nopsyn;
	    $tysw = "SYN";
	    $swpg = $pvpg[$nopsyn];
	    $swan = 0;
	}