psse_convert_xfmr

PSSE_CONVERT_XFMR Convert transformer data from PSS/E RAW to MATPOWER
   [XFMR, BUS, WARNINGS] = PSSE_CONVERT_XFMR(WARNINGS, TRANS2, TRANS3, ...
                                   VERBOSE, BASEMVA, BUS)
   [XFMR, BUS, WARNINGS, BUS_NAME] = PSSE_CONVERT_XFMR(WARNINGS, TRANS2, ...
                                   TRANS3, VERBOSE, BASEMVA, BUS, BUS_NAME)

   Convert all transformer data read from a PSS/E RAW data file
   into MATPOWER format. Returns a branch matrix corresponding to
   the transformers and an updated bus matrix, with additional buses
   added for the star points of three winding transformers.

   Inputs:
       WARNINGS :  cell array of strings containing accumulated
                   warning messages
       TRANS2  : matrix of raw two winding transformer data returned
                 by PSSE_READ in data.trans2.num
       TRANS3  : matrix of raw three winding transformer data returned
                 by PSSE_READ in data.trans3.num
       VERBOSE :   1 to display progress info, 0 (default) otherwise
       BASEMVA : system MVA base
       BUS     : MATPOWER bus matrix
       BUS_NAME: (optional) cell array of bus names

   Outputs:
       XFMR    : MATPOWER branch matrix of transformer data
       BUS     : updated MATPOWER bus matrix, with additional buses
                 added for star points of three winding transformers
       WARNINGS :  cell array of strings containing updated accumulated
                   warning messages
       BUS_NAME: (optional) updated cell array of bus names

   See also PSSE_CONVERT.

0001 function [xfmr, bus, warns, bus_name] = psse_convert_xfmr(warns, trans2, trans3, verbose, baseMVA, bus, bus_name)
0002 %PSSE_CONVERT_XFMR Convert transformer data from PSS/E RAW to MATPOWER
0003 %   [XFMR, BUS, WARNINGS] = PSSE_CONVERT_XFMR(WARNINGS, TRANS2, TRANS3, ...
0004 %                                   VERBOSE, BASEMVA, BUS)
0005 %   [XFMR, BUS, WARNINGS, BUS_NAME] = PSSE_CONVERT_XFMR(WARNINGS, TRANS2, ...
0006 %                                   TRANS3, VERBOSE, BASEMVA, BUS, BUS_NAME)
0007 %
0008 %   Convert all transformer data read from a PSS/E RAW data file
0009 %   into MATPOWER format. Returns a branch matrix corresponding to
0010 %   the transformers and an updated bus matrix, with additional buses
0011 %   added for the star points of three winding transformers.
0012 %
0013 %   Inputs:
0014 %       WARNINGS :  cell array of strings containing accumulated
0015 %                   warning messages
0016 %       TRANS2  : matrix of raw two winding transformer data returned
0017 %                 by PSSE_READ in data.trans2.num
0018 %       TRANS3  : matrix of raw three winding transformer data returned
0019 %                 by PSSE_READ in data.trans3.num
0020 %       VERBOSE :   1 to display progress info, 0 (default) otherwise
0021 %       BASEMVA : system MVA base
0022 %       BUS     : MATPOWER bus matrix
0023 %       BUS_NAME: (optional) cell array of bus names
0024 %
0025 %   Outputs:
0026 %       XFMR    : MATPOWER branch matrix of transformer data
0027 %       BUS     : updated MATPOWER bus matrix, with additional buses
0028 %                 added for star points of three winding transformers
0029 %       WARNINGS :  cell array of strings containing updated accumulated
0030 %                   warning messages
0031 %       BUS_NAME: (optional) updated cell array of bus names
0032 %
0033 %   See also PSSE_CONVERT.
0034 
0035 %   MATPOWER
0036 %   $Id: psse_convert_xfmr.m 2370 2014-07-30 16:06:04Z ray $
0037 %   by Yujia Zhu, PSERC ASU
0038 %   and Ray Zimmerman, PSERC Cornell
0039 %   Based on mptransin.m and mptransficbus.m, written by:
0040 %       Yujia Zhu, Jan 2014, yzhu54@asu.edu.
0041 %   Copyright (c) 2014 by Power System Engineering Research Center (PSERC)
0042 %
0043 %   This file is part of MATPOWER.
0044 %   See http://www.pserc.cornell.edu/matpower/ for more info.
0045 %
0046 %   MATPOWER is free software: you can redistribute it and/or modify
0047 %   it under the terms of the GNU General Public License as published
0048 %   by the Free Software Foundation, either version 3 of the License,
0049 %   or (at your option) any later version.
0050 %
0051 %   MATPOWER is distributed in the hope that it will be useful,
0052 %   but WITHOUT ANY WARRANTY; without even the implied warranty of
0053 %   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
0054 %   GNU General Public License for more details.
0055 %
0056 %   You should have received a copy of the GNU General Public License
0057 %   along with MATPOWER. If not, see <http://www.gnu.org/licenses/>.
0058 %
0059 %   Additional permission under GNU GPL version 3 section 7
0060 %
0061 %   If you modify MATPOWER, or any covered work, to interface with
0062 %   other modules (such as MATLAB code and MEX-files) available in a
0063 %   MATLAB(R) or comparable environment containing parts covered
0064 %   under other licensing terms, the licensors of MATPOWER grant
0065 %   you additional permission to convey the resulting work.
0066 
0067 %% define named indices into bus, gen, branch matrices
0068 [PQ, PV, REF, NONE, BUS_I, BUS_TYPE, PD, QD, GS, BS, BUS_AREA, VM, ...
0069     VA, BASE_KV, ZONE, VMAX, VMIN, LAM_P, LAM_Q, MU_VMAX, MU_VMIN] = idx_bus;
0070 [F_BUS, T_BUS, BR_R, BR_X, BR_B, RATE_A, RATE_B, RATE_C, ...
0071     TAP, SHIFT, BR_STATUS, PF, QF, PT, QT, MU_SF, MU_ST, ...
0072     ANGMIN, ANGMAX, MU_ANGMIN, MU_ANGMAX] = idx_brch;
0073 
0074 %% sizes
0075 nb = size(bus, 1);
0076 nt2 = size(trans2, 1);
0077 nt3 = size(trans3, 1);
0078 
0079 %%-----  create fictitious buses for star point of 3 winding transformers  -----
0080 starbus = zeros(nt3, VMIN);     %% initialize additional bus matrix
0081 if nt3 > 0
0082     mb =  max(bus(:, BUS_I));       %% find maximum bus number
0083     b = 10^ceil(log10(mb+1));       %% start new numbers at next order of magnitude
0084     wind1bus = trans3(:,1);         %% winding1 bus number
0085     e2i = sparse(bus(:, BUS_I), ones(nb, 1), 1:nb, max(bus(:, BUS_I)), 1);
0086     starbus(:, BUS_I) = (b+1:b+nt3)';   %% bus numbers follow originals
0087     starbus(:, BUS_TYPE) = PQ;
0088     starbus(trans3(:,12)==0, BUS_TYPE) = NONE;  %% isolated if transformer is off-line
0089     starbus(:, VA) = trans3(:,31);  %% VA = star point voltage angle
0090     starbus(:, VM) = trans3(:,30);  %% VM = star point voltage magnitude (PU)
0091     starbus(:, [BUS_AREA, ZONE]) = bus(e2i(wind1bus), [7,11]); %% wind1 bus area, zone
0092     starbus(:, BASE_KV) = 1;        %% baseKV = 1 kV (RayZ: why?)
0093     starbus(:, VMAX) = 1.1;
0094     starbus(:, VMIN) = 0.9;
0095 end
0096 
0097 %% two winding transformer data
0098 [tf,fbus] = ismember(trans2(:,1), bus(:, BUS_I));      %% I
0099 [tf,tbus] = ismember(trans2(:,2), bus(:, BUS_I));      %% J
0100 %% check for bad bus numbers
0101 k = find(fbus == 0 | tbus == 0);
0102 if ~isempty(k)
0103     warns{end+1} = sprintf('Ignoring %d two-winding transformers with bad bus numbers', length(k));
0104     if verbose
0105         fprintf('WARNING: Ignoring %d two-winding transformers with bad bus numbers', length(k));
0106     end
0107     fbus(k) = [];
0108     tbus(k) = [];
0109     trans2(k, :) = [];
0110     nt2 = nt2 - length(k);
0111 end
0112 Zbs = bus(:, BASE_KV).^2 / baseMVA;     %% system impedance base
0113 if nt2 > 0
0114     cw2 = find(trans2(:,5) == 2);   %% CW = 2
0115     cw3 = find(trans2(:,5) == 3);   %% CW = 3
0116     cw23 = [cw2;cw3];               %% CW = 2 or 3
0117     cz2 = find(trans2(:,6) == 2);   %% CZ = 2
0118     cz3 = find(trans2(:,6) == 3);   %% CZ = 3
0119     cz23 = [cz2;cz3];               %% CZ = 2 or 3
0120 
0121     R = trans2(:,21);
0122     X = trans2(:,22);
0123     Zb = ones(nt2, 1);
0124     Zb(cz23) = trans2(cz23,25).^2 ./ trans2(cz23,23);
0125     R(cz2)  = R(cz2)  .* Zb(cz2)  ./ Zbs(fbus(cz2));
0126     X(cz23) = X(cz23) .* Zb(cz23) ./ Zbs(fbus(cz23));
0127     R(cz3)  = trans2(cz3,25).^2 ./ trans2(cz3,21) ./ Zbs(fbus(cz3));
0128     tap = trans2(:,24) ./ trans2(:,40);
0129     tap(cw23) = tap(cw23) .* bus(tbus(cw23), BASE_KV)./bus(fbus(cw23), BASE_KV);
0130     tap(cw3) = tap(cw3) .* trans2(cw3,25)./trans2(cw3,41);
0131     shift = trans2(:, 26);
0132 end
0133 
0134 %% three winding transformer data
0135 [tf,ind1] = ismember(trans3(:,1), bus(:, BUS_I));
0136 [tf,ind2] = ismember(trans3(:,2), bus(:, BUS_I));
0137 [tf,ind3] = ismember(trans3(:,3), bus(:, BUS_I));
0138 %% check for bad bus numbers
0139 k = find(ind1 == 0 | ind2 == 0 | ind3 == 0);
0140 if ~isempty(k)
0141     warns{end+1} = sprintf('Ignoring %d three-winding transformers with bad bus numbers', length(k));
0142     if verbose
0143         fprintf('WARNING: Ignoring %d three-winding transformers with bad bus numbers', length(k));
0144     end
0145     ind1(k) = [];
0146     ind2(k) = [];
0147     ind3(k) = [];
0148     trans3(k, :) = [];
0149     starbus(k, :) = [];
0150     nt3 = nt3 - length(k);
0151 end
0152 %% Each three winding transformer will be converted into 3 branches:
0153 %% The branches will be in the order of
0154 %% # winding1 -> # winding2
0155 %% # winding2 -> # winding3
0156 %% # winding3 -> # winding1
0157 if nt3 > 0
0158     cw2 = find(trans3(:,5) == 2);   %% CW = 2
0159     cw3 = find(trans3(:,5) == 3);   %% CW = 3
0160     cw23 = [cw2;cw3];               %% CW = 2 or 3
0161     cz2 = find(trans3(:,6) == 2);   %% CZ = 2
0162     cz3 = find(trans3(:,6) == 3);   %% CZ = 3
0163     cz23 = [cz2;cz3];               %% CZ = 2 or 3
0164 
0165     tap1 = trans3(:, 32);   %% off nominal tap ratio of branch 1
0166     tap2 = trans3(:, 48);   %% off nominal tap ratio of branch 2
0167     tap3 = trans3(:, 64);   %% off nominal tap ratio of branch 3
0168     tap1(cw23) = tap1(cw23) ./ bus(ind1(cw23), BASE_KV);
0169     tap2(cw23) = tap2(cw23) ./ bus(ind2(cw23), BASE_KV);
0170     tap3(cw23) = tap3(cw23) ./ bus(ind3(cw23), BASE_KV);
0171     tap1(cw3)  = tap1(cw3)  .* trans3(cw3, 33);
0172     tap2(cw3)  = tap2(cw3)  .* trans3(cw3, 49);
0173     tap3(cw3)  = tap3(cw3)  .* trans3(cw3, 65);
0174     shift1 = trans3(:, 34);
0175     shift2 = trans3(:, 50);
0176     shift3 = trans3(:, 66);
0177 
0178     trans3(cz3, 33) = bus(ind1(cz3), BASE_KV);
0179     trans3(cz3, 49) = bus(ind1(cz3), BASE_KV);
0180     trans3(cz3, 65) = bus(ind1(cz3), BASE_KV);
0181 
0182     R12 = trans3(:, 21);
0183     X12 = trans3(:, 22);
0184     R23 = trans3(:, 24);
0185     X23 = trans3(:, 25);
0186     R31 = trans3(:, 27);
0187     X31 = trans3(:, 28);
0188     Zb1 = trans3(:, 33).^2 ./ trans3(:, 23);
0189     Zb2 = trans3(:, 49).^2 ./ trans3(:, 26);
0190     Zb3 = trans3(:, 65).^2 ./ trans3(:, 29);
0191 
0192     R12(cz2) = R12(cz2) .* Zb1(cz2) ./ Zbs(ind1(cz2));
0193     X12(cz2) = X12(cz2) .* Zb1(cz2) ./ Zbs(ind1(cz2));
0194     R23(cz2) = R23(cz2) .* Zb2(cz2) ./ Zbs(ind2(cz2));
0195     X23(cz2) = X23(cz2) .* Zb2(cz2) ./ Zbs(ind2(cz2));
0196     R31(cz2) = R31(cz2) .* Zb3(cz2) ./ Zbs(ind3(cz2));
0197     X31(cz2) = X31(cz2) .* Zb3(cz2) ./ Zbs(ind3(cz2));
0198 
0199     R12(cz3) = (trans3(cz3,33)*1000) .^ 2 ./ trans3(cz3,21) ./ Zbs(ind1(cz3));
0200     X12(cz3) = trans3(cz3,22) .* Zb1(cz3) ./ Zbs(ind3(cz3));
0201     R23(cz3) = (trans3(cz3,49)*1000) .^ 2 ./ trans3(cz3,24) ./ Zbs(ind2(cz3));
0202     X23(cz3) = trans3(cz3,25) .* Zb2(cz3) ./ Zbs(ind3(cz3));
0203     R31(cz3) = (trans3(cz3,65)*1000) .^ 2 ./ trans3(cz3,27) ./ Zbs(ind3(cz3));
0204     X31(cz3) = trans3(cz3,28) .* Zb3(cz3) ./ Zbs(ind3(cz3));
0205 
0206     R1 = (R12+R31-R23) ./ 2;
0207     R2 = (R12+R23-R31) ./ 2;
0208     R3 = (R31+R23-R12) ./ 2;
0209     X1 = (X12+X31-X23) ./ 2;
0210     X2 = (X12+X23-X31) ./ 2;
0211     X3 = (X31+X23-X12) ./ 2;
0212 end
0213 
0214 %%-----  assemble transformer data into MATPOWER branch format  -----
0215 %%% two winding transformers %%%
0216 xfmr2 = zeros(nt2, ANGMAX);
0217 if nt2 > 0
0218     xfmr2(:, [F_BUS T_BUS]) = trans2(:,[1,2]);
0219     xfmr2(:, [BR_R BR_X TAP SHIFT]) = [R X tap shift];
0220     xfmr2(:, [RATE_A RATE_B RATE_C]) = trans2(:,[27,28,29]);
0221     xfmr2(:, BR_STATUS) = trans2(:,12);
0222     xfmr2(:, ANGMIN) = -360;
0223     xfmr2(:, ANGMAX) = 360;
0224 end
0225 
0226 %%% three winding transformers %%%
0227 xfmr3 = zeros(3*nt3, ANGMAX);
0228 if nt3 > 0
0229     idx1 = (1:3:3*nt3)';        %% indices of winding 1
0230     idx2 = idx1+1;              %% indices of winding 2
0231     idx3 = idx1+2;              %% indices of winding 3
0232     %% bus numbers
0233     xfmr3(idx1, [F_BUS T_BUS]) = [trans3(:,1), starbus(:,1)];
0234     xfmr3(idx2, [F_BUS T_BUS]) = [trans3(:,2), starbus(:,1)];
0235     xfmr3(idx3, [F_BUS T_BUS]) = [trans3(:,3), starbus(:,1)];
0236     %% impedances, tap ratios & phase shifts
0237     xfmr3(idx1, [BR_R BR_X TAP SHIFT]) = [R1 X1 tap1 shift1];
0238     xfmr3(idx2, [BR_R BR_X TAP SHIFT]) = [R2 X2 tap2 shift2];
0239     xfmr3(idx3, [BR_R BR_X TAP SHIFT]) = [R3 X3 tap3 shift3];
0240     %% ratings
0241     xfmr3(idx1, [RATE_A RATE_B RATE_C]) = trans3(:,[35,36,37]);
0242     xfmr3(idx2, [RATE_A RATE_B RATE_C]) = trans3(:,[51,52,53]);
0243     xfmr3(idx3, [RATE_A RATE_B RATE_C]) = trans3(:,[67,68,69]);
0244     xfmr3(:, ANGMIN) = -360;        %% angle limits
0245     xfmr3(:, ANGMAX) =  360;
0246     %% winding status
0247     xfmr3(:, BR_STATUS) = 1;        %% initialize to all in-service
0248     status = trans3(:, 12);
0249     k1 = find(status == 0 | status == 4);   %% winding 1 out-of-service
0250     k2 = find(status == 0 | status == 2);   %% winding 2 out-of-service
0251     k3 = find(status == 0 | status == 3);   %% winding 3 out-of-service
0252     if ~isempty(k1)
0253         xfmr3(idx1(k1), BR_STATUS) = 0;
0254     end
0255     if ~isempty(k2)
0256         xfmr3(idx2(k2), BR_STATUS) = 0;
0257     end
0258     if ~isempty(k3)
0259         xfmr3(idx3(k3), BR_STATUS) = 0;
0260     end
0261 end
0262 
0263 %% combine 2-winding and 3-winding transformer data
0264 xfmr = [xfmr2; xfmr3];
0265 
0266 % %% delete out-of-service windings
0267 % k = find(xfmr(:, BR_STATUS) == 0);
0268 % xfmr(k, :) = [];
0269 % k = find(trans3(:,12) <= 0);
0270 % starbus(k, :) = [];
0271 
0272 %% finish adding the star point bus
0273 bus = [bus; starbus];
0274 if nt3 > 0
0275     warns{end+1} = sprintf('Added buses %d-%d as star-points for 3-winding transformers.', ...
0276         starbus(1, BUS_I), starbus(end, BUS_I));
0277     if verbose
0278         fprintf('Added buses %d-%d as star-points for 3-winding transformers.\n', ...
0279             starbus(1, BUS_I), starbus(end, BUS_I));
0280     end
0281 end
0282 if nargin > 6 && nargout > 3
0283     starbus_name = cell(nt3, 1);
0284     for k = 1:nt3
0285         starbus_name{k} = sprintf('STAR_POINT_XFMR_%d', k);
0286     end
0287     bus_name = [bus_name; starbus_name];
0288 end