├── 3Bus_networkdata.xls ├── 3bus_measurementdata.xls ├── 6BusCase_ZERO_INJ_BUS6_networkdata.xls ├── 6BusCase_networkdata.xls ├── 6bus_Vand_noAmeas_ZERO_INJ_BUS6_measurementdata.xls ├── 6bus_Vand_noAmeas_measurementdata.xls ├── 6bus_bus1onlypseudos_measurementdata.xls ├── 6bus_buses1and2only_measurementdata.xls ├── DetectandIdentifyBadData.m ├── DetectandIdentifyBadData_Orthogonal.m ├── Estimation_Loop.m ├── Estimation_Orthogonal_Loop.m ├── Loop Through measurements logic.m ├── OldBadDataLogic.m ├── README.md ├── Scadamenu.m ├── State Estimation Chapter from 2nd Edition of Wollenberg Book.pdf ├── StateEstimatorData.mat ├── add_noise.m ├── buildHmatrix.m ├── buildHmatrixOLD.m ├── calculate_residual_and_meas_error.m ├── count_active_measurements.m ├── edit_angle_measurement.m ├── edit_flow_measurement.m ├── edit_injection_measurement.m ├── edit_measurement.m ├── edit_volt_measurement.m ├── force_injection.m ├── force_to_zero.m ├── hey.m ├── measurement_data_template.xls ├── measurement_datainput_Excel.m ├── measurementprint.m ├── network_datainput_Excel.m ├── pfdatainput_Excel.m ├── powerflownewton.m ├── run_all.m ├── run_estimator.m ├── run_estimator_old.m ├── run_estimator_orthogonal.m ├── run_pfnewton.m ├── run_powerflow.m ├── run_scada.m ├── scada_store.m ├── sedatainput_Excel.m ├── testH.m ├── testchi2inv.m ├── testequations.m └── testrandom.m /3Bus_networkdata.xls: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/3Bus_networkdata.xls -------------------------------------------------------------------------------- /3bus_measurementdata.xls: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/3bus_measurementdata.xls -------------------------------------------------------------------------------- /6BusCase_ZERO_INJ_BUS6_networkdata.xls: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/6BusCase_ZERO_INJ_BUS6_networkdata.xls -------------------------------------------------------------------------------- /6BusCase_networkdata.xls: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/6BusCase_networkdata.xls -------------------------------------------------------------------------------- /6bus_Vand_noAmeas_ZERO_INJ_BUS6_measurementdata.xls: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/6bus_Vand_noAmeas_ZERO_INJ_BUS6_measurementdata.xls -------------------------------------------------------------------------------- /6bus_Vand_noAmeas_measurementdata.xls: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/6bus_Vand_noAmeas_measurementdata.xls -------------------------------------------------------------------------------- /6bus_bus1onlypseudos_measurementdata.xls: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/6bus_bus1onlypseudos_measurementdata.xls -------------------------------------------------------------------------------- /6bus_buses1and2only_measurementdata.xls: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/6bus_buses1and2only_measurementdata.xls -------------------------------------------------------------------------------- /DetectandIdentifyBadData.m: -------------------------------------------------------------------------------- 1 | %Begin the detection and Identification Iteration Loop 2 | %num_active_measurements % number of active measuremets 3 | num_states = (2*numbus-1); % number of states 4 | K = num_active_measurements - num_states; % degrees of freedom 5 | %Calculate TJ, the threshold for J(x). 6 | TJ=2*K-chi2inv(alpha,K); 7 | 8 | 9 | fprintf(' %6d %6d %10.3f \n', num_active_measurements, K, TJ ); 10 | 11 | if detect_bad_data == 1 12 | 13 | % Calculate the Residual Standardizd Deviation 14 | Resid_std_dev = sqrt( diag( Rcov - H * inv(H'*inv(Rcov)*H)*H' ) ); 15 | 16 | %Set slack bus diagonals to 1 17 | Resid_std_dev(refbus_Vrow_H) = 1; 18 | Resid_std_dev(refbus_Arow_H) = 1; 19 | 20 | % Calculate the Normalized Residual 21 | Norm_resid = inv( diag(Resid_std_dev) )*meas_error; 22 | 23 | measurement_index = 1; 24 | Largest_Norm_Resid = 0; 25 | % measurement_index 26 | % Voltage Measurements 27 | for i_vmeas = 1:numVmeas 28 | if Vmeasstatus(i_vmeas) == 1 29 | if i ~= refbus 30 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 31 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 32 | Largest_Norm_Resid_Index = i_vmeas; 33 | Largest_Norm_Resid_Type = 'Vmeas'; 34 | end 35 | elseif i == refbus 36 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 37 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 38 | Largest_Norm_Resid_Index = i_vmeas; 39 | Largest_Norm_Resid_Type = 'Vmeas'; 40 | end 41 | end 42 | measurement_index = measurement_index + 1; 43 | end 44 | end 45 | % measurement_index 46 | 47 | % Angle Measurements 48 | for i_ameas = 1:numAmeas 49 | if Ameasstatus(i_ameas) == 1 50 | if i ~= refbus 51 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 52 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 53 | Largest_Norm_Resid_Index = i_ameas; 54 | Largest_Norm_Resid_Type = 'Ameas'; 55 | end 56 | elseif i == refbus 57 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 58 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 59 | Largest_Norm_Resid_Index = i_ameas; 60 | Largest_Norm_Resid_Type = 'Ameas'; 61 | end 62 | end 63 | measurement_index = measurement_index + 1; 64 | end 65 | end 66 | % measurement_index 67 | 68 | % Injection Measurements 69 | 70 | for i_injmeas=1:numImeas 71 | if Imeasbus(i_injmeas) ~= refbus 72 | if Imeasstatus(i_injmeas) == 1 73 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 74 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 75 | Largest_Norm_Resid_Index = i_injmeas; 76 | Largest_Norm_Resid_Type = 'Imeas'; 77 | end 78 | measurement_index = measurement_index + 1; 79 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 80 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 81 | Largest_Norm_Resid_Index = i_injmeas; 82 | Largest_Norm_Resid_Type = 'Imeas'; 83 | end 84 | measurement_index = measurement_index + 1; 85 | end; 86 | end; 87 | end 88 | % measurement_index 89 | 90 | % Flow Measurements 91 | 92 | for i_flowmeas = 1:numFmeas 93 | if Fmeasstatus(i_flowmeas) == 1 94 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 95 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 96 | Largest_Norm_Resid_Index = i_flowmeas; 97 | Largest_Norm_Resid_Type = 'Fmeas'; 98 | end 99 | measurement_index = measurement_index + 1; 100 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 101 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 102 | Largest_Norm_Resid_Index = i_flowmeas; 103 | Largest_Norm_Resid_Type = 'Fmeas'; 104 | end 105 | measurement_index = measurement_index + 1; 106 | end; 107 | end 108 | % measurement_index 109 | 110 | 111 | % Largest_Norm_Resid 112 | % Largest_Norm_Resid_Index 113 | % Largest_Norm_Resid_Type 114 | 115 | % test to see if bad data has been detected 116 | if J > TJ 117 | 118 | switch Largest_Norm_Resid_Type 119 | case 'Vmeas' 120 | j = Largest_Norm_Resid_Index; 121 | fprintf('Bad Data Detected %6.3f %s\n',... 122 | Largest_Norm_Resid, VmeasNAME(j,:) ); 123 | 124 | % disp('Largest error was V Measurement') 125 | Vmeasstatus(Largest_Norm_Resid_Index) = 0; 126 | case 'Ameas' 127 | j = Largest_Norm_Resid_Index; 128 | fprintf('Bad Data Detected %6.3f %s\n',... 129 | Largest_Norm_Resid, AmeasNAME(J,:) ); 130 | %disp('Largest error was A Measurement') 131 | Ameasstatus(Largest_Norm_Resid_Index) = 0; 132 | case 'Imeas' 133 | j = Largest_Norm_Resid_Index; 134 | fprintf('Bad Data Detected %6.3f %s\n',... 135 | Largest_Norm_Resid, ImeasNAME(j,:) ); 136 | %disp('Largest error was Inj Measurement') 137 | Imeasstatus(Largest_Norm_Resid_Index) = 0; 138 | case 'Fmeas' 139 | j = Largest_Norm_Resid_Index; 140 | fprintf('Bad Data Detected %6.3f %s\n',... 141 | Largest_Norm_Resid, FmeasNAME(j,:) ); 142 | %disp('Largest error was Flow Measurement') 143 | Fmeasstatus(Largest_Norm_Resid_Index) = 0; 144 | end 145 | 146 | end 147 | 148 | end -------------------------------------------------------------------------------- /DetectandIdentifyBadData_Orthogonal.m: -------------------------------------------------------------------------------- 1 | %Begin the detection and Identification Iteration Loop 2 | %num_active_measurements % number of active measuremets 3 | num_states = (2*numbus-1); % number of states 4 | K = num_active_measurements - num_states; % degrees of freedom 5 | %Calculate TJ, the threshold for J(x). 6 | TJ=2*K-chi2inv(alpha,K); 7 | 8 | 9 | fprintf(' %6d %6d %10.3f \n', num_active_measurements, K, TJ ); 10 | 11 | if detect_bad_data == 1 12 | 13 | % Calculate the Residual Standardizd Deviation 14 | Resid_std_dev = sqrt( diag( Rcov - H * inv(H'*inv(Rcov)*H)*H' ) ); 15 | 16 | %Set slack bus diagonals to 1 17 | Resid_std_dev(refbus_Vrow_H) = 1; 18 | Resid_std_dev(refbus_Arow_H) = 1; 19 | 20 | % Calculate the Normalized Residual 21 | Norm_resid = inv( diag(Resid_std_dev) )*meas_error; 22 | 23 | measurement_index = 1; 24 | Largest_Norm_Resid = 0; 25 | % Voltage Measurements 26 | for i_vmeas = 1:numVmeas 27 | if Vmeasstatus(i_vmeas) == 1 28 | if i ~= refbus 29 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 30 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 31 | Largest_Norm_Resid_Index = i_vmeas; 32 | Largest_Norm_Resid_Type = 'Vmeas'; 33 | end 34 | end 35 | end 36 | measurement_index = measurement_index + 1; 37 | end 38 | 39 | 40 | % Angle Measurements 41 | for i_ameas = 1:numAmeas 42 | if Ameasstatus(i_ameas) == 1 43 | if i ~= refbus 44 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 45 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 46 | Largest_Norm_Resid_Index = i_ameas; 47 | Largest_Norm_Resid_Type = 'Ameas'; 48 | end 49 | end 50 | end 51 | measurement_index = measurement_index + 1; 52 | end 53 | 54 | 55 | % Injection Measurements 56 | 57 | for i_injmeas=1:numImeas 58 | if Imeasstatus(i_injmeas) == 1 59 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 60 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 61 | Largest_Norm_Resid_Index = i_injmeas; 62 | Largest_Norm_Resid_Type = 'Imeas'; 63 | end 64 | measurement_index = measurement_index + 1; 65 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 66 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 67 | Largest_Norm_Resid_Index = i_injmeas; 68 | Largest_Norm_Resid_Type = 'Imeas'; 69 | end 70 | measurement_index = measurement_index + 1; 71 | else 72 | measurement_index = measurement_index + 2; 73 | end; 74 | end 75 | 76 | 77 | % Flow Measurements 78 | 79 | for i_flowmeas = 1:numFmeas 80 | if Fmeasstatus(i_flowmeas) == 1 81 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 82 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 83 | Largest_Norm_Resid_Index = i_flowmeas; 84 | Largest_Norm_Resid_Type = 'Fmeas'; 85 | end 86 | measurement_index = measurement_index + 1; 87 | if abs(Norm_resid(measurement_index))> Largest_Norm_Resid 88 | Largest_Norm_Resid = abs(Norm_resid(measurement_index)); 89 | Largest_Norm_Resid_Index = i_flowmeas; 90 | Largest_Norm_Resid_Type = 'Fmeas'; 91 | end 92 | measurement_index = measurement_index + 1; 93 | else 94 | measurement_index = measurement_index + 2; 95 | end; 96 | end 97 | 98 | 99 | 100 | % Largest_Norm_Resid 101 | % Largest_Norm_Resid_Index 102 | % Largest_Norm_Resid_Type 103 | 104 | % test to see if bad data has been detected 105 | if J > TJ 106 | 107 | switch Largest_Norm_Resid_Type 108 | case 'Vmeas' 109 | j = Largest_Norm_Resid_Index; 110 | fprintf('Bad Data Detected %6.3f %s\n',... 111 | Largest_Norm_Resid, VmeasNAME(j,:) ); 112 | 113 | % disp('Largest error was V Measurement') 114 | Vmeasstatus(Largest_Norm_Resid_Index) = 0; 115 | case 'Ameas' 116 | j = Largest_Norm_Resid_Index; 117 | fprintf('Bad Data Detected %6.3f %s\n',... 118 | Largest_Norm_Resid, AmeasNAME(J,:) ); 119 | %disp('Largest error was A Measurement') 120 | Ameasstatus(Largest_Norm_Resid_Index) = 0; 121 | case 'Imeas' 122 | j = Largest_Norm_Resid_Index; 123 | fprintf('Bad Data Detected %6.3f %s\n',... 124 | Largest_Norm_Resid, ImeasNAME(j,:) ); 125 | %disp('Largest error was Inj Measurement') 126 | Imeasstatus(Largest_Norm_Resid_Index) = 0; 127 | case 'Fmeas' 128 | j = Largest_Norm_Resid_Index; 129 | fprintf('Bad Data Detected %6.3f %s\n',... 130 | Largest_Norm_Resid, FmeasNAME(j,:) ); 131 | %disp('Largest error was Flow Measurement') 132 | Fmeasstatus(Largest_Norm_Resid_Index) = 0; 133 | end 134 | 135 | end 136 | 137 | end -------------------------------------------------------------------------------- /Estimation_Loop.m: -------------------------------------------------------------------------------- 1 | % start state est iterative loop 2 | 3 | 4 | %run subrouting to calculate number of active measurements 5 | count_active_measurements 6 | 7 | iteration = 1; 8 | not_converged = 1; 9 | 10 | while not_converged == 1 11 | 12 | % Build the H Matrix 13 | buildHmatrix 14 | 15 | % Calculate the mesairement Residual J and the measurement error vector 16 | calculate_residual_and_meas_error 17 | 18 | 19 | DelTHV = inv( H'*inv(Rcov)*H)*H'*inv(Rcov)* meas_error; 20 | 21 | % Htest = inv( H'*inv(Rcov)*H)*H'*inv(Rcov); 22 | 23 | max_delta = 0.0; 24 | 25 | % Update voltages and phase angles 26 | for i = 1: numbus 27 | 28 | throw = 2*i-1; 29 | Theta(i) = Theta(i) + DelTHV(throw); 30 | if abs( DelTHV(throw) ) > max_delta 31 | max_delta = abs( DelTHV(throw) ); 32 | end 33 | vrow = 2*i; 34 | Vmag(i) = Vmag(i)*(1 + DelTHV(vrow)); 35 | if abs( Vmag(i)* DelTHV(vrow) ) > max_delta 36 | max_delta = abs( Vmag(i)* DelTHV(vrow) ); 37 | end 38 | 39 | end; 40 | 41 | 42 | %fprintf(' % 5d %12.3f %15.8f\n', iteration, J, max_delta); 43 | fprintf(' % 5d %12.3f \n', iteration, J ); 44 | iteration=iteration+1; 45 | %max_delta 46 | if iteration > 10 | max_delta <= Est_tolerance 47 | not_converged = 0; 48 | end 49 | 50 | end % end of main while loop 51 | 52 | -------------------------------------------------------------------------------- /Estimation_Orthogonal_Loop.m: -------------------------------------------------------------------------------- 1 | % start state estimation orthogonal iterative loop 2 | 3 | %run subrouting to calculate number of active measurements 4 | count_active_measurements 5 | 6 | iteration = 1; 7 | not_converged = 1; 8 | 9 | while not_converged == 1 10 | 11 | % Build the H Matrix 12 | buildHmatrix 13 | 14 | % Calculate the mesairement Residual J and the measurement error vector 15 | calculate_residual_and_meas_error 16 | 17 | %********************************************************* 18 | % 19 | % old code: 20 | % DelTHV = inv( H'*inv(Rcov)*H)*H'*inv(Rcov)* meas_error; 21 | % 22 | % max_delta = 0.0; 23 | % 24 | % Update voltages and phase angles 25 | % for i = 1: numbus 26 | % 27 | % throw = 2*i-1; 28 | % 29 | % Theta(i) = Theta(i) + DelTHV(throw); 30 | % if abs( DelTHV(throw) ) > max_delta 31 | % max_delta = abs( DelTHV(throw) ); 32 | % end 33 | % vrow = 2*i; 34 | % Vmag(i) = Vmag(i)*(1 + DelTHV(vrow)); 35 | % if abs( Vmag(i)* DelTHV(vrow) ) > max_delta 36 | % max_delta = abs( Vmag(i)* DelTHV(vrow) ); 37 | % end 38 | % 39 | % end; 40 | %********************************************************* 41 | % 42 | % New code for EE8725 project 43 | % 11/8/2015 44 | % 45 | %calculate the new H matrix 46 | %[H'] = sqrt[R^(-1)] * [H] 47 | %TODO: create sparse 48 | 49 | H1 = sqrt(inv(Rcov))*H; 50 | 51 | %calculate the new R-covariance matrix 52 | %[Z'] = sqrt[R^(-1)] * Z 53 | %TODO: create sparse 54 | Z1 = sqrt(inv(Rcov))*meas_error; 55 | 56 | %This function calculates the Q matrix and U matrix of H' 57 | %TODO: create sparse 58 | [Q,U] = qr(H1); 59 | 60 | % Q 61 | % U 62 | 63 | DelTHV = U\(Q' *Z1); 64 | 65 | max_delta = 0.0; 66 | 67 | % Update voltages and phase angles 68 | for i = 1: numbus 69 | 70 | throw = 2*i-1; 71 | 72 | Theta(i) = Theta(i) + DelTHV(throw); 73 | if abs( DelTHV(throw) ) > max_delta 74 | max_delta = abs( DelTHV(throw) ); 75 | end 76 | vrow = 2*i; 77 | Vmag(i) = Vmag(i)*(1 + DelTHV(vrow)); 78 | if abs( Vmag(i)* DelTHV(vrow) ) > max_delta 79 | max_delta = abs( Vmag(i)* DelTHV(vrow) ); 80 | end 81 | 82 | end; 83 | %********************************************************* 84 | 85 | 86 | 87 | %fprintf(' % 5d %12.3f %15.8f\n', iteration, J, max_delta); 88 | fprintf(' % 5d %12.3f \n', iteration, J ); 89 | iteration=iteration+1; 90 | %max_delta 91 | if iteration > 10 | max_delta <= Est_tolerance 92 | not_converged = 0; 93 | end 94 | 95 | end % end of main while loop 96 | 97 | -------------------------------------------------------------------------------- /Loop Through measurements logic.m: -------------------------------------------------------------------------------- 1 | measurement_index = 1; 2 | 3 | % Voltage Measurements 4 | for i_vmeas = 1:numVmeas 5 | i = Vmeasbus(i_vmeas); 6 | 7 | if Vmeasstatus(i_vmeas) == 1 8 | 9 | if i == Slack 10 | 11 | end 12 | end 13 | measurement_index = measurement_index + 1; 14 | end 15 | 16 | 17 | % Angle Measurements 18 | for i_ameas = 1:numAmeas 19 | i = Ameasbus(i_ameas); 20 | 21 | if Ameasstatus(i_ameas) == 1 22 | 23 | if i == Slack 24 | 25 | end 26 | end 27 | measurement_index = measurement_index + 1; 28 | end 29 | 30 | 31 | % Injection Measurements 32 | 33 | for i_injmeas=1:numImeas 34 | i = Imeasbus(i_injmeas); 35 | 36 | if Imeasstatus(i_injmeas) == 1 37 | measurement_index = measurement_index + 1; 38 | 39 | 40 | 41 | measurement_index = measurement_index + 1; 42 | else 43 | measurement_index = measurement_index + 2 44 | end; 45 | end 46 | 47 | 48 | % Flow Measurements 49 | 50 | for i_flowmeas = 1:numFmeas 51 | i=Fmeasfrombus(i_flowmeas); 52 | j=Fmeastobus(i_flowmeas); 53 | ibranch = Fmeasbranch(i_flowmeas); 54 | 55 | 56 | if Fmeasstatus(i_flowmeas) == 1 57 | 58 | measurement_index = measurement_index + 1; 59 | 60 | 61 | measurement_index = measurement_index + 1; 62 | else 63 | measurement_index = measurement_index + 2; 64 | end 65 | end -------------------------------------------------------------------------------- /OldBadDataLogic.m: -------------------------------------------------------------------------------- 1 | % fprintf(' %s \n',''); 2 | % fprintf(' %s \n',''); 3 | % fprintf(' %s \n',''); 4 | % fprintf(' %s \n','-------------------'); 5 | % fprintf(' %s \n','Bad Data Analysis'); 6 | % fprintf(' %s \n','-----------------------------------------------------------------------'); 7 | % fprintf(' %s \n','Measurement Measurement Caculated Difference Covariance y_norm '); 8 | % fprintf(' %s \n','Number Value Value of error '); 9 | % fprintf(' %s \n','-----------------------------------------------------------------------'); 10 | % fprintf(' %s\n','Pflow measurements:'); 11 | % for i=1:numFmeas 12 | % fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA, (FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,sigmaPflow(i),y1_norm(i)*baseMVA); 13 | % end 14 | % fprintf(' %s\n','Qflow measurements:'); 15 | % for i=1:numFmeas 16 | % fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA, (FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,sigmaQflow(i),y2_norm(i)*baseMVA); 17 | % end 18 | % fprintf(' %s\n','Pinjection measurements:'); 19 | % for i=1:numImeas 20 | % fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', Imeasbus(i), ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA, (ImeasPvalue(i)-IcalcPvalue(i))*baseMVA,sigmaPinjec(i),y3_norm(i)*baseMVA); 21 | % end 22 | % fprintf(' %s\n','Qinjection measurements:'); 23 | % for i=1:numImeas 24 | % fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', Imeasbus(i), ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA, (ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,sigmaQinjec(i),y4_norm(i)*baseMVA); 25 | % end 26 | % %find the maximum y_norm(i), which is the prime suspect of error,both 27 | % %the value and the index, putting them into Primesuspectvalue and 28 | % %Primesuspectindex seperately. 29 | % 30 | % 31 | % [Primesuspectvalue, Primesuspectindex]=max(abs(y_norm)) 32 | % if Primesuspectvalue<0.03 33 | % fprintf('There is no bad measurement anymore!\n'); 34 | % break; 35 | % end 36 | % 37 | % % Remove the bad measurement and display the bad measurement index and 38 | % % value. 39 | % if Primesuspectindex<=numFmeas % the removed measurements is a P flow measurement 40 | % fprintf('The bad measurement is a P flow measurement. %e\n'); 41 | % fprintf('The bad measurement occurs at(the index of P flow measurements): %2d %s', Primesuspectindex,''); 42 | % fprintf('Its value is:%e',Primesuspectvalue); 43 | % fprintf(' %s \n',' '); 44 | % numFmeas=numFmeas-1; 45 | % if numFmeas~=0 46 | % for i=Primesuspectindex:(numFmeas) 47 | % FmeasPvalue(i)=FmeasPvalue(i+1); 48 | % FmeasPsigma(i)=FmeasPsigma(i+1); 49 | % Fmeasbranch(i)=Fmeasbranch(i+1); 50 | % Fmeasfrombus(i)=Fmeasfrombus(i+1); 51 | % Fmeastobus(i)=Fmeastobus(i+1); 52 | % end 53 | % end 54 | % elseif Primesuspectindex>numFmeas&&Primesuspectindex<=(numFmeas+numFmeas) 55 | % fprintf('The bad measurement is a Q flow measurement. %e\n'); 56 | % fprintf('The bad measurement occurs at (the index of Q flow measurements): %2d %s', (Primesuspectindex-numFmeas),''); 57 | % fprintf('Its value is:%e',Primesuspectvalue); 58 | % fprintf(' %s \n',' '); 59 | % numFmeas=numFmeas-1; 60 | % if numFmeas~=0 61 | % for i=(Primesuspectindex-numFmeas):(numFmeas) 62 | % FmeasQvalue(i)=FmeasQvalue(i+1); 63 | % FmeasQsigma(i)=FmeasQsigma(i+1); 64 | % Fmeasbranch(i)=Fmeasbranch(i+1); 65 | % Fmeasfrombus(i)=Fmeasfrombus(i+1); 66 | % Fmeastobus(i)=Fmeastobus(i+1); 67 | % end 68 | % end 69 | % elseif Primesuspectindex>(numFmeas+numFmeas) && Primesuspectindex<=(numFmeas+numFmeas+numImeas) 70 | % badmeasurementbus=Primesuspectindex-numFmeas-numFmeas; 71 | % fprintf('The bad measurement is a P injection measurement. %e\n'); 72 | % fprintf('The bad measurement occurs at bus: %2d %s', Imeasbus(badmeasurementbus),''); 73 | % fprintf('Its value is:%2d',Primesuspectvalue); 74 | % fprintf(' %s \n',' '); 75 | % numImeas=numImeas-1; 76 | % if numImeas~=0 77 | % for i=(Primesuspectindex-numFmeas-numFmeas):(numImeas) 78 | % ImeasPvalue(i)=ImeasPvalue(i+1); 79 | % ImeasPsigma(i)=ImeasPsigma(i+1); 80 | % Imeasbus(i)=Imeasbus(i+1); 81 | % end 82 | % Imeasbus=Imeasbus(1:numImeas); 83 | % end 84 | % else 85 | % badmeasurementbus=Primesuspectindex-numFmeas-numFmeas-numImeas; 86 | % 87 | % end 88 | % end 89 | % fprintf('The bad measurement is a Q injection measurement. %e\n'); 90 | % fprintf('The bad measurement occurs at bus: %2d %s', Imeasbus(badmeasurementbus), ''); 91 | % fprintf('Its value is:%2d',Primesuspectvalue); 92 | % fprintf(' %s \n',' '); 93 | % numImeas=numImeas-1; 94 | % if numImeas~=0 95 | % for i=(Primesuspectindex-numFmeas-numFmeas-numImeas):(numImeas) 96 | % ImeasQvalue(i)=ImeasQvalue(i+1); 97 | % ImeasQsigma(i)=ImeasQsigma(i+1); 98 | % Imeasbus(i)=Imeasbus(i+1); 99 | % end 100 | % Imeasbus=Imeasbus(1:numImeas); 101 | % end 102 | % end 103 | % % Calculate all f(i),y_norm(i) values for Nm measurements. 104 | % for i=1:numbus 105 | % vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 106 | % end 107 | % for i = 1:numFmeas 108 | % a=Fmeasfrombus(i); 109 | % b=Fmeastobus(i); 110 | % % for j = 1:numline 111 | % % if frombus(j) == a & tobus(j)==b 112 | % % break 113 | % % elseif frombus(j) == b & tobus(j)==a 114 | % % break 115 | % % end 116 | % % end 117 | % Iline = (vr(a) - vr(b))/(R(Fmeasbranch(i))+sqrt(-1)*X(Fmeasbranch(i))); 118 | % Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(Fmeasbranch(i))*0.5); 119 | % Sline = vr(a) * conj(Iline); 120 | % FcalcPvalue(i) = real(Sline); 121 | % y1_norm(i)=(FmeasPvalue(i)-FcalcPvalue(i))/sigmaPflow(i); 122 | % 123 | % end 124 | % y1_norm=y1_norm(1:numFmeas); 125 | % 126 | % for i = 1:numFmeas 127 | % a=Fmeasfrombus(i); 128 | % b=Fmeastobus(i); 129 | % % for j = 1:numline 130 | % % if frombus(j) == a & tobus(j)==b 131 | % % break 132 | % % elseif frombus(j) == b & tobus(j)==a 133 | % % break 134 | % % end 135 | % % end 136 | % Iline = (vr(a) - vr(b))/(R(Fmeasbranch(i))+sqrt(-1)*X(Fmeasbranch(i))); 137 | % Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(Fmeasbranch(i))*0.5); 138 | % Sline = vr(a) * conj(Iline); 139 | % FcalcQvalue(i)= imag(Sline); 140 | % %if FmeasQvalue(i)-FcalcQvalue(i)<0.00001 141 | % % y2_norm(i)=0; 142 | % %else 143 | % y2_norm(i)=(FmeasQvalue(i)-FcalcQvalue(i))/sigmaQflow(i); 144 | % 145 | % % end 146 | % end 147 | % y2_norm=y2_norm(1:numFmeas); 148 | % 149 | % IcalcPvalue=zeros(numImeas,1); 150 | % IcalcQvalue=zeros(numImeas,1); 151 | % for i=1:numImeas 152 | % a = Imeasbus(i); 153 | % for b=1:numbus 154 | % Pinj =z.vmag(a)*z.vmag(b)*(cos(z.vang(a)-z.vang(b))*G(a,b)-sin(z.vang(a)-z.vang(b))*B(a,b)); 155 | % IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 156 | % end 157 | % y3_norm(i)=(ImeasPvalue(i)-IcalcPvalue(i))/sigmaPinjec(i); 158 | % 159 | % end 160 | % y3_norm=y3_norm(1:numImeas); 161 | % for i=1:numImeas 162 | % a = Imeasbus(i); 163 | % for b=1:numbus 164 | % Qinj = z.vmag(a)*z.vmag(b)*(sin(z.vang(a)-z.vang(b))*G(a,b)+cos(z.vang(a)-z.vang(b))*B(a,b)); 165 | % IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 166 | % end 167 | % y4_norm(i)=(ImeasQvalue(i)-IcalcQvalue(i))/sigmaQinjec(i); 168 | % 169 | % end 170 | % y4_norm=y4_norm(1:numImeas); 171 | % % Assume that numFmeas, numFmeas never go to zero. 172 | % if numImeas==0 173 | % y_norm=[y1_norm,y2_norm,y4_norm]; 174 | % elseif numImeas==0 175 | % y_norm=[y1_norm,y2_norm,y3_norm]; 176 | % elseif numImeas==0&&numImeas==0 177 | % y_norm=[y1_norm,y2_norm]; 178 | % else 179 | % y_norm=[y1_norm,y2_norm,y3_norm,y4_norm]; 180 | % end 181 | % end % end "Detect and Identify bad measurements" process 182 | % 183 | % %end % end threshold iteration loop 184 | % 185 | % %Recalculate y_norm 186 | % for i = 1:numFmeas 187 | % y1_norm(i)=(FmeasPvalue(i)-FcalcPvalue(i))/sigmaPflow(i); 188 | % end 189 | % for i=1:numFmeas 190 | % y2_norm(i)=(FmeasQvalue(i)-FcalcQvalue(i))/sigmaQflow(i); 191 | % end 192 | % for i=1:numImeas 193 | % y3_norm(i)=(ImeasPvalue(i)-IcalcPvalue(i))/sigmaPinjec(i); 194 | % end 195 | % for i=1:numImeas 196 | % y4_norm(i)=(ImeasQvalue(i)-IcalcQvalue(i))/sigmaQinjec(i); 197 | % end 198 | % 199 | % fprintf(' %s \n',' '); 200 | % fprintf ('The final value of J is %d\n' , J) 201 | % fprintf ('The final value of TJ is %d\n' , TJ) 202 | % % Display 203 | % fprintf(' %s \n',' '); 204 | % fprintf(' %s \n','-----------------------------------------------------------------------------------'); 205 | % fprintf(' %s \n','From To Measured Calculated Difference Covariance of '); 206 | % fprintf(' %s \n','Bus Bus Value Value Meansurement '); 207 | % fprintf(' %s \n','-----------------------------------------------------------------------------------'); 208 | % 209 | % fprintf(' %s \n','Pflow: '); 210 | % for i=1:numFmeas 211 | % fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',Fmeasfrombus(i),Fmeastobus(i),FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA,(FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,FmeasPsigma(i)); 212 | % end 213 | % fprintf(' %s \n',' '); 214 | % fprintf(' %s \n',' '); 215 | % 216 | % fprintf(' %s \n','Qflow: '); 217 | % for i=1:numFmeas 218 | % fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',Fmeasfrombus(i),Fmeastobus(i),FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA,(FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,FmeasQsigma(i)); 219 | % end 220 | % fprintf(' %s \n',' '); 221 | % fprintf(' %s \n',' '); 222 | % 223 | % 224 | % fprintf(' %s \n','Pinjection: '); 225 | % for i=1:numImeas 226 | % fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',Imeasbus(i),ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA,(ImeasPvalue(i)-IcalcPvalue(i))*baseMVA, ImeasPsigma(i)); 227 | % end 228 | % 229 | % fprintf(' %s \n',' '); 230 | % fprintf(' %s \n',' '); 231 | % fprintf(' %s \n','Qinjection: '); 232 | % 233 | % for i=1:numImeas 234 | % fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',Imeasbus(i),ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA,(ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,ImeasQsigma(i)); 235 | % end 236 | % 237 | % 238 | % fprintf(' %s \n',''); 239 | % fprintf(' %s \n',''); 240 | % fprintf(' %s \n',''); 241 | % fprintf(' %s \n','-------------------'); 242 | % fprintf(' %s \n','Bad Data Analysis'); 243 | % fprintf(' %s \n','-----------------------------------------------------------------------'); 244 | % fprintf(' %s \n','Measurement Measurement Caculated Difference Covariance y_norm '); 245 | % fprintf(' %s \n','Number Value Value of error '); 246 | % fprintf(' %s \n','-----------------------------------------------------------------------'); 247 | % fprintf(' %s\n','Pflow measurements:'); 248 | % for i=1:numFmeas 249 | % fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA, (FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,sigmaPflow(i),y1_norm(i)*baseMVA); 250 | % end 251 | % fprintf(' %s\n','Qflow measurements:'); 252 | % for i=1:numFmeas 253 | % fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA, (FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,sigmaQflow(i),y2_norm(i)*baseMVA); 254 | % end 255 | % fprintf(' %s\n','Pinjection measurements:'); 256 | % for i=1:numImeas 257 | % fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', Imeasbus(i), ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA, (ImeasPvalue(i)-IcalcPvalue(i))*baseMVA,sigmaPinjec(i),y3_norm(i)*baseMVA); 258 | % end 259 | % fprintf(' %s\n','Qinjection measurements:'); 260 | % for i=1:numImeas 261 | % fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', Imeasbus(i), ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA, (ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,sigmaQinjec(i),y4_norm(i)*baseMVA); 262 | % end 263 | % 264 | % %Caculate all the flow and injection values from the voltages magnitudes and angles obtained from the state estimator. 265 | % for i=1:numbus 266 | % vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 267 | % end 268 | % 269 | % 270 | % for i = 1:numline 271 | % a=frombus(i); 272 | % b=tobus(i); 273 | % Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 274 | % Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 275 | % Sline = vr(a) * conj(Iline); 276 | % FcalcPvalue(i) = real(Sline); 277 | % end 278 | % for i=1:numline 279 | % a=tobus(i); 280 | % b=frombus(i); 281 | % Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 282 | % Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 283 | % Sline = vr(a) * conj(Iline); 284 | % FcalcPvalue(i+numline) = real(Sline); 285 | % end 286 | % for i = 1:numline 287 | % a=frombus(i); 288 | % b=tobus(i); 289 | % Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 290 | % Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 291 | % Sline = vr(a) * conj(Iline); 292 | % FcalcQvalue(i)= imag(Sline); 293 | % end 294 | % 295 | % for i = 1:numline 296 | % a=tobus(i); 297 | % b=frombus(i); 298 | % Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 299 | % Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 300 | % Sline = vr(a) * conj(Iline); 301 | % FcalcQvalue(i+numline)= imag(Sline); 302 | % end 303 | % IcalcPvalue=zeros(numbus,1); 304 | % IcalcQvalue=zeros(numbus,1); 305 | % for i=1:numbus 306 | % for b=1:numbus 307 | % Pinj =z.vmag(i)*z.vmag(b)*(cos(z.vang(i)-z.vang(b))*G(i,b)-sin(z.vang(i)-z.vang(b))*B(i,b)); 308 | % IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 309 | % end 310 | % end 311 | % 312 | % for i=1:numbus 313 | % for b=1:numbus 314 | % Qinj = z.vmag(i)*z.vmag(b)*(sin(z.vang(i)-z.vang(b))*G(i,b)+cos(z.vang(i)-z.vang(b))*B(i,b)); 315 | % IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 316 | % end 317 | % end 318 | % 319 | % 320 | % % Display AC state estimator result 321 | % fprintf(' %s \n',' '); 322 | % fprintf(' %s \n','State Estimator Solution:'); 323 | % fprintf(' %s \n',' '); 324 | % fprintf(' %s \n','Bus Volt. Volt. Mw Mvar To Mw Mvar '); 325 | % fprintf(' %s \n','Number Mag. Angle Injec. Injec. Bus Flow Flow '); 326 | % fprintf(' %s \n','------ ------ ------ -------- -------- ---- ------- ------- '); 327 | % 328 | % for i=1:numbus 329 | % fprintf('%5d %8.3f %8.3f %8.3f %8.3f \n',i, z.vmag(i),z.vang(i),IcalcPvalue(i)*baseMVA,IcalcQvalue(i)*baseMVA); 330 | % for j=1:numline 331 | % a=frombus(j); 332 | % b=tobus(j); 333 | % if b==i 334 | % fprintf(' %5d %8.3f %8.3f \n', a, FcalcPvalue(j+numline)*baseMVA, FcalcQvalue(j+numline)*baseMVA); 335 | % elseif a==i 336 | % fprintf(' %5d %8.3f %8.3f \n', b, FcalcPvalue(j)*baseMVA, FcalcQvalue(j)*baseMVA); 337 | % end 338 | % end 339 | % end -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # MATLAB-StateEstimation 2 | This is tthe first of the two projects given by Prof. Wollenberg on State Estimation of Power Systems. -------------------------------------------------------------------------------- /Scadamenu.m: -------------------------------------------------------------------------------- 1 | %Scada Manu program 2 | 3 | k = menu('Scada Menu','1) Add noise','2) Edit Measurement Data','3) Store Measurement Data and Exit'); 4 | 5 | 6 | if k==1 7 | add_noise; 8 | elseif k==2 9 | edit_measurement; 10 | elseif k==3 11 | end 12 | -------------------------------------------------------------------------------- /State Estimation Chapter from 2nd Edition of Wollenberg Book.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/State Estimation Chapter from 2nd Edition of Wollenberg Book.pdf -------------------------------------------------------------------------------- /StateEstimatorData.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/StateEstimatorData.mat -------------------------------------------------------------------------------- /add_noise.m: -------------------------------------------------------------------------------- 1 | % add_noise 2 | % 3 | if numVmeas~=0 4 | for i=1:numVmeas 5 | if Vmeasstatus(i) == 1 6 | if Vmeasbus(i) ~= refbus % do not assign noise to refbus 7 | Vmeasvaluenormrandom = Vmeassigma(i)*randn; 8 | Vmeasvalue(i) = Vmeasvalue(i)+Vmeasvaluenormrandom; 9 | end 10 | end 11 | end 12 | end 13 | 14 | Slack = 1; 15 | if numAmeas~=0 16 | for i=1:numAmeas 17 | if Ameasstatus(i) == 1 18 | if Ameasbus(i) ~= refbus % do not assign noise to refbus 19 | Ameasvaluenormrandom = Ameassigma(i)*randn; 20 | Ameasvalue(i) = Ameasvalue(i)+Ameasvaluenormrandom; 21 | end 22 | end 23 | end 24 | end 25 | 26 | if numImeas~=0 27 | for i=1:numImeas 28 | if Imeasstatus(i) == 1 29 | ImeasPvaluenormrandom = ImeasPsigma(i)*randn; 30 | ImeasPvalue(i) = ImeasPvalue(i)+ImeasPvaluenormrandom; 31 | ImeasQvaluenormrandom = ImeasQsigma(i)*randn; 32 | ImeasQvalue(i )= ImeasQvalue(i)+ImeasQvaluenormrandom; 33 | end 34 | end 35 | end 36 | if numFmeas~=0 37 | for i=1:numFmeas 38 | if Fmeasstatus(i) == 1 39 | FmeasPvaluenormrandom=FmeasPsigma(i)*randn; 40 | FmeasPvalue(i)=FmeasPvalue(i)+FmeasPvaluenormrandom; 41 | FmeasQvaluenormrandom=FmeasQsigma(i)*randn; 42 | FmeasQvalue(i)=FmeasQvalue(i)+FmeasQvaluenormrandom; 43 | end 44 | end 45 | end 46 | 47 | Noised=1; 48 | 49 | fprintf('%s\n','noise added!'); 50 | 51 | Scadamenu 52 | -------------------------------------------------------------------------------- /buildHmatrix.m: -------------------------------------------------------------------------------- 1 | % Store ones on the diagonal of the H Matrix 2 | 3 | % The H Matrix is built with one Vrow for each Voltage meas and 4 | % with one Arow for each Angle meas 5 | 6 | % The H Matrix is built with Prows(prow) and Qrows (qrow) for the 7 | % injection measurements and flow measurements 8 | 9 | % All rows have Theta columns (thcol) and V columns (vcol). 10 | num_rows_H = num_active_measurements; 11 | num_cols_H = 2*numbus; 12 | clear H Rcov 13 | H = zeros( num_rows_H, num_cols_H ); 14 | Rcov = zeros( num_rows_H, num_rows_H ); 15 | 16 | H_row_num = 0; 17 | 18 | % H 19 | % Rcov 20 | % size(Rcov) 21 | % Build the H Matrix rows for Voltage Measurements 22 | for i_vmeas = 1:numVmeas 23 | i = Vmeasbus(i_vmeas); 24 | if i ~= refbus 25 | if Vmeasstatus(i_vmeas) ~= 0 26 | H_row_num = H_row_num + 1; 27 | vrow = H_row_num; 28 | vcol = 2*i; 29 | 30 | H(vrow,vcol) = 1.0; 31 | % H(vrow,vcol) = Vmag(i); 32 | 33 | Rcov(vrow, vrow) = Vmeassigma(i_vmeas)^2; 34 | end 35 | 36 | elseif i == refbus 37 | 38 | H_row_num = H_row_num + 1; 39 | vrow = H_row_num; 40 | vcol = 2*i; 41 | H(vrow,vcol) = 1.0; 42 | refbus_Vrow_H = H_row_num; 43 | Rcov(vrow, vrow) = 1.0; 44 | 45 | end 46 | end 47 | % H 48 | % Rcov 49 | % size(Rcov) 50 | % Build the H Matrix rows for Angle Measurements 51 | for i_ameas = 1:numAmeas 52 | i = Ameasbus(i_ameas); 53 | if i ~= refbus 54 | if Ameasstatus(i_ameas) ~= 0 55 | H_row_num = H_row_num + 1; 56 | arow = H_row_num; 57 | thcol = 2*i-1; 58 | 59 | H(arow,thcol) = 1.0; 60 | 61 | 62 | Rcov(arow, arow) = Ameassigma(i_ameas)^2; 63 | end 64 | 65 | elseif i == refbus 66 | 67 | H_row_num = H_row_num + 1; 68 | arow = H_row_num; 69 | thcol = 2*i-1; 70 | H(arow,thcol) = 1.0; 71 | refbus_Arow_H = H_row_num; 72 | Rcov(arow, arow) = 1.0; 73 | 74 | end 75 | end 76 | % H 77 | % Rcov 78 | % size(Rcov) 79 | 80 | % Build the H Matrix rows for Injection Measurements 81 | % skip the inj at the refbus 82 | 83 | for i_injmeas = 1: numImeas 84 | i = Imeasbus(i_injmeas); 85 | if i ~= refbus 86 | 87 | if Imeasstatus(i_injmeas) ~= 0 88 | 89 | H_row_num = H_row_num + 1; 90 | prow = H_row_num; 91 | H_row_num = H_row_num + 1; 92 | qrow = H_row_num; 93 | 94 | 95 | % Build HPTh terms 96 | for j = 1: numbus 97 | thcol = 2*j -1; 98 | vcol = 2*j; 99 | if j ~= refbus 100 | if i == j 101 | H(prow,thcol) = -Qinj(i) - B(i,i)*Vmag(i)^2; 102 | else 103 | H(prow,thcol) = Vmag(i)*Vmag(j)*(G(i,j)*sin(Theta(i)-Theta(j)) - B(i,j)*cos(Theta(i)-Theta(j))); 104 | end 105 | elseif j == refbus 106 | H(prow,thcol) = 0.0; 107 | H(prow,thcol) = 0.0; 108 | end 109 | end % end build HPth terms loop 110 | 111 | % Build HPV terms 112 | for j = 1: numbus 113 | thcol = 2*j -1; 114 | vcol = 2*j; 115 | if j ~= refbus 116 | if i == j 117 | H(prow,vcol) = Pinj(i) + G(i,i)*Vmag(i)^2; 118 | else 119 | H(prow,vcol) = Vmag(i)*Vmag(j)*(G(i,j)*cos(Theta(i)-Theta(j))+B(i,j)*sin(Theta(i)-Theta(j))); 120 | end 121 | elseif j == refbus 122 | H(prow,vcol) = 0.0; 123 | H(prow,vcol) = 0.0; 124 | end 125 | end % end build HPV term loop 126 | 127 | % Build HQTh terms 128 | for j = 1: numbus 129 | thcol = 2*j -1; 130 | vcol = 2*j; 131 | if j ~= refbus 132 | if i == j 133 | H(qrow,thcol) = Pinj(i) - G(i,i)*Vmag(i)^2; 134 | else 135 | H(qrow,thcol)= -Vmag(i)*Vmag(j)*(G(i,j)*cos(Theta(i)-Theta(j))+B(i,j)*sin(Theta(i)-Theta(j))); 136 | end 137 | elseif j == refbus 138 | H(qrow,thcol) = 0.0; 139 | H(qrow,thcol) = 0.0; 140 | end 141 | end % end Build HQTh terms loop 142 | 143 | % Build HQV terms 144 | for j = 1: numbus 145 | thcol = 2*j -1; 146 | vcol = 2*j; 147 | if j ~= refbus 148 | if i == j 149 | H(qrow,vcol) = Qinj(i) - B(i,i)*Vmag(i)^2; 150 | else 151 | H(qrow,vcol) = Vmag(i)*Vmag(j)*(G(i,j)*sin(Theta(i)-Theta(j))-B(i,j)*cos(Theta(i)-Theta(j))); 152 | end 153 | elseif j == refbus 154 | H(qrow,vcol) = 0.0; 155 | H(qrow,vcol) = 0.0; 156 | end 157 | end% end build HQV terms loop 158 | 159 | Rcov(prow, prow) = ImeasPsigma(i_injmeas)^2; 160 | Rcov(qrow, qrow) = ImeasQsigma(i_injmeas)^2; 161 | 162 | end %end Imeasstatus test 163 | end % end refbus test 164 | 165 | 166 | end % end master bus loop building H matrix for Injection Measurements 167 | % H 168 | % Rcov 169 | % size(Rcov) 170 | 171 | % Build the H Matrix rows for Flow Measurements 172 | 173 | for i_flowmeas = 1: numFmeas 174 | if Fmeasstatus(i_flowmeas) ~= 0 175 | 176 | ibranch = Fmeasbranch(i_flowmeas); 177 | Gline = R(ibranch)/(R(ibranch)^2 + X(ibranch)^2); 178 | Bline = -X(ibranch)/(R(ibranch)^2 + X(ibranch)^2); 179 | Bcapline = Bcap(ibranch)/2; 180 | 181 | i = Fmeasfrombus(i_flowmeas); 182 | j = Fmeastobus(i_flowmeas); 183 | 184 | 185 | H_row_num = H_row_num + 1; 186 | prow = H_row_num; 187 | H_row_num = H_row_num + 1; 188 | qrow = H_row_num; 189 | 190 | 191 | 192 | % Build H terms for from end (bus i) 193 | thcol = 2*i -1; 194 | vcol = 2*i; 195 | if i ~= refbus 196 | 197 | 198 | H(prow,thcol) = Gline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)) - Bline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j)); % dP/dthi 199 | 200 | H(prow,vcol) = (2*Gline*Vmag(i) - Gline*Vmag(j)*cos(Theta(i)-Theta(j)) - Bline*Vmag(j)*sin(Theta(i)-Theta(j)))*Vmag(i); % dP/dVi 201 | 202 | H(qrow,thcol) = - Gline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j)) - Bline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)); % dQ/dthi 203 | 204 | H(qrow,vcol) = (Bline*Vmag(j)*cos(Theta(i)-Theta(j)) - 2*Bcapline*Vmag(i) - 2*Bline*Vmag(i) - Gline*Vmag(j)*sin(Theta(i)-Theta(j)))*Vmag(i); % dQ/dVi 205 | 206 | elseif i == refbus 207 | 208 | H(prow,thcol) = 0.0; 209 | H(prow,vcol) = 0.0; 210 | H(qrow,thcol) = 0.0; 211 | H(qrow,vcol) = 0.0; 212 | end 213 | 214 | % Build H terms for to end (bus j) 215 | 216 | thcol = 2*j -1; 217 | vcol = 2*j; 218 | if j ~= refbus 219 | 220 | 221 | H(prow,thcol) = Bline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j)) - Gline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)); % dP/dthj 222 | 223 | H(prow,vcol) = (- Gline*Vmag(i)*cos(Theta(i)-Theta(j)) - Bline*Vmag(i)*sin(Theta(i)-Theta(j)))*Vmag(j); % dP/dVj 224 | 225 | H(qrow,thcol) = Gline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j)) + Bline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)); % dQ/dthj 226 | 227 | H(qrow,vcol) = (Bline*Vmag(i)*cos(Theta(i)-Theta(j)) - Gline*Vmag(i)*sin(Theta(i)-Theta(j)))*Vmag(j); % dQ/dVj 228 | 229 | elseif j == refbus 230 | 231 | H(prow,thcol) = 0.0; 232 | H(prow,vcol) = 0.0; 233 | H(qrow,thcol) = 0.0; 234 | H(qrow,vcol) = 0.0; 235 | end 236 | 237 | Rcov(prow, prow) = FmeasPsigma(i_flowmeas)^2; 238 | Rcov(qrow, qrow) = FmeasQsigma(i_flowmeas)^2; 239 | 240 | end %end Fmeasstatus loop 241 | 242 | end % end master bus loop building H matrix for Flow Measurements 243 | 244 | % H 245 | % Rcov 246 | % size(Rcov) 247 | -------------------------------------------------------------------------------- /buildHmatrixOLD.m: -------------------------------------------------------------------------------- 1 | % Store ones on the diagonal of the H Matrix 2 | 3 | % The H Matrix is built with one Vrow for each Voltage meas and 4 | % with one Arow for each Angle meas 5 | 6 | % The H Matrix is built with Prows(prow) and Qrows (qrow) for the 7 | % injection measurements and flow measurements 8 | 9 | % All rows have Theta columns (thcol) and V columns (vcol). 10 | num_rows_H = num_measurements; 11 | num_cols_H = 2*numbus; 12 | H = zeros( num_rows_H, num_cols_H ); 13 | Rcov = zeros( num_rows_H, num_rows_H ); 14 | 15 | H_row_num = 0; 16 | 17 | % Build the H Matrix rows for Voltage Measurements 18 | for i_vmeas = 1:numVmeas 19 | i = Vmeasbus(i_vmeas); 20 | H_row_num = H_row_num + 1; 21 | vrow = H_row_num; 22 | vcol = 2*i; 23 | if Vmeasstatus(i_vmeas) ~= 0 24 | % H(vrow,vcol) = 1.0; 25 | H(vrow,vcol) = Vmag(i); 26 | end 27 | Rcov(vrow, vrow) = Vmeassigma(i_vmeas)^2; 28 | if i == refbus 29 | refbus_Vrow_H = H_row_num; 30 | end 31 | end 32 | 33 | 34 | % Build the H Matrix rows for Angle Measurements 35 | for i_ameas = 1:numAmeas 36 | i = Ameasbus(i_ameas); 37 | H_row_num = H_row_num + 1; 38 | arow = H_row_num; 39 | thcol = 2*i-1; 40 | if Ameasstatus(i_ameas) ~= 0 41 | H(arow,thcol) = 1.0; 42 | end 43 | Rcov(arow, arow) = Ameassigma(i_ameas)^2; 44 | if i == refbus 45 | refbus_Arow_H = H_row_num; 46 | end 47 | end 48 | 49 | % Build the H Matrix rows for Injection Measurements 50 | 51 | for i_injmeas = 1: numImeas 52 | 53 | i = Imeasbus(i_injmeas); 54 | H_row_num = H_row_num + 1; 55 | prow = H_row_num; 56 | H_row_num = H_row_num + 1; 57 | qrow = H_row_num; 58 | 59 | if Imeasstatus(i_injmeas) ~= 0 60 | 61 | % Build HPTh terms 62 | for j = 1: numbus 63 | %if j ~= refbus 64 | thcol = 2*j -1; 65 | vcol = 2*j; 66 | if i == j 67 | H(prow,thcol) = -Qinj(i) - B(i,i)*Vmag(i)^2; 68 | else 69 | H(prow,thcol) = Vmag(i)*Vmag(j)*(G(i,j)*sin(Theta(i)-Theta(j)) - B(i,j)*cos(Theta(i)-Theta(j))); 70 | end 71 | % end 72 | end % end build HPth terms loop 73 | 74 | % Build HPV terms 75 | for j = 1: numbus 76 | %if j ~= refbus 77 | thcol = 2*j -1; 78 | vcol = 2*j; 79 | if i == j 80 | H(prow,vcol) = Pinj(i) + G(i,i)*Vmag(i)^2; 81 | else 82 | H(prow,vcol) = Vmag(i)*Vmag(j)*(G(i,j)*cos(Theta(i)-Theta(j))+B(i,j)*sin(Theta(i)-Theta(j))); 83 | end 84 | %end 85 | end % end build HPV term loop 86 | 87 | % Build HQTh terms 88 | for j = 1: numbus 89 | %if j ~= refbus 90 | thcol = 2*j -1; 91 | vcol = 2*j; 92 | if i == j 93 | H(qrow,thcol) = Pinj(i) - G(i,i)*Vmag(i)^2; 94 | else 95 | H(qrow,thcol)= -Vmag(i)*Vmag(j)*(G(i,j)*cos(Theta(i)-Theta(j))+B(i,j)*sin(Theta(i)-Theta(j))); 96 | end 97 | %end 98 | end % end Build HQTh terms loop 99 | 100 | % Build HQV terms 101 | for j = 1: numbus 102 | %if j ~= refbus 103 | thcol = 2*j -1; 104 | vcol = 2*j; 105 | if i == j 106 | H(qrow,vcol) = Qinj(i) - B(i,i)*Vmag(i)^2; 107 | else 108 | H(qrow,vcol) = Vmag(i)*Vmag(j)*(G(i,j)*sin(Theta(i)-Theta(j))-B(i,j)*cos(Theta(i)-Theta(j))); 109 | end 110 | %end 111 | end% end build HQV terms loop 112 | 113 | end %end Imeasstatus loop 114 | 115 | Rcov(prow, prow) = ImeasPsigma(i_injmeas)^2; 116 | Rcov(qrow, qrow) = ImeasQsigma(i_injmeas)^2; 117 | 118 | 119 | end % end master bus loop building H matrix for Injection Measurements 120 | 121 | % Build the H Matrix rows for Flow Measurements 122 | 123 | 124 | 125 | for i_flowmeas = 1: numFmeas 126 | 127 | 128 | ibranch = Fmeasbranch(i_flowmeas); 129 | Gline = R(ibranch)/(R(ibranch)^2 + X(ibranch)^2); 130 | Bline = -X(ibranch)/(R(ibranch)^2 + X(ibranch)^2); 131 | Bcapline = Bcap(ibranch)/2; 132 | 133 | i = Fmeasfrombus(i_flowmeas); 134 | j = Fmeastobus(i_flowmeas); 135 | 136 | H_row_num = H_row_num + 1; 137 | prow = H_row_num; 138 | H_row_num = H_row_num + 1; 139 | qrow = H_row_num; 140 | 141 | if Fmeasstatus(i_flowmeas) ~= 0 142 | 143 | % Build H terms for from end (bus i) 144 | 145 | %if i ~= refbus 146 | thcol = 2*i -1; 147 | vcol = 2*i; 148 | 149 | H(prow,thcol) = Gline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)) - Bline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j)); % dP/dthi 150 | 151 | H(prow,vcol) = (2*Gline*Vmag(i) - Gline*Vmag(j)*cos(Theta(i)-Theta(j)) - Bline*Vmag(j)*sin(Theta(i)-Theta(j)))*Vmag(i); % dP/dVi 152 | 153 | H(qrow,thcol) = - Gline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j)) - Bline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)); % dQ/dthi 154 | 155 | H(qrow,vcol) = (Bline*Vmag(j)*cos(Theta(i)-Theta(j)) - 2*Bcapline*Vmag(i) - 2*Bline*Vmag(i) - Gline*Vmag(j)*sin(Theta(i)-Theta(j)))*Vmag(i); % dQ/dVi 156 | % end 157 | 158 | % Build H terms for to end (bus j) 159 | 160 | % if j ~= refbus 161 | thcol = 2*j -1; 162 | vcol = 2*j; 163 | 164 | H(prow,thcol) = Bline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j)) - Gline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)); % dP/dthj 165 | 166 | H(prow,vcol) = (- Gline*Vmag(i)*cos(Theta(i)-Theta(j)) - Bline*Vmag(i)*sin(Theta(i)-Theta(j)))*Vmag(j); % dP/dVj 167 | 168 | H(qrow,thcol) = Gline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j)) + Bline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)); % dQ/dthj 169 | 170 | H(qrow,vcol) = (Bline*Vmag(i)*cos(Theta(i)-Theta(j)) - Gline*Vmag(i)*sin(Theta(i)-Theta(j)))*Vmag(j); % dQ/dVj 171 | % end 172 | 173 | end %end Fmeasstatus loop 174 | 175 | Rcov(prow, prow) = ImeasPsigma(i_injmeas)^2; 176 | Rcov(qrow, qrow) = ImeasQsigma(i_injmeas)^2; 177 | 178 | end % end master bus loop building H matrix for Flow Measurements 179 | 180 | 181 | -------------------------------------------------------------------------------- /calculate_residual_and_meas_error.m: -------------------------------------------------------------------------------- 1 | measurement_index = 1; 2 | 3 | % Caculate Residual 4 | meas_error = zeros(num_active_measurements, 1); 5 | 6 | J = 0.0; 7 | 8 | % Build the error vector rows for Voltage Measurements 9 | Vmeas_estimated_value = zeros(numVmeas,1); 10 | for i_vmeas = 1:numVmeas 11 | i = Vmeasbus(i_vmeas); 12 | Vmeas_estimated_value(i_vmeas) = Vmag(i); 13 | 14 | if i ~= refbus 15 | 16 | if Vmeasstatus(i_vmeas) == 1 17 | meas_error(measurement_index)= Vmeas_measurement_value(i_vmeas) - Vmeas_estimated_value(i_vmeas); 18 | J = J + (Vmeas_measurement_value(i_vmeas)-Vmeas_estimated_value(i_vmeas))^2/Vmeassigma(i_vmeas)^2; 19 | measurement_index = measurement_index + 1; 20 | end 21 | 22 | elseif i == refbus 23 | 24 | Vmeas_estimated_value(i_vmeas) = Vmeas_measurement_value(i_vmeas); 25 | meas_error(measurement_index) = 0.0; 26 | measurement_index = measurement_index + 1; 27 | 28 | end 29 | 30 | end 31 | 32 | 33 | 34 | % Build the error vector rows for Angle Measurements 35 | Ameas_estimated_value = zeros(numAmeas,1); 36 | for i_ameas = 1:numAmeas 37 | i = Ameasbus(i_ameas); 38 | Ameas_estimated_value(i_ameas) = Theta(i); 39 | 40 | if i ~= refbus 41 | 42 | if Ameasstatus(i_ameas) == 1 43 | meas_error(measurement_index)= Ameas_measurement_value(i_ameas) - Ameas_estimated_value(i_ameas); 44 | J = J + (Ameas_measurement_value(i_ameas)-Ameas_estimated_value(i_ameas))^2/Ameassigma(i_ameas)^2; 45 | measurement_index = measurement_index + 1; 46 | end 47 | 48 | elseif i == refbus 49 | 50 | Ameas_estimated_value(i_ameas) = Ameas_measurement_value(i_ameas); 51 | meas_error(measurement_index)= 0.0; 52 | measurement_index = measurement_index + 1; 53 | end 54 | 55 | end 56 | 57 | 58 | % Residual for Injection Measurements 59 | Imeas_estimated_Pvalue=zeros(numImeas,1); 60 | Imeas_estimated_Qvalue=zeros(numImeas,1); 61 | for i_injmeas=1:numImeas 62 | 63 | i = Imeasbus(i_injmeas); 64 | 65 | if i ~=refbus 66 | 67 | Pinj(i)=0; 68 | Qinj(i)=0; 69 | for j = 1:numbus 70 | if i == j 71 | Pinj(i) = Pinj(i) + G(i,i)*Vmag(i)^2; 72 | Qinj(i) = Qinj(i) - B(i,i)*Vmag(i)^2; 73 | else 74 | Pinj(i) = Pinj(i) + Vmag(i)*Vmag(j)*(G(i,j)*cos(Theta(i)-Theta(j))+B(i,j)*sin(Theta(i)-Theta(j))); 75 | Qinj(i) = Qinj(i) + Vmag(i)*Vmag(j)*(G(i,j)*sin(Theta(i)-Theta(j))-B(i,j)*cos(Theta(i)-Theta(j))); 76 | end 77 | end 78 | Imeas_estimated_Pvalue(i_injmeas)= Pinj(i); 79 | Imeas_estimated_Qvalue(i_injmeas)= Qinj(i); 80 | if Imeasstatus(i_injmeas) == 1 81 | 82 | J = J + (Imeas_measurement_Pvalue(i_injmeas)-Imeas_estimated_Pvalue(i_injmeas))^2/ImeasPsigma(i_injmeas)^2; 83 | meas_error(measurement_index)= Imeas_measurement_Pvalue(i_injmeas)-Imeas_estimated_Pvalue(i_injmeas); 84 | measurement_index = measurement_index + 1; 85 | 86 | 87 | J = J + (Imeas_measurement_Qvalue(i_injmeas)-Imeas_estimated_Qvalue(i_injmeas))^2/ImeasQsigma(i_injmeas)^2; 88 | meas_error(measurement_index)= Imeas_measurement_Qvalue(i_injmeas)-Imeas_estimated_Qvalue(i_injmeas); 89 | measurement_index = measurement_index + 1; 90 | 91 | end; 92 | end 93 | end 94 | 95 | 96 | % Residual for flow measurements 97 | Fmeas_estimated_Pvalue = zeros(numFmeas,1); 98 | Fmeas_estimated_Qvalue = zeros(numFmeas,1); 99 | for i_flowmeas = 1:numFmeas 100 | i=Fmeasfrombus(i_flowmeas); 101 | j=Fmeastobus(i_flowmeas); 102 | ibranch = Fmeasbranch(i_flowmeas); 103 | Gline = R(ibranch)/(R(ibranch)^2 + X(ibranch)^2); 104 | Bline = -X(ibranch)/(R(ibranch)^2 + X(ibranch)^2); 105 | Bcapline = Bcap(ibranch)/2; 106 | 107 | Fmeas_estimated_Pvalue(i_flowmeas) = Gline*Vmag(i)^2 - Gline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j))-Bline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)); 108 | Fmeas_estimated_Qvalue(i_flowmeas)= -1*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j))*Gline - Vmag(i)^2*Bline + Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j))*Bline - (Vmag(i)^2)*Bcapline; 109 | 110 | if Fmeasstatus(i_flowmeas) == 1 111 | J = J + (Fmeas_measurement_Pvalue(i_flowmeas)- Fmeas_estimated_Pvalue(i_flowmeas))^2/FmeasPsigma(i_flowmeas)^2; 112 | meas_error(measurement_index)= Fmeas_measurement_Pvalue(i_flowmeas)- Fmeas_estimated_Pvalue(i_flowmeas); 113 | measurement_index = measurement_index + 1; 114 | 115 | J = J + (Fmeas_measurement_Qvalue(i_flowmeas)-Fmeas_estimated_Qvalue(i_flowmeas))^2/FmeasQsigma(i_flowmeas)^2; 116 | meas_error(measurement_index)= Fmeas_measurement_Qvalue(i_flowmeas)-Fmeas_estimated_Qvalue(i_flowmeas); 117 | measurement_index = measurement_index + 1; 118 | 119 | end 120 | end 121 | -------------------------------------------------------------------------------- /count_active_measurements.m: -------------------------------------------------------------------------------- 1 | %num_active_measurements is the total number of measurements being 2 | % used it will be <= num_measurements depending on how many measurements 3 | % have status set to 0 4 | num_active_measurements = 0; 5 | % num_active_measurements 6 | % count active Voltage Measurements 7 | 8 | for i_vmeas = 1:numVmeas 9 | if Vmeasbus(i_vmeas) ~= refbus 10 | if Vmeasstatus(i_vmeas) == 1 11 | num_active_measurements = num_active_measurements + 1; 12 | end 13 | elseif Vmeasbus(i_vmeas) == refbus 14 | num_active_measurements = num_active_measurements + 1; 15 | end 16 | % i_vmeas 17 | % num_active_measurements 18 | end 19 | % num_active_measurements 20 | % Count active Angle Measurements 21 | for i_ameas = 1:numAmeas 22 | if Ameasbus(i_ameas) ~= refbus 23 | if Ameasstatus(i_ameas) == 1 24 | num_active_measurements = num_active_measurements + 1; 25 | end 26 | elseif Ameasbus(i_ameas) == refbus 27 | num_active_measurements = num_active_measurements + 1; 28 | end 29 | end 30 | % num_active_measurements 31 | % count active Injection Measurements 32 | for i_injmeas=1:numImeas 33 | if Imeasbus(i_injmeas) ~= refbus 34 | if Imeasstatus(i_injmeas) == 1 35 | num_active_measurements = num_active_measurements + 2; 36 | end; 37 | end 38 | end 39 | % num_active_measurements 40 | % Count active flow measurements 41 | for i_flowmeas = 1:numFmeas 42 | if Fmeasstatus(i_flowmeas) == 1 43 | num_active_measurements = num_active_measurements + 2; 44 | end 45 | end 46 | % num_active_measurements 47 | % num_active_measurements -------------------------------------------------------------------------------- /edit_angle_measurement.m: -------------------------------------------------------------------------------- 1 | % edit_angle_measurement 2 | 3 | fprintf('%s \n', 'which angle measurement would you like to edit?'); 4 | fprintf('%s %s %s \n', 'angle meas number','Ameasbus','Ameasvalue'); 5 | for i=1:numAmeas 6 | fprintf('%5d %5d %8.3f \n', i,Ameasbus(i),Ameasvalue(i)); 7 | end 8 | anglenumber=input('angle measurement number:','s'); 9 | [x status]=str2num(anglenumber); 10 | if status==0 11 | fprintf('%s\n','No change has been made'); 12 | edit_measurement; 13 | else 14 | anglenumber=str2num(anglenumber); 15 | while (anglenumber>numAmeas||anglenumber<=0) 16 | fprintf('%s\n','ERROR!!!'); 17 | fprintf('%s \n', 'which angle measurement would you like to edit?'); 18 | anglenumber=input('angle measurement number:'); 19 | end 20 | a_bus=Ameasbus(anglenumber); 21 | fprintf('%s %5d \n', 'Volt bus:',a_bus); 22 | % Later I should add error signal if the bus number is not right. 23 | fprintf('%s \n', 'Please input a new value to the angle measurement data for the bus you have selected'); 24 | Ameasnew = input(' Ameasnew: ','s'); 25 | [x status]=str2num(Ameasnew); 26 | if status==0 27 | fprintf('%s\n','No change has been made to Voltage measurement data'); 28 | else 29 | Ameasnew=str2num(Ameasnew); 30 | Ameasvalue(anglenumber)=Ameasnew; 31 | end 32 | 33 | fprintf('%s \n','Now the new angle data become:'); 34 | fprintf('%s %s %s\n', 'angle meas number','Ameasbus','Ameasvalue'); 35 | for i=1:numAmeas 36 | fprintf('%5d %5d %8.3f \n', i,Ameasbus(i),Ameasvalue(i)); 37 | end 38 | edit_measurement; 39 | end -------------------------------------------------------------------------------- /edit_flow_measurement.m: -------------------------------------------------------------------------------- 1 | % edit_flow_measurement 2 | 3 | fprintf('%s \n', 'which flow measurement data you would like to edit?'); 4 | fprintf('%s %s %s %s %s %s\n', 'flow number','branch number','Fmeasfrombus','Fmeastobus','FmeasPflow','FmeasQflow'); 5 | for i=1:numFmeas 6 | fprintf('%5d %5d %5d %5d %8.3f %8.3f \n', i,Fmeasbranch(i),Fmeasfrombus(i),Fmeastobus(i),FmeasPvalue(i)*baseMVA,FmeasQvalue(i)*baseMVA); 7 | end 8 | flownumber=input('flow measurement number:','s'); 9 | [x status]=str2num(flownumber); 10 | if status==0 11 | fprintf('%s\n','No change has been made'); 12 | edit_measurement; 13 | else 14 | flownumber=str2num(flownumber); 15 | while (flownumber>numFmeas||flownumber<=0) 16 | fprintf('%s\n','ERROR!!!'); 17 | fprintf('%s \n', 'which flow measurement data you would like to edit?'); 18 | flownumber=input('flow measurement number:'); 19 | end 20 | a=Fmeasfrombus(flownumber); 21 | b=Fmeastobus(flownumber); 22 | fprintf('%s %5d %s %5d \n', 'From bus:',a,'To bus:',b); 23 | % 24 | fprintf('%s \n', 'Please input new values to the flow measurement data of the line you have selected'); 25 | FmeasPnew= input(' FmeasPnew: ','s'); 26 | [x status]=str2num(FmeasPnew); 27 | if status==0 28 | fprintf('%s\n','No change has been made to P flow measurement data'); 29 | else 30 | FmeasPnew=str2num(FmeasPnew); 31 | FmeasPvalue(flownumber)=FmeasPnew/baseMVA; 32 | end 33 | FmeasQnew= input(' FmeasQnew: ','s'); 34 | [x status]=str2num(FmeasQnew); 35 | if status==0 36 | fprintf('%s\n','No change has been made to Q flow measurement data'); 37 | else 38 | FmeasQnew=str2num(FmeasQnew); 39 | FmeasQvalue(flownumber)=FmeasQnew/baseMVA; 40 | end 41 | fprintf('%s \n','Now the new flow data become:'); 42 | fprintf('%s %s %s %s %s %s\n', 'flow number','branch number','Fmeasfrombus','Fmeastobus','FmeasPflow','FmeasQflow'); 43 | for i=1:numFmeas 44 | fprintf('%5d %5d %5d %5d %8.3f %8.3f \n', i,Fmeasbranch(i),Fmeasfrombus(i),Fmeastobus(i),FmeasPvalue(i)*baseMVA,FmeasQvalue(i)*baseMVA); 45 | end 46 | edit_measurement; 47 | end -------------------------------------------------------------------------------- /edit_injection_measurement.m: -------------------------------------------------------------------------------- 1 | %Edit Injection Measurement 2 | 3 | 4 | fprintf('%s \n', 'which Injection measurement data you would like to edit?'); 5 | fprintf('%s \n', 'P Injection measurement data:'); 6 | for i=1:numImeas 7 | fprintf('%5d %8.3f\n',Imeasbus(i), ImeasPvalue(i)*baseMVA); 8 | end 9 | fprintf('%s \n', 'Q Injection measurement data:'); 10 | for i=1:numImeas 11 | fprintf('%5d %8.3f\n',Imeasbus(i), ImeasQvalue(i)*baseMVA); 12 | end 13 | Injectionbus=input('Injection Measurement Bus Number:','s'); 14 | [x status]=str2num(Injectionbus); 15 | if status==0 16 | fprintf('%s\n','No change has been made'); 17 | edit_measurement; 18 | else 19 | Injectionbus=str2num(Injectionbus); 20 | for i=1:numImeas 21 | if Imeasbus(i,1)==Injectionbus; 22 | inj_num=i; % Injection bus index 23 | end 24 | end 25 | for i=1:numImeas 26 | if Injectionbus==Imeasbus(i) 27 | break 28 | else 29 | i=i+1; 30 | end 31 | end 32 | while i>numImeas 33 | fprintf('%s\n','ERROR!!!'); 34 | fprintf('%s\n','Please enter the bus number again!'); 35 | Injectionbus=input('Injection Measurement Bus Number:'); 36 | for i=1:numImeas 37 | if Imeasbus(i,1)==Injectionbus; 38 | inj_num=i; % Injection bus index 39 | end 40 | end 41 | for i=1:numImeas 42 | if Injectionbus==Imeasbus(i) 43 | break 44 | else 45 | i=i+1; 46 | end 47 | end 48 | end 49 | fprintf('%s \n', 'Please input new values to the injection measurement data (MW) of the bus you have selected'); 50 | IinjPnew=0; 51 | IinjQnew=0; 52 | IinjPnew= input(' IinjPnew: ','s'); 53 | [x status]=str2num(IinjPnew); 54 | if status==0 55 | fprintf('%s\n','No change has been made to P injection measurement data'); 56 | else 57 | IinjPnew=str2num(IinjPnew); 58 | ImeasPvalue(inj_num)=IinjPnew/baseMVA; 59 | end 60 | IinjQnew= input(' IinjQnew: ','s'); 61 | [x status]=str2num(IinjQnew); 62 | if status==0 63 | fprintf('%s\n','No change has been made to Q injection measurement data'); 64 | else 65 | IinjQnew=str2num(IinjQnew); 66 | ImeasQvalue(inj_num)=IinjQnew/baseMVA; 67 | end 68 | fprintf('%s \n','Now all the injection measurement become:'); 69 | fprintf('%s \n', 'P Injection measurement data:'); 70 | for i=1:numImeas 71 | fprintf('%5d %8.3f\n',Imeasbus(i), ImeasPvalue(i)*baseMVA); 72 | end 73 | fprintf('%s \n', 'Q Injection measurement data:'); 74 | for i=1:numImeas 75 | fprintf('%5d %8.3f\n',Imeasbus(i), ImeasQvalue(i)*baseMVA); 76 | end 77 | fprintf(' %s \n',' '); 78 | 79 | edit_measurement; 80 | end -------------------------------------------------------------------------------- /edit_measurement.m: -------------------------------------------------------------------------------- 1 | %edit_measurement 2 | 3 | k = menu('Edit Measurement Data','1) Edit Voltage Measurement',... 4 | '2) Edit Angle Measurement',... 5 | '3) Edit Injection Measurement',... 6 | '4) Edit Flow Measurement',... 7 | '5) Exit Editor'); 8 | 9 | 10 | 11 | if k==1 12 | edit_volt_measurement; 13 | elseif k==2 14 | edit_angle_measurement; 15 | elseif k==3 16 | edit_injection_measurement; 17 | elseif k==4 18 | edit_flow_measurement; 19 | elseif k==5 20 | Scadamenu; 21 | end -------------------------------------------------------------------------------- /edit_volt_measurement.m: -------------------------------------------------------------------------------- 1 | % edit_volt_measurement 2 | 3 | fprintf('%s \n', 'which volt measurement would you like to edit?'); 4 | fprintf('%s %s %s \n',... 5 | 'volt meas number','Vmeasbus','Vmeasvalue'); 6 | for i=1:numVmeas 7 | fprintf('%5d %5d %8.3f \n', i,Vmeasbus(i),Vmeasvalue(i)); 8 | end 9 | voltnumber=input('volt measurement number:','s'); 10 | [x status]=str2num(voltnumber); 11 | if status==0 12 | fprintf('%s\n','No change has been made'); 13 | edit_measurement; 14 | else 15 | voltnumber=str2num(voltnumber); 16 | while (voltnumber>numVmeas||voltnumber<=0) 17 | fprintf('%s\n','ERROR!!!'); 18 | fprintf('%s \n', 'which volt measurement would you like to edit?'); 19 | voltnumber=input('volt measurement number:'); 20 | end 21 | v_bus=Vmeasbus(voltnumber); 22 | fprintf('%s %5d \n', 'Volt bus:',v_bus); 23 | % Later I should add error signal if the bus number is not right. 24 | fprintf('%s \n', 'Please input a new value to the voltage measurement data for the bus you have selected'); 25 | Vmeasnew = input(' Vmeasnew: ','s'); 26 | [x status]=str2num(Vmeasnew); 27 | if status==0 28 | fprintf('%s\n','No change has been made to Voltage measurement data'); 29 | else 30 | Vmeasnew=str2num(Vmeasnew); 31 | Vmeasvalue(voltnumber)=Vmeasnew; 32 | end 33 | 34 | fprintf('%s \n','Now the new voltage data become:'); 35 | fprintf('%s %s %s\n', 'volt meas number','Vmeasbus','Vmeasvalue'); 36 | for i=1:numVmeas 37 | fprintf('%5d %5d %8.3f \n', i,Vmeasbus(i),Vmeasvalue(i)); 38 | end 39 | edit_measurement; 40 | end -------------------------------------------------------------------------------- /force_injection.m: -------------------------------------------------------------------------------- 1 | %force injection measurment to zero. 2 | 3 | 4 | fprintf('%s \n', 'which Injection measurement data you would like to force to zero?'); 5 | fprintf('%s \n', 'P Injection measurement data:'); 6 | for i=1:numImeas 7 | fprintf('%5d %8.3f\n',Imeasbus(i), ImeasPvalue(i)*baseMVA); 8 | end 9 | fprintf('%s \n', 'Q Injection measurement data:'); 10 | for i=1:numImeas 11 | fprintf('%5d %8.3f\n',Imeasbus(i), ImeasQvalue(i)*baseMVA); 12 | end 13 | Injectionbus=input('Injection Measurement Bus Number:','s'); 14 | [x status]=str2num(Injectionbus); 15 | if status==0 16 | fprintf('%s\n','No change has been made'); 17 | edit_measurement; 18 | else 19 | Injectionbus=str2num(Injectionbus); 20 | for i=1:numImeas 21 | if Imeasbus(i,1)==Injectionbus; 22 | inj_num=i; % Injection bus index 23 | end 24 | end 25 | for i=1:numImeas 26 | if Injectionbus==Imeasbus(i) 27 | break 28 | else 29 | i=i+1; 30 | end 31 | end 32 | while i>numImeas 33 | fprintf('%s\n','ERROR!!!'); 34 | fprintf('%s\n','Please enter the bus number again!'); 35 | Injectionbus=input('Injection Measurement Bus Number:'); 36 | for i=1:numImeas 37 | if Injectionbus==Imeasbus(i) 38 | break 39 | else 40 | i=i+1; 41 | end 42 | end 43 | end 44 | fprintf('%s \n', 'Please input new values to the injection measurement data (MW) of the bus you have selected'); 45 | IinjPnew=0; 46 | IinjQnew=0; 47 | IinjPnew= input(' IinjPnew: ','s'); 48 | [x status]=str2num(IinjPnew); 49 | if status==0 50 | fprintf('%s\n','No change has been made to P injection measurement data'); 51 | else 52 | IinjPnew=str2num(IinjPnew); 53 | ImeasPvalue(Injectionbus)=IinjPnew/baseMVA; 54 | end 55 | IinjQnew= input(' IinjQnew: ','s'); 56 | [x status]=str2num(IinjQnew); 57 | if status==0 58 | fprintf('%s\n','No change has been made to Q injection measurement data'); 59 | else 60 | IinjQnew=str2num(IinjQnew); 61 | ImeasQvalue(Injectionbus)=IinjQnew/baseMVA; 62 | end 63 | fprintf('%s \n','Now all the injection measurement become:'); 64 | fprintf('%s \n', 'P Injection measurement data:'); 65 | for i=1:numImeas 66 | fprintf('%5d %8.3f\n',Imeasbus(i), ImeasPvalue(i)*baseMVA); 67 | end 68 | fprintf('%s \n', 'Q Injection measurement data:'); 69 | for i=1:numImeas 70 | fprintf('%5d %8.3f\n',Imeasbus(i), ImeasQvalue(i)*baseMVA); 71 | end 72 | fprintf(' %s \n',' '); 73 | 74 | edit_measurement; 75 | end -------------------------------------------------------------------------------- /force_to_zero.m: -------------------------------------------------------------------------------- 1 | %force some measurement data to zero. -------------------------------------------------------------------------------- /hey.m: -------------------------------------------------------------------------------- 1 | %oh heyyy am not andy -------------------------------------------------------------------------------- /measurement_data_template.xls: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasanthkannan/MATLAB-StateEstimation/3df0fec4c4c7858c2516e3045630cd01a9b51dbb/measurement_data_template.xls -------------------------------------------------------------------------------- /measurement_datainput_Excel.m: -------------------------------------------------------------------------------- 1 | %&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 2 | % Reading Measurement Data File: 3 | % Input Data File 4 | [file,pathname] = uigetfile('*measurementdata.xls*','Select Spreadsheet File'); 5 | if (pathname == 0), 6 | error('You Must Select A Valid Data File') 7 | end 8 | S=file; % Name of the File that we need to read 9 | 10 | fprintf(' Case ID: %s \n',file); 11 | %-------------------------------------------------------------------------- 12 | % Read measurement data from the spreadsheet 13 | [voltage_measurements, voltage_meas_NAMES_CHAR ] = xlsread(S, 'voltage_measurements'); 14 | 15 | [numrows,N] = size(voltage_meas_NAMES_CHAR); 16 | for i=2:numrows 17 | name = cell2mat(voltage_meas_NAMES_CHAR(i,2)); 18 | [M, numcols] = size(name); 19 | for j = 1:numcols 20 | voltage_meas_NAMES(i-1, j) = name(1,j); 21 | end 22 | end 23 | numVmeas = numrows - 1; 24 | 25 | %-------------------------------------------------------------------------- 26 | [angle_measurements, angle_meas_NAMES_CHAR] = xlsread(S, 'angle_measurements'); 27 | 28 | [numrows,N] = size(angle_meas_NAMES_CHAR); 29 | for i=2:numrows 30 | name = cell2mat(angle_meas_NAMES_CHAR(i,2)); 31 | [M, numcols] = size(name); 32 | for j = 1:numcols 33 | angle_meas_NAMES(i-1, j) = name(1,j); 34 | end 35 | end 36 | numAmeas = numrows - 1; 37 | 38 | %-------------------------------------------------------------------------- 39 | [injection_measurements, injection_meas_NAMES_CHAR] = xlsread(S, 'injection_measurements'); 40 | 41 | [numrows,N] = size(injection_meas_NAMES_CHAR); 42 | for i=2:numrows 43 | name = cell2mat(injection_meas_NAMES_CHAR(i,2)); 44 | [M, numcols] = size(name); 45 | for j = 1:numcols 46 | injection_meas_NAMES(i-1, j) = name(1,j); 47 | end 48 | end 49 | numImeas = numrows - 1; 50 | 51 | %-------------------------------------------------------------------------- 52 | [flow_measurements, flow_meas_NAMES_CHAR] = xlsread(S, 'flow_measurements'); 53 | 54 | [numrows,N] = size(flow_meas_NAMES_CHAR); 55 | for i=2:numrows 56 | name = cell2mat(flow_meas_NAMES_CHAR(i,2)); 57 | [M, numcols] = size(name); 58 | for j = 1:numcols 59 | flow_meas_NAMES(i-1, j) = name(1,j); 60 | end 61 | end 62 | numFmeas = numrows - 1; 63 | 64 | %-------------------------------------------------------------------------- 65 | 66 | 67 | 68 | % Get the table dimensions from the tables read off spreadsheet 69 | [numVmeas,numVvariables]=size(voltage_measurements); 70 | [numAmeas,numAvariables]=size(angle_measurements); 71 | [numImeas,numIvariables]=size(injection_measurements); 72 | [numFmeas,numFvariables]=size(flow_measurements); 73 | 74 | %NOTE: This state estimator depends upon the user placing a Vmeas and 75 | % an Ameas at the slack bus 76 | 77 | % Create the data structure for all measurements and fill with spreadsheet data 78 | % NOTE THAT ALL DATA GOES IN AT THIS POINT BUT NOT THE MEAS VALUES 79 | SCADA_voltage_meas_data = struct('number_voltage_meas', numVmeas,... 80 | 'voltage_meas_bus', [voltage_measurements(1:numVmeas,1)],... 81 | 'voltage_meas_NAMES', [voltage_meas_NAMES(1:numVmeas,:)],... 82 | 'voltage_meas_sigma', [voltage_measurements(1:numVmeas,3)],... 83 | 'voltage_meas_status', [voltage_measurements(1:numVmeas,4)],... 84 | 'voltage_meas_base_value', [voltage_measurements(1:numVmeas,5)],... 85 | 'voltage_meas_measurement_value',[voltage_measurements(1:numVmeas,6)] ); 86 | 87 | 88 | 89 | SCADA_angle_meas_data = struct('number_angle_meas', numAmeas,... 90 | 'angle_meas_bus', [angle_measurements(1:numAmeas,1)],... 91 | 'angle_meas_NAMES', [angle_meas_NAMES(1:numAmeas,:)],... 92 | 'angle_meas_sigma', [angle_measurements(1:numAmeas,3)],... 93 | 'angle_meas_status', [angle_measurements(1:numVmeas,4)],... 94 | 'angle_meas_base_value', [angle_measurements(1:numVmeas,5)],... 95 | 'angle_meas_measurement_value',[angle_measurements(1:numVmeas,6)] ); 96 | if numImeas==0 97 | SCADA_injection_meas_data = struct('number_injection_meas', numImeas,... 98 | 'injection_meas_bus', [],... 99 | 'injection_meas_NAMES', [],... 100 | 'injection_meas_Psigma',[],... 101 | 'injection_meas_Qsigma',[],... 102 | 'injection_meas_status',[],... 103 | 'injection_meas_base_Pvalue',[],... 104 | 'injection_meas_base_Qvalue',[],... 105 | 'injection_meas_measurement_Pvalue',[],... 106 | 'injection_meas_measurement_Qvalue',[] ); 107 | 108 | else 109 | SCADA_injection_meas_data = struct('number_injection_meas', numImeas,... 110 | 'injection_meas_bus', [injection_measurements(1:numImeas,1)],... 111 | 'injection_meas_NAMES', [injection_meas_NAMES(1:numImeas,:)],... 112 | 'injection_meas_Psigma', [injection_measurements(1:numImeas,3)],... 113 | 'injection_meas_Qsigma', [injection_measurements(1:numImeas,4)],... 114 | 'injection_meas_status', [injection_measurements(1:numImeas,5)],... 115 | 'injection_meas_base_Pvalue', [injection_measurements(1:numImeas,6)],... 116 | 'injection_meas_base_Qvalue', [injection_measurements(1:numImeas,7)],... 117 | 'injection_meas_measurement_Pvalue',[injection_measurements(1:numImeas,8)],... 118 | 'injection_meas_measurement_Qvalue',[injection_measurements(1:numImeas,9)] ); 119 | end 120 | 121 | if numFmeas==0 122 | SCADA_flow_meas_data = struct('number_flow_meas', numFmeas,... 123 | 'flow_meas_branch', [],... 124 | 'flow_meas_NAMES', [],... 125 | 'flow_meas_frombus',[],... 126 | 'flow_meas_tobus', [],... 127 | 'flow_meas_Psigma', [],... 128 | 'flow_meas_Qsigma', [],... 129 | 'flow_meas_status', [],... 130 | 'flow_meas_base_Pvalue',[],... 131 | 'flow_meas_base_Qvalue',[],... 132 | 'flow_meas_measurement_Pvalue',[],... 133 | 'flow_meas_measurement_Qvalue',[] ); 134 | else 135 | 136 | SCADA_flow_meas_data = struct('number_flow_meas', numFmeas,... 137 | 'flow_meas_branch', [flow_measurements(1:numFmeas,1)],... 138 | 'flow_meas_NAMES', [flow_meas_NAMES(1:numFmeas,:)],... 139 | 'flow_meas_frombus', [flow_measurements(1:numFmeas,3)],... 140 | 'flow_meas_tobus', [flow_measurements(1:numFmeas,4)],... 141 | 'flow_meas_Psigma', [flow_measurements(1:numFmeas,5)],... 142 | 'flow_meas_Qsigma', [flow_measurements(1:numFmeas,6)],... 143 | 'flow_meas_status', [flow_measurements(1:numFmeas,7)],... 144 | 'flow_meas_base_Pvalue', [flow_measurements(1:numFmeas,8)],... 145 | 'flow_meas_base_Qvalue', [flow_measurements(1:numFmeas,9)],... 146 | 'flow_meas_measurement_Pvalue',[flow_measurements(1:numFmeas,10)],... 147 | 'flow_meas_measurement_Qvalue',[flow_measurements(1:numFmeas,11)] ); 148 | end 149 | 150 | % Place data in local arrays for use in calculating values 151 | Vmeasbus = SCADA_voltage_meas_data.voltage_meas_bus; 152 | VmeasNAME = SCADA_voltage_meas_data.voltage_meas_NAMES; 153 | Vmeassigma = SCADA_voltage_meas_data.voltage_meas_sigma; 154 | Vmeasstatus = SCADA_voltage_meas_data.voltage_meas_status; 155 | 156 | Ameasbus = SCADA_angle_meas_data.angle_meas_bus; 157 | AmeasNAME = SCADA_angle_meas_data.angle_meas_NAMES; 158 | Ameassigma = SCADA_angle_meas_data.angle_meas_sigma; 159 | Ameasstatus = SCADA_angle_meas_data.angle_meas_status; 160 | 161 | 162 | Imeasbus = SCADA_injection_meas_data.injection_meas_bus; 163 | ImeasNAME = SCADA_injection_meas_data.injection_meas_NAMES; 164 | ImeasPsigma = SCADA_injection_meas_data.injection_meas_Psigma; 165 | ImeasQsigma = SCADA_injection_meas_data.injection_meas_Qsigma; 166 | Imeasstatus = SCADA_injection_meas_data.injection_meas_status; 167 | 168 | 169 | Fmeasbranch = SCADA_flow_meas_data.flow_meas_branch; 170 | FmeasNAME = SCADA_flow_meas_data.flow_meas_NAMES; 171 | Fmeasfrombus = SCADA_flow_meas_data.flow_meas_frombus; 172 | Fmeastobus = SCADA_flow_meas_data.flow_meas_tobus; 173 | FmeasPsigma = SCADA_flow_meas_data.flow_meas_Psigma; 174 | FmeasQsigma = SCADA_flow_meas_data.flow_meas_Qsigma; 175 | Fmeasstatus = SCADA_flow_meas_data.flow_meas_status; 176 | 177 | -------------------------------------------------------------------------------- /measurementprint.m: -------------------------------------------------------------------------------- 1 | if print >= 2 2 | fprintf(' %s \n',' '); 3 | fprintf(' %s \n',' Base Case Value Measured Value '); 4 | fprintf(' %s \n',' _________________ _________________'); 5 | fprintf(' %s \n','Measurement kV MW MVAR kV MW MVAR '); 6 | for i = 1:numbus 7 | if i >9 8 | space = ''; 9 | else 10 | space = ' '; 11 | end 12 | 13 | if numVmeas > 0 14 | for j = 1:numVmeas 15 | if Vmeasbus(j) == i 16 | fprintf(' %s %5.1f %5.1 \n',voltage_meas_NAMES(j,:),Vmeasvalueinput(j),Vmeasvalue(j)); 17 | end 18 | end 19 | end 20 | 21 | % for j = 1:numline 22 | % if frombus(j) == i; 23 | % if tobus(j) >9 24 | % space = ''; 25 | % else 26 | % space = ' '; 27 | % end 28 | % Iline = (vr(frombus(j)) - vr(tobus(j)))/(R(j)+sqrt(-1)*X(j)); 29 | % Iline = Iline + vr(frombus(j))*(0.0 + sqrt(-1)*Bcap(j)*0.5); 30 | % Sline = vr(frombus(j)) * conj(Iline); 31 | % Pline = real(Sline)*baseMVA; 32 | % Qline = imag(Sline)*baseMVA; 33 | % fprintf(' %s%s %d %8.3f %8.3f \n',space,' ',tobus(j),Pline, Qline); 34 | % elseif tobus(j) == i 35 | % if frombus(j) >9 36 | % space = ''; 37 | % else 38 | % space = ' '; 39 | % end 40 | % Iline = (vr(tobus(j)) - vr(frombus(j)))/(R(j)+sqrt(-1)*X(j)); 41 | % Iline = Iline + vr(tobus(j))*(0.0 + sqrt(-1)*Bcap(j)*0.5); 42 | % Sline = vr(tobus(j)) * conj(Iline); 43 | % Pline = real(Sline)*baseMVA; 44 | % Qline = imag(Sline)*baseMVA; 45 | % fprintf(' %s%s %d %8.3f %8.3f \n',space,' ',frombus(j),Pline, Qline); 46 | % end 47 | % end 48 | % end 49 | 50 | end % end of print option print>1 51 | -------------------------------------------------------------------------------- /network_datainput_Excel.m: -------------------------------------------------------------------------------- 1 | %pfdatainput 2 | % Power flow data input, build Y matrix 3 | 4 | 5 | % Input Data File 6 | [file,pathname] = uigetfile('*networkdata.xls*','Select Network Data Spreadsheet File'); 7 | if (pathname == 0), 8 | error('You Must Select A Valid Data File') 9 | end 10 | S=file; % Name of the File that we need to read 11 | 12 | fprintf(' Case ID: %s \n',file); 13 | 14 | 15 | [Parameter_data, Parameter_Character_Data] = xlsread(S, 'Parameters'); 16 | [bus, Character_Data] = xlsread(S, 'BusData'); 17 | [gen, Character_Data] = xlsread(S, 'GenData'); 18 | [branch, Character_Data] = xlsread(S, 'BranchData'); 19 | [area, Character_Data] = xlsread(S, 'AreaData'); 20 | [areanamedata, areaname] = xlsread(S, 'AreaName'); 21 | [gencost_inputdata, Character_Data] = xlsread(S, 'GenCostData'); 22 | 23 | baseMVA = Parameter_data(1); 24 | baseKV = Parameter_data(2); 25 | casemult = Parameter_data(3); 26 | Rmult = Parameter_data(4); 27 | varlimit = cell2mat(Parameter_Character_Data(5,2)); 28 | powerflow_tolerance = Parameter_data(6); 29 | Maxiter = Parameter_data(7); 30 | LPOPF_convergence = Parameter_data(8); 31 | delta_upper = Parameter_data(9); 32 | delta = Parameter_data(10); 33 | tau = Parameter_data(11); 34 | gamma = Parameter_data(12); 35 | nu = Parameter_data(13); 36 | printpowerflow_convergence = Parameter_data(14); 37 | printpowerflow_bussummary = Parameter_data(15); 38 | printLPmove_summary = Parameter_data(16); 39 | print_summary_graphs = Parameter_data(17); 40 | Contingency_Limits = Parameter_data(18); 41 | climadj = Parameter_data(19); 42 | Line_flow_limits = Parameter_data(20); 43 | printfactorsflag = Parameter_data(21); 44 | 45 | 46 | [numbus,N] = size(bus); 47 | [numline,N] = size(branch); 48 | [numgen,N] = size(gen); 49 | [numarea,N] = size(area); 50 | 51 | 52 | % numbus 53 | % numline 54 | % numgen 55 | % numarea 56 | 57 | Bustype = zeros(1,numbus); 58 | Bustype_start = zeros(1,numbus); 59 | 60 | for ibus = 1:numbus 61 | Bustype(ibus)= ' '; 62 | end 63 | 64 | Pload = zeros(1,numbus); 65 | Qload = zeros(1,numbus); 66 | Vmax = zeros(1,numbus); 67 | Vmin = zeros(1,numbus); 68 | 69 | frombus = zeros(1,numline); 70 | tobus = zeros(1,numline); 71 | R = zeros(1,numline); 72 | X = zeros(1,numline); 73 | Bcap = zeros(1,numline); 74 | flowmax = zeros(1,numline); 75 | BranchStatus = zeros(1,numline); 76 | Vsched = zeros(1,numgen); 77 | Pgen = zeros(1,numgen); 78 | Qgen = zeros(1,numgen); 79 | Pmax = zeros(1,numgen); 80 | Pmin = zeros(1,numgen); 81 | Qmax = zeros(1,numgen); 82 | Qmin = zeros(1,numgen); 83 | genbus = zeros(1,numgen); 84 | busgen = zeros(1,numbus); 85 | original_genbus = zeros(1,numgen); 86 | 87 | for ibus = 1:numbus 88 | bustype_number = bus(ibus,2); 89 | if bustype_number == 1 90 | Bustype(ibus) = 'L'; 91 | end 92 | if bustype_number == 2 93 | Bustype(ibus) = 'G'; 94 | end 95 | if bustype_number == 3 96 | Bustype(ibus) = 'S'; 97 | refbus = ibus; 98 | end 99 | Bustype_start(ibus) = Bustype(ibus); 100 | Pload(ibus) = bus(ibus,3)* casemult/baseMVA; 101 | Qload(ibus) = bus(ibus,4)* casemult/baseMVA; 102 | Vmax(ibus) = bus(ibus,12); 103 | Vmin(ibus) = bus(ibus,13); 104 | end 105 | % Pload 106 | % Qload 107 | % Vmax 108 | % Vmin 109 | for igen = 1:numgen 110 | ibus = gen(igen,1); 111 | genbus(igen) = ibus; 112 | busgen(ibus) = igen; 113 | original_genbus(igen) = ibus; 114 | Pgen(igen) = gen(igen,2)* casemult/baseMVA; 115 | Qgen(igen) = gen(igen,3)* casemult/baseMVA; 116 | Pmax(igen) = gen(igen,9)/baseMVA; 117 | Pmin(igen) = gen(igen,10)/baseMVA; 118 | Qmax(igen) = gen(igen,4)/baseMVA; 119 | Qmin(igen) = gen(igen,5)/baseMVA; 120 | if varlimit == 'N' 121 | Qmax(igen) = 99.; 122 | Qmin(igen) = -99.; 123 | end 124 | Vsched(igen) = gen(igen,6); 125 | end 126 | for iline = 1:numline 127 | frombus(iline) = branch(iline,1); 128 | tobus(iline) = branch(iline,2); 129 | R(iline) = branch(iline,3); 130 | X(iline) = branch(iline,4); 131 | Bcap(iline) = branch(iline,5); 132 | flowmax(iline) = branch(iline,6); 133 | BranchStatus(iline) = branch(iline,11); 134 | end 135 | Y = zeros(numbus,numbus); 136 | for iline = 1:numline 137 | if BranchStatus(iline) == 1 138 | Y(frombus(iline),tobus(iline)) = Y(frombus(iline),tobus(iline))-1/(R(iline)+sqrt(-1)*X(iline)); 139 | Y(tobus(iline),frombus(iline)) = Y(tobus(iline),frombus(iline))-1/(R(iline)+sqrt(-1)*X(iline)); 140 | end 141 | end 142 | for ibus = 1:numbus 143 | Y(ibus,ibus) = -sum(Y(ibus,:)); 144 | end 145 | for iline = 1:numline 146 | if BranchStatus(iline) == 1 147 | Y(frombus(iline),frombus(iline)) = Y(frombus(iline),frombus(iline))+sqrt(-1)*Bcap(iline)/2; 148 | Y(tobus(iline),tobus(iline)) = Y(tobus(iline),tobus(iline))+sqrt(-1)*Bcap(iline)/2; 149 | end 150 | end 151 | 152 | G=real(Y); 153 | B=imag(Y); 154 | 155 | %Init voltage and angle Variables 156 | v = ones(1,numbus); 157 | angle = zeros(1,numbus); 158 | v = bus(:,8); 159 | angle = bus(:,9)*(pi/180); 160 | for igen = 1:numgen 161 | ibus = genbus(igen); 162 | v(ibus) = Vsched(igen); 163 | end 164 | 165 | nbus = numbus; % Number of buss 166 | ncircuits = numline; % Number of Interfaces between buss 167 | 168 | 169 | for iline = 1:numline 170 | fbus(iline) = frombus(iline); 171 | tbus(iline) = tobus(iline); 172 | xckt(iline) = X(iline); 173 | flowmax_perckt(iline) = flowmax(iline); 174 | monitor_circuit(iline) = BranchStatus(iline); 175 | end 176 | -------------------------------------------------------------------------------- /pfdatainput_Excel.m: -------------------------------------------------------------------------------- 1 | %pfdatainput 2 | % Power flow data input, build Y matrix 3 | 4 | 5 | % Input Data File 6 | [file,pathname] = uigetfile('*.xls','Select Spreadsheet File'); 7 | if (pathname == 0), 8 | error('You Must Select A Valid Data File') 9 | end 10 | S=file; % Name of the File that we need to read 11 | 12 | fprintf(' Case ID: %s \n',file); 13 | fprintf(' \n') 14 | 15 | 16 | [Parameter_data, Parameter_Character_Data] = xlsread(S, 'Parameters'); 17 | [bus, Character_Data] = xlsread(S, 'BusData'); 18 | [gen, Character_Data] = xlsread(S, 'GenData'); 19 | [branch, Character_Data] = xlsread(S, 'BranchData'); 20 | [area, Character_Data] = xlsread(S, 'AreaData'); 21 | [areanamedata, areaname] = xlsread(S, 'AreaName'); 22 | [gencost_inputdata, Character_Data] = xlsread(S, 'GenCostData'); 23 | 24 | baseMVA = Parameter_data(1); 25 | baseKV = Parameter_data(2); 26 | casemult = Parameter_data(3); 27 | Rmult = Parameter_data(4); 28 | varlimit = cell2mat(Parameter_Character_Data(5,2)); 29 | powerflow_tolerance = Parameter_data(6); 30 | Maxiter = Parameter_data(7); 31 | LPOPF_convergence = Parameter_data(8); 32 | delta_upper = Parameter_data(9); 33 | delta = Parameter_data(10); 34 | tau = Parameter_data(11); 35 | gamma = Parameter_data(12); 36 | nu = Parameter_data(13); 37 | printpowerflow_convergence = Parameter_data(14); 38 | printpowerflow_bussummary = Parameter_data(15); 39 | printLPmove_summary = Parameter_data(16); 40 | print_summary_graphs = Parameter_data(17); 41 | Contingency_limits = Parameter_data(18); 42 | climadj = Parameter_data(19); 43 | Line_flow_limits = Parameter_data(20); 44 | printfactorsflag = Parameter_data(21); 45 | 46 | % Parameter_data 47 | % Parameter_Character_Data 48 | % bus 49 | % gen 50 | % branch 51 | % area 52 | % areaname 53 | % gencost 54 | 55 | % Def of Data 56 | % iter: Iteration number 57 | % Maxiter: Maximum number of iteration 58 | % powerflow_tolerance: Maximum error allowed 59 | % numbus: Number of nodes in the system 60 | % numline: Number of lines in the system 61 | % frombus(i), tobus(i): Nodes from and to bus numbers for line i 62 | % R(i): Resistance line i 63 | % X(i): Reactance line i 64 | % Bcap(i) Total line charging for line i 65 | % FlowLimit Line MW flow limit 66 | % BranchStatus Line IN/OUT status 1 = IN, 0 = OUT 67 | % Bustype(i): Kind of bus i (l = PQ, g = PV, s = Slack) 68 | % v(i): Voltage magnitude of the node i 69 | % Psched(i): Active power inyected in the node i 70 | % Qsched(i): Reactive power inyected in the node i 71 | % Vsched(i): Voltage schedule for the node i 72 | 73 | % 74 | % Fill in UMN power flow table variables below 75 | % 76 | % POWER FLOW MATLAB variables: 77 | % 78 | % Bustype, Psched, Qsched, Vsched 79 | % 80 | % frombus, tobus, R, X, Bcap 81 | % 82 | % baseMVA, numbus, numlines, powerflow_tolerance, Maxiter 83 | 84 | [numbus,N] = size(bus); 85 | [numline,N] = size(branch); 86 | [numgen,N] = size(gen); 87 | [numarea,N] = size(area); 88 | 89 | 90 | % numbus 91 | % numline 92 | % numgen 93 | % numarea 94 | 95 | Bustype = zeros(1,numbus); 96 | Bustype_start = zeros(1,numbus); 97 | 98 | for ibus = 1:numbus 99 | Bustype(ibus)= ' '; 100 | end 101 | 102 | Pload = zeros(1,numbus); 103 | Qload = zeros(1,numbus); 104 | Vmax = zeros(1,numbus); 105 | Vmin = zeros(1,numbus); 106 | % frombus = zeros(1,numline+1); 107 | % tobus = zeros(1,numline+1); 108 | % R = zeros(1,numline+1); 109 | % X = zeros(1,numline+1); 110 | % Bcap = zeros(1,numline+1); 111 | % flowmax = zeros(1,numline+1); 112 | % BranchStatus = zeros(1,numline+1); 113 | frombus = zeros(1,numline); 114 | tobus = zeros(1,numline); 115 | R = zeros(1,numline); 116 | X = zeros(1,numline); 117 | Bcap = zeros(1,numline); 118 | flowmax = zeros(1,numline); 119 | BranchStatus = zeros(1,numline); 120 | Vsched = zeros(1,numgen); 121 | Pgen = zeros(1,numgen); 122 | Qgen = zeros(1,numgen); 123 | Pmax = zeros(1,numgen); 124 | Pmin = zeros(1,numgen); 125 | Qmax = zeros(1,numgen); 126 | Qmin = zeros(1,numgen); 127 | genbus = zeros(1,numgen); 128 | busgen = zeros(1,numbus); 129 | original_genbus = zeros(1,numgen); 130 | 131 | for ibus = 1:numbus 132 | bustype_number = bus(ibus,2); 133 | if bustype_number == 1 134 | Bustype(ibus) = 'L'; 135 | end 136 | if bustype_number == 2 137 | Bustype(ibus) = 'G'; 138 | end 139 | if bustype_number == 3 140 | Bustype(ibus) = 'S'; 141 | Slack = ibus; 142 | end 143 | Bustype_start(ibus) = Bustype(ibus); 144 | Pload(ibus) = bus(ibus,3)* casemult/baseMVA; 145 | Qload(ibus) = bus(ibus,4)* casemult/baseMVA; 146 | Vmax(ibus) = bus(ibus,12); 147 | Vmin(ibus) = bus(ibus,13); 148 | end 149 | % Pload 150 | % Qload 151 | % Vmax 152 | % Vmin 153 | for igen = 1:numgen 154 | ibus = gen(igen,1); 155 | genbus(igen) = ibus; 156 | busgen(ibus) = igen; 157 | original_genbus(igen) = ibus; 158 | Pgen(igen) = gen(igen,2)* casemult/baseMVA; 159 | Qgen(igen) = gen(igen,3)* casemult/baseMVA; 160 | Pmax(igen) = gen(igen,9)/baseMVA; 161 | Pmin(igen) = gen(igen,10)/baseMVA; 162 | Qmax(igen) = gen(igen,4)/baseMVA; 163 | Qmin(igen) = gen(igen,5)/baseMVA; 164 | if varlimit == 'N' 165 | Qmax(igen) = 9999.; 166 | Qmin(igen) = -9999.; 167 | end 168 | Vsched(igen) = gen(igen,6); 169 | end 170 | % Pgen 171 | % Qgen 172 | % Pmax 173 | % Pmin 174 | % Qmax 175 | % Qmin 176 | % Vsched 177 | for iline = 1:numline 178 | frombus(iline) = branch(iline,1); 179 | tobus(iline) = branch(iline,2); 180 | R(iline) = branch(iline,3); 181 | X(iline) = branch(iline,4); 182 | Bcap(iline) = branch(iline,5); 183 | flowmax(iline) = branch(iline,6); 184 | BranchStatus(iline) = branch(iline,11); 185 | end 186 | % frombus 187 | % tobus 188 | % R 189 | % X 190 | % Bcap 191 | % flowmax 192 | % BranchStatus 193 | % Init values for Y supporting parallel lines 194 | Y = zeros(numbus,numbus); 195 | for iline = 1:numline 196 | if BranchStatus(iline) == 1 197 | Y(frombus(iline),tobus(iline)) = Y(frombus(iline),tobus(iline))-1/(R(iline)+sqrt(-1)*X(iline)); 198 | Y(tobus(iline),frombus(iline)) = Y(tobus(iline),frombus(iline))-1/(R(iline)+sqrt(-1)*X(iline)); 199 | end 200 | end 201 | for ibus = 1:numbus 202 | Y(ibus,ibus) = -sum(Y(ibus,:)); 203 | end 204 | for iline = 1:numline 205 | if BranchStatus(iline) == 1 206 | Y(frombus(iline),frombus(iline)) = Y(frombus(iline),frombus(iline))+sqrt(-1)*Bcap(iline)/2; 207 | Y(tobus(iline),tobus(iline)) = Y(tobus(iline),tobus(iline))+sqrt(-1)*Bcap(iline)/2; 208 | end 209 | end 210 | 211 | G=real(Y); 212 | B=imag(Y); 213 | 214 | %Init voltage and angle Variables 215 | v = ones(1,numbus); 216 | angle = zeros(1,numbus); 217 | v = bus(:,8); 218 | angle = bus(:,9)*(pi/180); 219 | for igen = 1:numgen 220 | ibus = genbus(igen); 221 | v(ibus) = Vsched(igen); 222 | end 223 | -------------------------------------------------------------------------------- /powerflownewton.m: -------------------------------------------------------------------------------- 1 | %function [systemMWloss] = powerflow 2 | print = 3; 3 | % Power Flow 4 | 5 | % Def of Data 6 | % iter: Iteration number 7 | % Maxiter: Maximum number of iteration 8 | % powerflow_tolerance: Maximum error allowed 9 | % numbus: Number of nodes in the system 10 | % numline: Number of lines in the system 11 | % frombus(i), tobus(i): Nodes from and to bus numbers for line i 12 | % R(i): Resistance line i 13 | % X(i): Reactance line i 14 | % Bcap(i) Total line charging for line i 15 | % Bustype(i): Kind of bus i (l = PQ, g = PV, s = refbus) 16 | % v(i): Voltage of the node i 17 | % Psched(i): Active power inyected in the node i 18 | % Qsched(i): Reactive power inyected in the node i 19 | % Vsched(i): Voltage schedule for the node i 20 | 21 | % Power Flow starts here 22 | 23 | % Init voltage and angle Variables 24 | v=ones(1,numbus); 25 | angle=zeros(numbus,1); 26 | 27 | %Build the Psched and Qsched tables 28 | totload = 0.0; 29 | for i = 1:numbus 30 | Psched(i)= -Pload(i); 31 | Qsched(i)= -Qload(i); 32 | totload = totload + Pload(i); 33 | end 34 | 35 | for g = 1:numgen 36 | i = genbus(g); 37 | Psched(i) = Psched(i) + Pgen(g); 38 | Qsched(i) = Qsched(i) + Qgen(g); 39 | v(i)=Vsched(g); 40 | end 41 | 42 | if print >= 3 43 | fprintf(' %s\n','Iter MAXDP MAXDPbus MAXDQ MAXDQbus') 44 | end 45 | 46 | Iter = 0; 47 | converge = 0; 48 | 49 | 50 | while 1 51 | 52 | Iter = Iter + 1; 53 | MAXDP = 0.0; 54 | MAXDPbus = 0; 55 | MAXDQ = 0.0; 56 | MAXDQbus = 0; 57 | 58 | % Calculation of Pinj and Qinj using the v and angles values. 59 | for i = 1: numbus 60 | if Bustype(i) == 'L' | Bustype(i) == 'G' 61 | Pinj(i)=0; 62 | Qinj(i)=0; 63 | for j = 1:numbus 64 | if i == j 65 | Pinj(i) = Pinj(i) + G(i,i)*v(i)^2; 66 | Qinj(i) = Qinj(i) - B(i,i)*v(i)^2; 67 | else 68 | Pinj(i) = Pinj(i) + v(i)*v(j)*(G(i,j)*cos(angle(i)-angle(j))+B(i,j)*sin(angle(i)-angle(j))); 69 | Qinj(i) = Qinj(i) + v(i)*v(j)*(G(i,j)*sin(angle(i)-angle(j))-B(i,j)*cos(angle(i)-angle(j))); 70 | end 71 | end 72 | DelP(i)=Psched(i)-Pinj(i); 73 | DelQ(i) = 0.0; 74 | if Bustype(i) == 'L' 75 | DelQ(i)=Qsched(i)-Qinj(i); 76 | end 77 | if abs(DelP(i)) > MAXDP 78 | MAXDP = abs(DelP(i)); 79 | MAXDPbus = i; 80 | end 81 | if abs(DelQ(i)) > MAXDQ 82 | MAXDQ = abs(DelQ(i)); 83 | MAXDQbus = i; 84 | end 85 | elseif Bustype(i) == 'S' 86 | Pinj(i) = 0; 87 | Qinj(i) = 0; 88 | DelP(i) = 0; 89 | DelQ(i) = 0; 90 | end 91 | end 92 | 93 | % Store ones on the diagonal of the Jacobian 94 | 95 | numbus2 = 2 * numbus; 96 | for i = 1:numbus2 97 | for j = 1:numbus2 98 | J(i,j) = 0.0; 99 | if i == j 100 | J(i,j) = 1.0; 101 | end 102 | end 103 | end 104 | 105 | % Build the Jacobian 106 | % Note, the Jacobian is built with P rows(prow) and Q rows (qrow), and with Theta Comumns (thcol) 107 | % and V rows (vrow). 108 | % The Jacobian is built one Prow and One Q row at a time. 109 | 110 | for i = 1: numbus 111 | prow = 2*i -1; 112 | qrow = 2*i; 113 | if Bustype(i) == 'L' | Bustype(i) == 'G' 114 | % Build JPTh terms 115 | for j = 1: numbus 116 | thcol = 2*j -1; 117 | vcol = 2*j; 118 | if Bustype(j) == 'L' | Bustype(j) == 'G' 119 | if i == j 120 | J(prow,thcol) = -Qinj(i) - B(i,i)*v(i)^2; 121 | else 122 | J(prow,thcol) = v(i)*v(j)*(G(i,j)*sin(angle(i)-angle(j)) - B(i,j)*cos(angle(i)-angle(j))); 123 | end 124 | end 125 | end % end build JPth terms loop 126 | % Build matrix JPV 127 | for j = 1: numbus 128 | thcol = 2*j -1; 129 | vcol = 2*j; 130 | if Bustype(j) == 'L' 131 | if i == j 132 | J(prow,vcol) = Pinj(i) + G(i,i)*v(i)^2; 133 | else 134 | J(prow,vcol) = v(i)*v(j)*(G(i,j)*cos(angle(i)-angle(j))+B(i,j)*sin(angle(i)-angle(j))); 135 | end 136 | end 137 | end % end build JPV term loop 138 | % Build JQTh terms 139 | if Bustype(i) == 'L' 140 | for j = 1: numbus 141 | thcol = 2*j -1; 142 | vcol = 2*j; 143 | if Bustype(j) == 'L' | Bustype(j) == 'G' 144 | if i == j 145 | J(qrow,thcol) = Pinj(i) - G(i,i)*v(i)^2; 146 | else 147 | J(qrow,thcol)= -v(i)*v(j)*(G(i,j)*cos(angle(i)-angle(j))+B(i,j)*sin(angle(i)-angle(j))); 148 | end 149 | end 150 | end % end Build JQTh terms loop 151 | end % end if 152 | % Build JQV terms 153 | if Bustype(i) == 'L' 154 | for j = 1: numbus 155 | thcol = 2*j -1; 156 | vcol = 2*j; 157 | if Bustype(j) == 'L' 158 | if i == j 159 | J(qrow,vcol) = Qinj(i) - B(i,i)*v(i)^2; 160 | else 161 | J(qrow,vcol) = v(i)*v(j)*(G(i,j)*sin(angle(i)-angle(j))-B(i,j)*cos(angle(i)-angle(j))); 162 | end 163 | end 164 | end% end build JQV terms loop 165 | end % end if statement 166 | 167 | end % end if statement on L or G 168 | DelPQ(prow) = DelP(i); 169 | DelPQ(qrow) = DelQ(i); 170 | 171 | end % end master bus loop building Jacobian 172 | if converge 173 | break 174 | end 175 | 176 | % Calculation of the delta voltages and delta angles 177 | %DelTHV=inv(J)*DelPQ'; 178 | DelTHV = J\DelPQ'; 179 | 180 | % Assign difference calculated in last step 181 | for i = 1: numbus 182 | if Bustype(i) == 'L' | Bustype(i) == 'G' 183 | throw = 2*i-1; 184 | angle(i) = angle(i) + DelTHV(throw); 185 | if Bustype(i) == 'L' 186 | vrow = 2*i; 187 | v(i) = v(i)*(1 + DelTHV(vrow)); 188 | end 189 | end 190 | end; 191 | 192 | % Print and save result from last iteration 193 | if print >= 3 194 | fprintf(' %2d %10.6f %6d %10.6f %5d\n',Iter, MAXDP, MAXDPbus, MAXDQ, MAXDQbus) 195 | end 196 | 197 | if MAXDP < powerflow_tolerance 198 | if MAXDQ < powerflow_tolerance 199 | converge = 1; 200 | for g = 1:numgen 201 | Qgen(g) = Qinj(genbus(g)) + Qload(genbus(g)); 202 | if Qgen(g) > Qmax(g) 203 | Bustype(genbus(g)) = 'L'; 204 | Qsched(genbus(g)) = Qmax(g) - Qload(genbus(g)); 205 | converge = 0; 206 | end 207 | end 208 | end 209 | end 210 | 211 | if Iter > Maxiter 212 | 'Maximun number of iteration reached - The Power Flow has failed' 213 | converge = 1; 214 | end 215 | 216 | 217 | end % end while loop 218 | 219 | %V=v'; 220 | %V(find(Bustype=='G')) 221 | 222 | % Display results 223 | % Calculate the net bus injections 224 | for i = 1: numbus 225 | Pinj(i)=0; 226 | Qinj(i)=0; 227 | for j = 1:numbus 228 | if i == j 229 | Pinj(i) = Pinj(i) + G(i,i)*v(i)^2; 230 | Qinj(i) = Qinj(i) - B(i,i)*v(i)^2; 231 | else 232 | Pinj(i) = Pinj(i) + v(i)*v(j)*(G(i,j)*cos(angle(i)-angle(j))+B(i,j)*sin(angle(i)-angle(j))); 233 | Qinj(i) = Qinj(i) + v(i)*v(j)*(G(i,j)*sin(angle(i)-angle(j))-B(i,j)*cos(angle(i)-angle(j))); 234 | end 235 | end 236 | end 237 | 238 | totPload = 0.0; 239 | totQload = 0.0; 240 | totPinj = 0.; 241 | totQinj = 0.; 242 | for i = 1:numbus 243 | totPload = totPload + Pload(i)* baseMVA; 244 | totQload = totQload + Qload(i)* baseMVA; 245 | totPinj = totPinj + Pinj(i)* baseMVA; 246 | totQinj = totQinj + Qinj(i)* baseMVA; 247 | end 248 | totPload; 249 | totQload; 250 | totPinj; 251 | totQinj; 252 | 253 | totPgen = 0.0; 254 | totQgen = 0.0; 255 | for g = 1:numgen 256 | Pgen(g) = (Pinj(genbus(g)) + Pload(genbus(g))); 257 | Qgen(g) = (Qinj(genbus(g)) + Qload(genbus(g))); 258 | totPgen = totPgen + Pgen(g)* baseMVA; 259 | totQgen = totQgen + Qgen(g)* baseMVA; 260 | end 261 | totMWgen = totPgen; 262 | totMWload = totPload ; 263 | totMVARload = totQload ; 264 | 265 | % Place voltage mag and angle into a complex vector 266 | vr = v.*cos(angle') + sqrt(-1)*v.*sin(angle'); 267 | 268 | systemMWloss = 0.0; 269 | for j = 1:numline 270 | Iline = (vr(frombus(j)) - vr(tobus(j)))/(R(j)+sqrt(-1)*X(j)); 271 | lineMWloss = ( abs(Iline)^2 * R(j) )* baseMVA; 272 | systemMWloss = systemMWloss + lineMWloss; 273 | end 274 | 275 | Jinv = inv(J); 276 | 277 | if print >= 1 278 | fprintf(' %s \n',' '); 279 | fprintf(' %s %10.3f %s%10.3f \n','Power Flow with Total Pgen = ',totMWgen, ' Total Qgen = ',totQgen); 280 | fprintf(' %s %10.3f %s%10.3f\n', ' Total PLoad= ',totMWload,' Total Qload= ',totMVARload); 281 | fprintf(' %s %10.3f \n',' Total MW Losses = ',systemMWloss); 282 | fprintf(' %s \n',' '); 283 | end % end of print option print>1 284 | 285 | for i = 1:numbus 286 | busgen(i) = 0; 287 | end 288 | 289 | for g = 1:numgen 290 | busgen(genbus(g))=g; 291 | PgenMW(g) = Pgen(g)*baseMVA; 292 | QgenMW(g) = Qgen(g)*baseMVA; 293 | end 294 | 295 | for i = 1:numbus 296 | PloadMW(i) = Pload(i)*baseMVA; 297 | QloadMW(i) = Qload(i)*baseMVA; 298 | 299 | end 300 | 301 | for i = 1:numbus 302 | Vmag(i) = v(i); 303 | angle_deg(i) = angle(i)*180/pi; 304 | end 305 | 306 | if print >= 2 307 | fprintf(' %s \n',' '); 308 | fprintf(' %s \n','Bus Vmag angle Pgen Qgen Pload Qload To Bus Pline Qline '); 309 | for i = 1:numbus 310 | if i >9 311 | space = ''; 312 | else 313 | space = ' '; 314 | end 315 | 316 | if busgen(i) > 0 317 | fprintf(' %s%d %5.3f %6.3f %8.3f %8.3f %8.3f %8.3f \n',space,i,Vmag(i),angle_deg(i),PgenMW(busgen(i)),QgenMW(busgen(i)),PloadMW(i),QloadMW(i)); 318 | else 319 | fprintf(' %s%d %5.3f %6.3f %s%8.3f %8.3f \n',space,i,Vmag(i), angle_deg(i),' ',PloadMW(i),QloadMW(i)); 320 | end 321 | 322 | for j = 1:numline 323 | if frombus(j) == i; 324 | if tobus(j) >9 325 | space = ''; 326 | else 327 | space = ' '; 328 | end 329 | Iline = (vr(frombus(j)) - vr(tobus(j)))/(R(j)+sqrt(-1)*X(j)); 330 | Iline = Iline + vr(frombus(j))*(0.0 + sqrt(-1)*Bcap(j)*0.5); 331 | Sline = vr(frombus(j)) * conj(Iline); 332 | Pline = real(Sline)*baseMVA; 333 | Qline = imag(Sline)*baseMVA; 334 | fprintf(' %s%s %d %8.3f %8.3f \n',space,' ',tobus(j),Pline, Qline); 335 | elseif tobus(j) == i 336 | if frombus(j) >9 337 | space = ''; 338 | else 339 | space = ' '; 340 | end 341 | Iline = (vr(tobus(j)) - vr(frombus(j)))/(R(j)+sqrt(-1)*X(j)); 342 | Iline = Iline + vr(tobus(j))*(0.0 + sqrt(-1)*Bcap(j)*0.5); 343 | Sline = vr(tobus(j)) * conj(Iline); 344 | Pline = real(Sline)*baseMVA; 345 | Qline = imag(Sline)*baseMVA; 346 | fprintf(' %s%s %d %8.3f %8.3f \n',space,' ',frombus(j),Pline, Qline); 347 | end 348 | end 349 | end 350 | 351 | end % end of print option print>1 352 | 353 | PowerFlowInputData.baseMVA = baseMVA; 354 | PowerFlowInputData.Maxiter = Maxiter; 355 | PowerFlowInputData.powerflow_tolerance = powerflow_tolerance; 356 | PowerFlowInputData.numbus = numbus; 357 | PowerFlowInputData.numline = numline; 358 | PowerFlowInputData.numgen = numgen; 359 | PowerFlowInputData.numarea = numarea; 360 | PowerFlowInputData.refbus = refbus; 361 | PowerFlowInputData.frombus = frombus; 362 | PowerFlowInputData.tobus = tobus; 363 | PowerFlowInputData.R = R; 364 | PowerFlowInputData.X = X; 365 | PowerFlowInputData.Bcap = Bcap; 366 | PowerFlowInputData.Bustype = Bustype; 367 | PowerFlowInputData.Psched = Psched; 368 | PowerFlowInputData.Qsched = Qsched; 369 | PowerFlowInputData.Vsched = Vsched; 370 | PowerFlowInputData.Y = Y; 371 | PowerFlowInputData.G = G; 372 | PowerFlowInputData.B = B; 373 | 374 | PowerFlowSolution.Pinj = Pinj; 375 | PowerFlowSolution.Qinj = Qinj; 376 | PowerFlowSolution.vr = vr; 377 | PowerFlowSolution.Vmag = Vmag; 378 | PowerFlowSolution.Theta = angle; 379 | PowerFlowSolution.Bustype = Bustype; 380 | 381 | save('PowerFlowOutput', 'PowerFlowSolution','PowerFlowInputData'); 382 | 383 | 384 | -------------------------------------------------------------------------------- /run_all.m: -------------------------------------------------------------------------------- 1 | 2 | clear all 3 | clearvars 4 | clc 5 | 6 | % run all steps in the state estimator sequence 7 | 8 | run_powerflow 9 | display(' Pause, when you are ready hit Enter key') 10 | pause 11 | 12 | run_scada 13 | display(' Pause, when you are ready hit Enter key') 14 | pause 15 | 16 | run_estimator 17 | -------------------------------------------------------------------------------- /run_estimator.m: -------------------------------------------------------------------------------- 1 | 2 | 3 | % format long 4 | orthogonal_check = menu('Estimator Menu','1) Standard State Estimator','2) Orthogonal State Estimator'); 5 | detect_bad_data = menu('Estimator Menu','1) Detect Bad Data','2) Ignore Bad Data'); 6 | 7 | 8 | % Read power flow input data and power flow solution data 9 | load('PowerFlowOutput') 10 | % Read state estimator data input file 11 | load ('StateEstimatorData') 12 | 13 | baseMVA = PowerFlowInputData.baseMVA; 14 | tolerance = PowerFlowInputData.powerflow_tolerance; 15 | numbus = PowerFlowInputData.numbus; 16 | numline = PowerFlowInputData.numline; 17 | numgen = PowerFlowInputData.numgen; 18 | numarea = PowerFlowInputData.numarea; 19 | refbus = PowerFlowInputData.refbus; 20 | frombus = PowerFlowInputData.frombus; 21 | tobus = PowerFlowInputData.tobus; 22 | R = PowerFlowInputData.R; 23 | X = PowerFlowInputData.X; 24 | Bcap = PowerFlowInputData.Bcap; 25 | Bustype = PowerFlowInputData.Bustype; 26 | Psched = PowerFlowInputData.Psched; 27 | Qsched = PowerFlowInputData.Qsched; 28 | Vsched = PowerFlowInputData.Vsched; 29 | Y = PowerFlowInputData.Y; 30 | G = PowerFlowInputData.G; 31 | B = PowerFlowInputData.B; 32 | 33 | %Power Flow Solution: 34 | Pinj = PowerFlowSolution.Pinj; 35 | Qinj = PowerFlowSolution.Qinj; 36 | vr = PowerFlowSolution.vr; 37 | Vmag = PowerFlowSolution.Vmag; 38 | Theta = PowerFlowSolution.Theta; 39 | 40 | numVmeas = SCADA_voltage_meas_data.number_voltage_meas; 41 | Vmeasbus = SCADA_voltage_meas_data.voltage_meas_bus; 42 | VmeasNAME = SCADA_voltage_meas_data.voltage_meas_NAMES; 43 | Vmeassigma = SCADA_voltage_meas_data.voltage_meas_sigma; 44 | Vmeasstatus = SCADA_voltage_meas_data.voltage_meas_status; 45 | Vmeas_base_value = SCADA_voltage_meas_data.voltage_meas_base_value; 46 | Vmeas_measurement_value = SCADA_voltage_meas_data.voltage_meas_measurement_value; 47 | 48 | % numVmeas 49 | % Vmeasbus 50 | % VmeasNAMErun_estimator 51 | % Vmeassigma 52 | % Vmeasstatus 53 | % Vmeas_base_value 54 | % Vmeas_measurement_value 55 | 56 | 57 | numAmeas = SCADA_angle_meas_data.number_angle_meas; 58 | Ameasbus = SCADA_angle_meas_data.angle_meas_bus; 59 | AmeasNAME = SCADA_angle_meas_data.angle_meas_NAMES; 60 | Ameassigma = SCADA_angle_meas_data.angle_meas_sigma; 61 | Ameasstatus = SCADA_angle_meas_data.angle_meas_status; 62 | Ameas_base_value = SCADA_angle_meas_data.angle_meas_base_value; 63 | Ameas_measurement_value = SCADA_angle_meas_data.angle_meas_measurement_value; 64 | 65 | numImeas = SCADA_injection_meas_data.number_injection_meas; 66 | Imeasbus = SCADA_injection_meas_data.injection_meas_bus; 67 | ImeasNAME = SCADA_injection_meas_data.injection_meas_NAMES; 68 | ImeasPsigma = SCADA_injection_meas_data.injection_meas_Psigma; 69 | ImeasQsigma = SCADA_injection_meas_data.injection_meas_Qsigma; 70 | Imeasstatus = SCADA_injection_meas_data.injection_meas_status; 71 | Imeas_base_Pvalue = SCADA_injection_meas_data.injection_meas_base_Pvalue; 72 | Imeas_base_Qvalue = SCADA_injection_meas_data.injection_meas_base_Qvalue; 73 | Imeas_measurement_Pvalue = SCADA_injection_meas_data.injection_meas_measurement_Pvalue; 74 | Imeas_measurement_Qvalue = SCADA_injection_meas_data.injection_meas_measurement_Qvalue; 75 | 76 | numFmeas = SCADA_flow_meas_data.number_flow_meas; 77 | Fmeasbranch = SCADA_flow_meas_data.flow_meas_branch; 78 | Fmeasfrombus = SCADA_flow_meas_data.flow_meas_frombus; 79 | Fmeastobus = SCADA_flow_meas_data.flow_meas_tobus; 80 | FmeasNAME = SCADA_flow_meas_data.flow_meas_NAMES; 81 | FmeasPsigma = SCADA_flow_meas_data.flow_meas_Psigma; 82 | FmeasQsigma = SCADA_flow_meas_data.flow_meas_Qsigma; 83 | Fmeasstatus = SCADA_flow_meas_data.flow_meas_status; 84 | Fmeas_base_Pvalue = SCADA_flow_meas_data.flow_meas_base_Pvalue; 85 | Fmeas_base_Qvalue = SCADA_flow_meas_data.flow_meas_base_Qvalue; 86 | Fmeas_measurement_Pvalue = SCADA_flow_meas_data.flow_meas_measurement_Pvalue; 87 | Fmeas_measurement_Qvalue = SCADA_flow_meas_data.flow_meas_measurement_Qvalue; 88 | 89 | % num_measurements is the total number of measurements, but they might 90 | % not all be active 91 | num_measurements = numVmeas + numAmeas + 2*numImeas + 2*numFmeas; 92 | 93 | % State estimator convergence tolerance 94 | Est_tolerance = 0.0001; 95 | %significant level of the hypothesis test 96 | alpha=0.1; 97 | 98 | Vmag = ones(numbus,1); 99 | Theta = zeros(numbus,1); 100 | 101 | Norm_resid = zeros(num_measurements,1); 102 | 103 | fprintf(' Estimator iteration summary \n'); 104 | fprintf(' Iteration Residual Number Active Degrees of Bad Data Threshold Largest Bad\n'); 105 | fprintf(' J Measurements Freedom Tj Normalized Measurement\n'); 106 | fprintf(' Residual at\n'); 107 | 108 | 109 | 110 | % run first estimation then determine if bad data is detected 111 | if orthogonal_check==1 112 | Estimation_Loop 113 | DetectandIdentifyBadData 114 | else 115 | Estimation_Orthogonal_Loop 116 | %DetectandIdentifyBadData_Orthogonal 117 | DetectandIdentifyBadData 118 | end 119 | 120 | 121 | 122 | %Start Bad Data Detection Loop, if bad data detect falg is set 123 | % Detect and Identify bad measurements. 124 | 125 | if detect_bad_data == 1 126 | while J > TJ 127 | if orthogonal_check==1 128 | Estimation_Loop 129 | DetectandIdentifyBadData 130 | else 131 | Estimation_Orthogonal_Loop 132 | %DetectandIdentifyBadData_Orthogonal 133 | DetectandIdentifyBadData 134 | end 135 | end 136 | end 137 | 138 | display('Final State Estimator Result') 139 | 140 | %------------------------------------------------------------------------------------------------ 141 | 142 | fprintf(' %s \n',' '); 143 | fprintf(' %s \n','Measurement Base Case Value Measured Value Estimated Value '); 144 | fprintf(' %s \n','Name Status kV MW MVAR kV MW MVAR kV MW MVAR '); 145 | for i = 1:numbus 146 | fprintf(' %s %3d \n',' Bus',i); 147 | Vbase = 230.; 148 | MVABase = 100.; 149 | rad2deg = 180/pi; 150 | 151 | if numVmeas > 0 152 | for j = 1:numVmeas 153 | if Vmeasbus(j) == i 154 | fprintf(' %s %d %6.1f %6.1f %6.1f \n',VmeasNAME(j,:),Vmeasstatus(j),... 155 | Vmeas_base_value(j)*Vbase,... 156 | Vmeas_measurement_value(j)*Vbase, ... 157 | Vmeas_estimated_value(j)*Vbase); 158 | end 159 | end 160 | end 161 | 162 | if numAmeas > 0 163 | for j = 1:numAmeas 164 | if Ameasbus(j) == i 165 | fprintf(' %s %d %6.1f %6.1f %6.1f \n',AmeasNAME(j,:),Ameasstatus(j),... 166 | Ameas_base_value(j)*rad2deg,... 167 | Ameas_measurement_value(j)*rad2deg, ... 168 | Ameas_estimated_value(j)*rad2deg); 169 | end 170 | end 171 | end 172 | 173 | if numImeas > 0 174 | for j = 1:numImeas 175 | if Imeasbus(j) == i 176 | fprintf(' %s %d %6.1f %6.1f %6.1f %6.1f %6.1f %6.1f \n',ImeasNAME(j,:),Imeasstatus(j),... 177 | Imeas_base_Pvalue(j)*MVABase, Imeas_base_Qvalue(j)*MVABase, ... 178 | Imeas_measurement_Pvalue(j)*MVABase, Imeas_measurement_Qvalue(j)*MVABase, ... 179 | Imeas_estimated_Pvalue(j)*MVABase, Imeas_estimated_Qvalue(j)*MVABase); 180 | end 181 | end 182 | end 183 | 184 | if numFmeas >0 185 | for j = 1:numFmeas 186 | if Fmeasfrombus(j) == i ; 187 | fprintf(' %s %d %6.1f %6.1f %6.1f %6.1f %6.1f %6.1f \n',FmeasNAME(j,:),Fmeasstatus(j),... 188 | Fmeas_base_Pvalue(j)*MVABase, Fmeas_base_Qvalue(j)*MVABase, ... 189 | Fmeas_measurement_Pvalue(j)*MVABase, Fmeas_measurement_Qvalue(j)*MVABase, ... 190 | Fmeas_estimated_Pvalue(j)*MVABase, Fmeas_estimated_Qvalue(j)*MVABase); 191 | end 192 | end 193 | end 194 | 195 | end 196 | 197 | % end 198 | 199 | 200 | -------------------------------------------------------------------------------- /run_estimator_old.m: -------------------------------------------------------------------------------- 1 | format long 2 | 3 | % Read state estimator data input file 4 | load ('StateEstimatorData') 5 | 6 | 7 | tolerance = PowerFlowInputData.powerflow_tolerance; 8 | numbus = PowerFlowInputData.numbus; 9 | numline = PowerFlowInputData.numline; 10 | numgen = PowerFlowInputData.numgen; 11 | numarea = PowerFlowInputData.numarea; 12 | frombus = PowerFlowInputData.frombus; 13 | tobus = PowerFlowInputData.tobus; 14 | R = PowerFlowInputData.R; 15 | X = PowerFlowInputData.X; 16 | Bcap = PowerFlowInputData.Bcap; 17 | Bustype = PowerFlowInputData.Bustype; 18 | Psched = PowerFlowInputData.Psched; 19 | Qsched = PowerFlowInputData.Qsched; 20 | Vsched = PowerFlowInputData.Vsched; 21 | Y = PowerFlowInputData.Y; 22 | G = PowerFlowInputData.G; 23 | B = PowerFlowInputData.B; 24 | 25 | % % Initial values for Y supporting parallel lines 26 | % Y=zeros(numbus,numbus); 27 | % for j = 1:numline 28 | % Y(frombus(j),tobus(j))=Y(frombus(j),tobus(j))-1/(R(j)+sqrt(-1)*X(j)); 29 | % Y(tobus(j),frombus(j))=Y(tobus(j),frombus(j))-1/(R(j)+sqrt(-1)*X(j)); 30 | % end 31 | % for j = 1:numbus 32 | % Y(j,j) = -sum(Y(j,:)); 33 | % end 34 | % 35 | % % Getting the G, B before counting in Bcap. Since in our flow measurement, 36 | % % H_flow, the B and G in the formula do not include Bcap. 37 | % G0=-real(Y); 38 | % B0=-imag(Y); 39 | % 40 | % for j = 1:numline 41 | % Y(frombus(j),frombus(j))=Y(frombus(j),frombus(j))+sqrt(-1)*Bcap(j)/2; 42 | % Y(tobus(j),tobus(j))=Y(tobus(j),tobus(j))+sqrt(-1)*Bcap(j)/2; 43 | % end 44 | 45 | % G=real(Y); 46 | % %B=imag(Y); we used defintion Y=G-jB in this program. 47 | % B=-imag(Y); 48 | 49 | G0 = G; 50 | B0 = B; 51 | 52 | numVmeas = SCADA_voltage_meas_data.number_voltage_meas; 53 | Vmeasbus = SCADA_voltage_meas_data.voltage_meas_bus; 54 | Vmeassigma = SCADA_voltage_meas_data.voltage_meas_sigma; 55 | Vmeasvalue = SCADA_voltage_meas_data.voltage_meas_value; 56 | 57 | numAmeas = SCADA_angle_meas_data.number_angle_meas; 58 | Ameasbus = SCADA_angle_meas_data.angle_meas_bus; 59 | Ameassigma = SCADA_angle_meas_data.angle_meas_sigma; 60 | Ameasvalue = SCADA_angle_meas_data.angle_meas_value; 61 | 62 | numImeas = SCADA_injection_meas_data.number_injection_meas; 63 | Imeasbus = SCADA_injection_meas_data.injection_meas_bus; 64 | ImeasPsigma = SCADA_injection_meas_data.injection_meas_Psigma; 65 | ImeasQsigma = SCADA_injection_meas_data.injection_meas_Qsigma; 66 | ImeasPvalue = SCADA_injection_meas_data.injection_meas_Pvalue; 67 | ImeasQvalue = SCADA_injection_meas_data.injection_meas_Qvalue; 68 | 69 | 70 | numFmeas = SCADA_flow_meas_data.number_flow_meas; 71 | Fmeasbranch = SCADA_flow_meas_data.flow_meas_branch; 72 | Fmeasfrombus = SCADA_flow_meas_data.flow_meas_frombus; 73 | Fmeastobus = SCADA_flow_meas_data.flow_meas_tobus; 74 | FmeasPsigma = SCADA_flow_meas_data.flow_meas_Psigma; 75 | FmeasQsigma = SCADA_flow_meas_data.flow_meas_Qsigma; 76 | FmeasPvalue = SCADA_flow_meas_data.flow_meas_Pvalue; 77 | FmeasQvalue = SCADA_flow_meas_data.flow_meas_Qvalue; 78 | 79 | 80 | %significant level of the hypothesis test 81 | alpha=0.001; 82 | 83 | numFPmeas=numFmeas; 84 | numFQmeas=numFmeas; 85 | numIPmeas=numImeas; 86 | numIQmeas=numImeas; 87 | FPmeasbranch =Fmeasbranch; 88 | FQmeasbranch =Fmeasbranch; 89 | FPmeasfrombus=Fmeasfrombus; 90 | FQmeasfrombus=Fmeasfrombus; 91 | FPmeastobus=Fmeastobus; 92 | FQmeastobus=Fmeastobus; 93 | IPmeasbus=Imeasbus; 94 | IQmeasbus=Imeasbus; 95 | 96 | %Give ramdom value to TJ and J, and make sure J>TJ, so that we can enter 97 | %the threshold testing iteration loop. Later on TJ and J are determined by 98 | %the state estimator and the bad measurement detector. 99 | 100 | buildHmatrix 101 | 102 | %stop 103 | 104 | TJ=0; 105 | J=1; 106 | 107 | while J>TJ 108 | %Begin the detection and Identification Iteration Loop 109 | Nm=numFPmeas+numFQmeas+numIPmeas+numIQmeas; % number of measuremets 110 | Ns=2*(numbus-1); % number of states 111 | K=Nm-Ns; %degree of freedom 112 | %Calculate TJ, the threshold for J(x). 113 | TJ=2*K-chi2inv(alpha,K); 114 | 115 | 116 | maxiter=20; 117 | % degrees_per_radian= 57.29577951; 118 | iteration=1; 119 | badmeasurementbus=0; 120 | % Build data structure for voltage mag and angle and install flat Start 121 | for i=1:numbus 122 | z.vmag(i)=1.0; 123 | z.vang(i)=0.0; 124 | end 125 | 126 | for i = 1:numVmeas 127 | z.vmag(Vmeasbus(i)) = Vmeasvalue(i); 128 | end 129 | 130 | % Begin the iteration loop 131 | while (iteration0.0000000000000001 %set the critiriar which helps us decide when to stop the iterations. 353 | 354 | 355 | for i=2:numbus 356 | z.vmag(i)=z.vmag(i)+dX((i-1)*2-1); 357 | z.vang(i)=z.vang(i)+dX((i-1)*2); 358 | end 359 | 360 | else break 361 | end 362 | z.vang; 363 | z.vmag; 364 | 365 | 366 | % Caculate Residual again at the end of the iteration loop 367 | % Build residual J 368 | J=zeros(4,1); %Since Vmeasbus=1, Ameasbus=1, which means they are reference bus, there's no need to have residual for voltage and angle measurement. 369 | 370 | % Residual for flow measurements 371 | for i=1:numbus 372 | vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 373 | end 374 | for i = 1:numFPmeas 375 | a=FPmeasfrombus(i); 376 | b=FPmeastobus(i); 377 | Iline = (vr(a) - vr(b))/(R(FPmeasbranch(i))+sqrt(-1)*X(FPmeasbranch(i))); 378 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FPmeasbranch(i))*0.5); 379 | Sline = vr(a) * conj(Iline); 380 | FcalcPvalue(i) = real(Sline); 381 | J1(i)=(FmeasPvalue(i)- FcalcPvalue(i))^2/FmeasPsigma(i)^2; 382 | J(1)=J1(i)+J(1); 383 | end 384 | for i = 1:numFQmeas 385 | a=FQmeasfrombus(i); 386 | b=FQmeastobus(i); 387 | Iline = (vr(a) - vr(b))/(R(FQmeasbranch(i))+sqrt(-1)*X(FQmeasbranch(i))); 388 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FQmeasbranch(i))*0.5); 389 | Sline = vr(a) * conj(Iline); 390 | FcalcQvalue(i)= imag(Sline); 391 | J2(i)=(FmeasQvalue(i)-FcalcQvalue(i))^2/FmeasQsigma(i)^2; 392 | J(2)=J(2)+J2(i); 393 | end 394 | 395 | % Residual for ImeasPvalue 396 | IcalcPvalue=zeros(numIPmeas,1); 397 | IcalcQvalue=zeros(numIQmeas,1); 398 | for i=1:numIPmeas 399 | a = IPmeasbus(i); 400 | for b=1:numbus 401 | Pinj =z.vmag(a)*z.vmag(b)*(cos(z.vang(a)-z.vang(b))*G(a,b)-sin(z.vang(a)-z.vang(b))*B(a,b)); 402 | IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 403 | end 404 | J3(i)=(ImeasPvalue(i)-IcalcPvalue(i))^2/ImeasPsigma(i)^2; 405 | J(3)=J(3)+J3(i); 406 | end 407 | for i=1:numIQmeas 408 | a = IQmeasbus(i); 409 | for b=1:numbus 410 | Qinj =z.vmag(a)*z.vmag(b)*(sin(z.vang(a)-z.vang(b))*G(a,b)+cos(z.vang(a)-z.vang(b))*B(a,b)); 411 | IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 412 | end 413 | J4(i)=(ImeasQvalue(i)-IcalcQvalue(i))^2/ImeasQsigma(i)^2; 414 | J(4)=J(4)+J4(i); 415 | end 416 | J=sum(J); 417 | 418 | 419 | iteration=iteration+1; 420 | 421 | drawnow; 422 | 423 | end %end of state estimator iteration loop 424 | 425 | if J<=TJ 426 | break 427 | else 428 | % Detect and Identify bad measurements. 429 | % Calculate all f(i),y_norm(i) values for Nm measurements. 430 | for i=1:numbus 431 | vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 432 | end 433 | for i = 1:numFPmeas 434 | a=FPmeasfrombus(i); 435 | b=FPmeastobus(i); 436 | Iline = (vr(a) - vr(b))/(R(FPmeasbranch(i))+sqrt(-1)*X(FPmeasbranch(i))); 437 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FPmeasbranch(i))*0.5); 438 | Sline = vr(a) * conj(Iline); 439 | FcalcPvalue(i) = real(Sline); 440 | if sigmaPflow(i)>0.000001 441 | y1_norm(i)=(FmeasPvalue(i)-FcalcPvalue(i))/sigmaPflow(i); 442 | else 443 | y1_norm(i)=0; 444 | end 445 | end 446 | y1_norm=y1_norm(1:numFPmeas); 447 | for i = 1:numFQmeas 448 | a=FQmeasfrombus(i); 449 | b=FQmeastobus(i); 450 | Iline = (vr(a) - vr(b))/(R(FQmeasbranch(i))+sqrt(-1)*X(FQmeasbranch(i))); 451 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FQmeasbranch(i))*0.5); 452 | Sline = vr(a) * conj(Iline); 453 | FcalcQvalue(i)= imag(Sline); 454 | if sigmaQflow(i)>0.000001 455 | y2_norm(i)=(FmeasQvalue(i)-FcalcQvalue(i))/sigmaQflow(i); 456 | else 457 | y2_norm(i)=0; 458 | end 459 | end 460 | y2_norm=y2_norm(1:numFQmeas); 461 | 462 | if numImeas==0 463 | y3_norm=[]; 464 | y4_norm=[]; 465 | else 466 | IcalcPvalue=zeros(numIPmeas,1); 467 | IcalcQvalue=zeros(numIQmeas,1); 468 | for i=1:numIPmeas 469 | a = IPmeasbus(i); 470 | for b=1:numbus 471 | Pinj =z.vmag(a)*z.vmag(b)*(cos(z.vang(a)-z.vang(b))*G(a,b)-sin(z.vang(a)-z.vang(b))*B(a,b)); 472 | IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 473 | end 474 | if sigmaPinjec(i)>0.000001 475 | y3_norm(i)=(ImeasPvalue(i)-IcalcPvalue(i))/sigmaPinjec(i); 476 | else 477 | y3_norm(i)=0; 478 | end 479 | end 480 | y3_norm=y3_norm(1:numIPmeas); 481 | for i=1:numIQmeas 482 | a = IQmeasbus(i); 483 | for b=1:numbus 484 | Qinj = z.vmag(a)*z.vmag(b)*(sin(z.vang(a)-z.vang(b))*G(a,b)+cos(z.vang(a)-z.vang(b))*B(a,b)); 485 | IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 486 | end 487 | if sigmaQinjec(i)>0.000001 488 | y4_norm(i)=(ImeasQvalue(i)-IcalcQvalue(i))/sigmaQinjec(i); 489 | else 490 | y4_norm(i)=0; 491 | end 492 | end 493 | y4_norm=y4_norm(1:numIQmeas); 494 | end 495 | % Assume that numFPmeas, numFQmeas never go to zero. 496 | if numIPmeas==0 497 | y_norm=[y1_norm,y2_norm,y4_norm]; 498 | elseif numIQmeas==0 499 | y_norm=[y1_norm,y2_norm,y3_norm]; 500 | elseif numIPmeas==0&&numIQmeas==0 501 | y_norm=[y1_norm,y2_norm]; 502 | else 503 | y_norm=[y1_norm,y2_norm,y3_norm,y4_norm]; 504 | end 505 | 506 | 507 | % Display 508 | fprintf(' %s \n',' '); 509 | fprintf(' %s \n','Bus Voltage and Phase Angle Measurements: '); 510 | fprintf(' %s \n','-------------------------------------------------------------------------------------'); 511 | fprintf(' %s \n',' From Measured Calculated Difference Covariance of '); 512 | fprintf(' %s \n',' Bus Value Value Meansurement '); 513 | fprintf(' %s \n','-------------------------------------------------------------------------------------'); 514 | 515 | fprintf(' %s \n','Bus Voltage: '); 516 | for i=1:numVmeas 517 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',Vmeasbus(i), Vmeasvalue(i), z.vmag(Vmeasbus(i)),(Vmeasvalue(i) - z.vmag(Vmeasbus(i))), Vmeassigma(i)); 518 | end 519 | 520 | fprintf(' %s \n',' '); 521 | fprintf(' %s \n',' '); 522 | 523 | fprintf(' %s \n','Bus Phase Angle: '); 524 | 525 | for i=1:numAmeas 526 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',Ameasbus(i), Ameasvalue(i), z.vang(Ameasbus(i)),(Ameasvalue(i) - z.vang(Ameasbus(i))), Ameassigma(i)); 527 | end 528 | 529 | 530 | fprintf(' %s \n',' '); 531 | fprintf(' %s \n','-------------------------------------------------------------------------------------'); 532 | fprintf(' %s \n',' From To Measured Calculated Difference Covariance of '); 533 | fprintf(' %s \n',' Bus Bus Value Value Meansurement '); 534 | fprintf(' %s \n','-------------------------------------------------------------------------------------'); 535 | 536 | fprintf(' %s \n','Pflow: '); 537 | for i=1:numFPmeas 538 | fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',FPmeasfrombus(i),FPmeastobus(i),FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA,(FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,FmeasPsigma(i)); 539 | end 540 | fprintf(' %s \n',' '); 541 | fprintf(' %s \n',' '); 542 | 543 | fprintf(' %s \n','Qflow: '); 544 | for i=1:numFQmeas 545 | fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',FQmeasfrombus(i),FQmeastobus(i),FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA,(FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,FmeasQsigma(i)); 546 | end 547 | fprintf(' %s \n',' '); 548 | fprintf(' %s \n',' '); 549 | 550 | 551 | fprintf(' %s \n','Pinjection: '); 552 | for i=1:numIPmeas 553 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',IPmeasbus(i), ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA,(ImeasPvalue(i)-IcalcPvalue(i))*baseMVA, ImeasPsigma(i)); 554 | end 555 | 556 | fprintf(' %s \n',' '); 557 | fprintf(' %s \n',' '); 558 | fprintf(' %s \n','Qinjection: '); 559 | 560 | for i=1:numIQmeas 561 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',IQmeasbus(i), ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA,(ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,ImeasQsigma(i)); 562 | end 563 | 564 | 565 | fprintf(' %s \n',''); 566 | fprintf(' %s \n',''); 567 | fprintf(' %s \n',''); 568 | fprintf(' %s \n','-------------------'); 569 | fprintf(' %s \n','Bad Data Analysis'); 570 | fprintf(' %s \n','-----------------------------------------------------------------------'); 571 | fprintf(' %s \n','Measurement Measurement Caculated Difference Covariance y_norm '); 572 | fprintf(' %s \n','Number Value Value of error '); 573 | fprintf(' %s \n','-----------------------------------------------------------------------'); 574 | fprintf(' %s\n','Pflow measurements:'); 575 | for i=1:numFPmeas 576 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA, (FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,sigmaPflow(i),y1_norm(i)*baseMVA); 577 | end 578 | fprintf(' %s\n','Qflow measurements:'); 579 | for i=1:numFQmeas 580 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA, (FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,sigmaQflow(i),y2_norm(i)*baseMVA); 581 | end 582 | fprintf(' %s\n','Pinjection measurements:'); 583 | for i=1:numIPmeas 584 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', IPmeasbus(i), ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA, (ImeasPvalue(i)-IcalcPvalue(i))*baseMVA,sigmaPinjec(i),y3_norm(i)*baseMVA); 585 | end 586 | fprintf(' %s\n','Qinjection measurements:'); 587 | for i=1:numIQmeas 588 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', IQmeasbus(i), ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA, (ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,sigmaQinjec(i),y4_norm(i)*baseMVA); 589 | end 590 | %find the maximum y_norm(i), which is the prime suspect of error,both 591 | %the value and the index, putting them into Primesuspectvalue and 592 | %Primesuspectindex seperately. 593 | 594 | 595 | [Primesuspectvalue, Primesuspectindex]=max(abs(y_norm)) 596 | if Primesuspectvalue<0.03 597 | fprintf('There is no bad measurement anymore!\n'); 598 | break; 599 | end 600 | 601 | % Remove the bad measurement and display the bad measurement index and 602 | % value. 603 | if Primesuspectindex<=numFPmeas % the removed measurements is a P flow measurement 604 | fprintf('The bad measurement is a P flow measurement. %e\n'); 605 | fprintf('The bad measurement occurs at(the index of P flow measurements): %2d %s', Primesuspectindex,''); 606 | fprintf('Its value is:%e',Primesuspectvalue); 607 | fprintf(' %s \n',' '); 608 | numFPmeas=numFPmeas-1; 609 | if numFPmeas~=0 610 | for i=Primesuspectindex:(numFPmeas) 611 | FmeasPvalue(i)=FmeasPvalue(i+1); 612 | FmeasPsigma(i)=FmeasPsigma(i+1); 613 | FPmeasbranch(i)=FPmeasbranch(i+1); 614 | FPmeasfrombus(i)=FPmeasfrombus(i+1); 615 | FPmeastobus(i)=FPmeastobus(i+1); 616 | end 617 | end 618 | elseif Primesuspectindex>numFPmeas&&Primesuspectindex<=(numFPmeas+numFQmeas) 619 | fprintf('The bad measurement is a Q flow measurement. %e\n'); 620 | fprintf('The bad measurement occurs at (the index of Q flow measurements): %2d %s', (Primesuspectindex-numFPmeas),''); 621 | fprintf('Its value is:%e',Primesuspectvalue); 622 | fprintf(' %s \n',' '); 623 | numFQmeas=numFQmeas-1; 624 | if numFQmeas~=0 625 | for i=(Primesuspectindex-numFPmeas):(numFQmeas) 626 | FmeasQvalue(i)=FmeasQvalue(i+1); 627 | FmeasQsigma(i)=FmeasQsigma(i+1); 628 | FQmeasbranch(i)=FQmeasbranch(i+1); 629 | FQmeasfrombus(i)=FQmeasfrombus(i+1); 630 | FQmeastobus(i)=FQmeastobus(i+1); 631 | end 632 | end 633 | elseif Primesuspectindex>(numFPmeas+numFQmeas) && Primesuspectindex<=(numFPmeas+numFQmeas+numIPmeas) 634 | badmeasurementbus=Primesuspectindex-numFPmeas-numFQmeas; 635 | fprintf('The bad measurement is a P injection measurement. %e\n'); 636 | fprintf('The bad measurement occurs at bus: %2d %s', IPmeasbus(badmeasurementbus),''); 637 | fprintf('Its value is:%2d',Primesuspectvalue); 638 | fprintf(' %s \n',' '); 639 | numIPmeas=numIPmeas-1; 640 | if numIPmeas~=0 641 | for i=(Primesuspectindex-numFPmeas-numFQmeas):(numIPmeas) 642 | ImeasPvalue(i)=ImeasPvalue(i+1); 643 | ImeasPsigma(i)=ImeasPsigma(i+1); 644 | IPmeasbus(i)=IPmeasbus(i+1); 645 | end 646 | IPmeasbus=IPmeasbus(1:numIPmeas); 647 | end 648 | else 649 | badmeasurementbus=Primesuspectindex-numFPmeas-numFQmeas-numIPmeas; 650 | fprintf('The bad measurement is a Q injection measurement. %e\n'); 651 | fprintf('The bad measurement occurs at bus: %2d %s', IQmeasbus(badmeasurementbus), ''); 652 | fprintf('Its value is:%2d',Primesuspectvalue); 653 | fprintf(' %s \n',' '); 654 | numIQmeas=numIQmeas-1; 655 | if numIQmeas~=0 656 | for i=(Primesuspectindex-numFPmeas-numFQmeas-numIPmeas):(numIQmeas) 657 | ImeasQvalue(i)=ImeasQvalue(i+1); 658 | ImeasQsigma(i)=ImeasQsigma(i+1); 659 | IQmeasbus(i)=IQmeasbus(i+1); 660 | end 661 | IQmeasbus=IQmeasbus(1:numIQmeas); 662 | end 663 | end 664 | % Calculate all f(i),y_norm(i) values for Nm measurements. 665 | for i=1:numbus 666 | vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 667 | end 668 | for i = 1:numFPmeas 669 | a=FPmeasfrombus(i); 670 | b=FPmeastobus(i); 671 | % for j = 1:numline 672 | % if frombus(j) == a & tobus(j)==b 673 | % break 674 | % elseif frombus(j) == b & tobus(j)==a 675 | % break 676 | % end 677 | % end 678 | Iline = (vr(a) - vr(b))/(R(FPmeasbranch(i))+sqrt(-1)*X(FPmeasbranch(i))); 679 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FPmeasbranch(i))*0.5); 680 | Sline = vr(a) * conj(Iline); 681 | FcalcPvalue(i) = real(Sline); 682 | y1_norm(i)=(FmeasPvalue(i)-FcalcPvalue(i))/sigmaPflow(i); 683 | 684 | end 685 | y1_norm=y1_norm(1:numFPmeas); 686 | 687 | for i = 1:numFQmeas 688 | a=FQmeasfrombus(i); 689 | b=FQmeastobus(i); 690 | % for j = 1:numline 691 | % if frombus(j) == a & tobus(j)==b 692 | % break 693 | % elseif frombus(j) == b & tobus(j)==a 694 | % break 695 | % end 696 | % end 697 | Iline = (vr(a) - vr(b))/(R(FQmeasbranch(i))+sqrt(-1)*X(FQmeasbranch(i))); 698 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FQmeasbranch(i))*0.5); 699 | Sline = vr(a) * conj(Iline); 700 | FcalcQvalue(i)= imag(Sline); 701 | %if FmeasQvalue(i)-FcalcQvalue(i)<0.00001 702 | % y2_norm(i)=0; 703 | %else 704 | y2_norm(i)=(FmeasQvalue(i)-FcalcQvalue(i))/sigmaQflow(i); 705 | 706 | % end 707 | end 708 | y2_norm=y2_norm(1:numFQmeas); 709 | 710 | IcalcPvalue=zeros(numIPmeas,1); 711 | IcalcQvalue=zeros(numIQmeas,1); 712 | for i=1:numIPmeas 713 | a = IPmeasbus(i); 714 | for b=1:numbus 715 | Pinj =z.vmag(a)*z.vmag(b)*(cos(z.vang(a)-z.vang(b))*G(a,b)-sin(z.vang(a)-z.vang(b))*B(a,b)); 716 | IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 717 | end 718 | y3_norm(i)=(ImeasPvalue(i)-IcalcPvalue(i))/sigmaPinjec(i); 719 | 720 | end 721 | y3_norm=y3_norm(1:numIPmeas); 722 | for i=1:numIQmeas 723 | a = IQmeasbus(i); 724 | for b=1:numbus 725 | Qinj = z.vmag(a)*z.vmag(b)*(sin(z.vang(a)-z.vang(b))*G(a,b)+cos(z.vang(a)-z.vang(b))*B(a,b)); 726 | IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 727 | end 728 | y4_norm(i)=(ImeasQvalue(i)-IcalcQvalue(i))/sigmaQinjec(i); 729 | 730 | end 731 | y4_norm=y4_norm(1:numIQmeas); 732 | % Assume that numFPmeas, numFQmeas never go to zero. 733 | if numIPmeas==0 734 | y_norm=[y1_norm,y2_norm,y4_norm]; 735 | elseif numIQmeas==0 736 | y_norm=[y1_norm,y2_norm,y3_norm]; 737 | elseif numIPmeas==0&&numIQmeas==0 738 | y_norm=[y1_norm,y2_norm]; 739 | else 740 | y_norm=[y1_norm,y2_norm,y3_norm,y4_norm]; 741 | end 742 | end % end "Detect and Identify bad measurements" process 743 | 744 | end % end threshold iteration loop 745 | 746 | %Recalculate y_norm 747 | for i = 1:numFPmeas 748 | y1_norm(i)=(FmeasPvalue(i)-FcalcPvalue(i))/sigmaPflow(i); 749 | end 750 | for i=1:numFQmeas 751 | y2_norm(i)=(FmeasQvalue(i)-FcalcQvalue(i))/sigmaQflow(i); 752 | end 753 | for i=1:numIPmeas 754 | y3_norm(i)=(ImeasPvalue(i)-IcalcPvalue(i))/sigmaPinjec(i); 755 | end 756 | for i=1:numIQmeas 757 | y4_norm(i)=(ImeasQvalue(i)-IcalcQvalue(i))/sigmaQinjec(i); 758 | end 759 | 760 | fprintf(' %s \n',' '); 761 | fprintf ('The final value of J is %d\n' , J) 762 | fprintf ('The final value of TJ is %d\n' , TJ) 763 | % Display 764 | fprintf(' %s \n',' '); 765 | fprintf(' %s \n','-----------------------------------------------------------------------------------'); 766 | fprintf(' %s \n','From To Measured Calculated Difference Covariance of '); 767 | fprintf(' %s \n','Bus Bus Value Value Meansurement '); 768 | fprintf(' %s \n','-----------------------------------------------------------------------------------'); 769 | 770 | fprintf(' %s \n','Pflow: '); 771 | for i=1:numFPmeas 772 | fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',FPmeasfrombus(i),FPmeastobus(i),FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA,(FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,FmeasPsigma(i)); 773 | end 774 | fprintf(' %s \n',' '); 775 | fprintf(' %s \n',' '); 776 | 777 | fprintf(' %s \n','Qflow: '); 778 | for i=1:numFQmeas 779 | fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',FQmeasfrombus(i),FQmeastobus(i),FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA,(FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,FmeasQsigma(i)); 780 | end 781 | fprintf(' %s \n',' '); 782 | fprintf(' %s \n',' '); 783 | 784 | 785 | fprintf(' %s \n','Pinjection: '); 786 | for i=1:numIPmeas 787 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',IPmeasbus(i),ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA,(ImeasPvalue(i)-IcalcPvalue(i))*baseMVA, ImeasPsigma(i)); 788 | end 789 | 790 | fprintf(' %s \n',' '); 791 | fprintf(' %s \n',' '); 792 | fprintf(' %s \n','Qinjection: '); 793 | 794 | for i=1:numIQmeas 795 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',IQmeasbus(i),ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA,(ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,ImeasQsigma(i)); 796 | end 797 | 798 | 799 | fprintf(' %s \n',''); 800 | fprintf(' %s \n',''); 801 | fprintf(' %s \n',''); 802 | fprintf(' %s \n','-------------------'); 803 | fprintf(' %s \n','Bad Data Analysis'); 804 | fprintf(' %s \n','-----------------------------------------------------------------------'); 805 | fprintf(' %s \n','Measurement Measurement Caculated Difference Covariance y_norm '); 806 | fprintf(' %s \n','Number Value Value of error '); 807 | fprintf(' %s \n','-----------------------------------------------------------------------'); 808 | fprintf(' %s\n','Pflow measurements:'); 809 | for i=1:numFPmeas 810 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA, (FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,sigmaPflow(i),y1_norm(i)*baseMVA); 811 | end 812 | fprintf(' %s\n','Qflow measurements:'); 813 | for i=1:numFQmeas 814 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA, (FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,sigmaQflow(i),y2_norm(i)*baseMVA); 815 | end 816 | fprintf(' %s\n','Pinjection measurements:'); 817 | for i=1:numIPmeas 818 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', IPmeasbus(i), ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA, (ImeasPvalue(i)-IcalcPvalue(i))*baseMVA,sigmaPinjec(i),y3_norm(i)*baseMVA); 819 | end 820 | fprintf(' %s\n','Qinjection measurements:'); 821 | for i=1:numIQmeas 822 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', IQmeasbus(i), ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA, (ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,sigmaQinjec(i),y4_norm(i)*baseMVA); 823 | end 824 | 825 | %Caculate all the flow and injection values from the voltages magnitudes and angles obtained from the state estimator. 826 | for i=1:numbus 827 | vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 828 | end 829 | 830 | 831 | for i = 1:numline 832 | a=frombus(i); 833 | b=tobus(i); 834 | Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 835 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 836 | Sline = vr(a) * conj(Iline); 837 | FcalcPvalue(i) = real(Sline); 838 | end 839 | for i=1:numline 840 | a=tobus(i); 841 | b=frombus(i); 842 | Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 843 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 844 | Sline = vr(a) * conj(Iline); 845 | FcalcPvalue(i+numline) = real(Sline); 846 | end 847 | for i = 1:numline 848 | a=frombus(i); 849 | b=tobus(i); 850 | Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 851 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 852 | Sline = vr(a) * conj(Iline); 853 | FcalcQvalue(i)= imag(Sline); 854 | end 855 | 856 | for i = 1:numline 857 | a=tobus(i); 858 | b=frombus(i); 859 | Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 860 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 861 | Sline = vr(a) * conj(Iline); 862 | FcalcQvalue(i+numline)= imag(Sline); 863 | end 864 | IcalcPvalue=zeros(numbus,1); 865 | IcalcQvalue=zeros(numbus,1); 866 | for i=1:numbus 867 | for b=1:numbus 868 | Pinj =z.vmag(i)*z.vmag(b)*(cos(z.vang(i)-z.vang(b))*G(i,b)-sin(z.vang(i)-z.vang(b))*B(i,b)); 869 | IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 870 | end 871 | end 872 | 873 | for i=1:numbus 874 | for b=1:numbus 875 | Qinj = z.vmag(i)*z.vmag(b)*(sin(z.vang(i)-z.vang(b))*G(i,b)+cos(z.vang(i)-z.vang(b))*B(i,b)); 876 | IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 877 | end 878 | end 879 | 880 | 881 | % Display AC state estimator result 882 | fprintf(' %s \n',' '); 883 | fprintf(' %s \n','State Estimator Solution:'); 884 | fprintf(' %s \n',' '); 885 | fprintf(' %s \n','Bus Volt. Volt. Mw Mvar To Mw Mvar '); 886 | fprintf(' %s \n','Number Mag. Angle Injec. Injec. Bus Flow Flow '); 887 | fprintf(' %s \n','------ ------ ------ -------- -------- ---- ------- ------- '); 888 | 889 | for i=1:numbus 890 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f \n',i, z.vmag(i),z.vang(i),IcalcPvalue(i)*baseMVA,IcalcQvalue(i)*baseMVA); 891 | for j=1:numline 892 | a=frombus(j); 893 | b=tobus(j); 894 | if b==i 895 | fprintf(' %5d %8.3f %8.3f \n', a, FcalcPvalue(j+numline)*baseMVA, FcalcQvalue(j+numline)*baseMVA); 896 | elseif a==i 897 | fprintf(' %5d %8.3f %8.3f \n', b, FcalcPvalue(j)*baseMVA, FcalcQvalue(j)*baseMVA); 898 | end 899 | end 900 | end 901 | -------------------------------------------------------------------------------- /run_estimator_orthogonal.m: -------------------------------------------------------------------------------- 1 | format long 2 | 3 | % format long 4 | 5 | %detect_bad_data = menu('Estimator Menu','1) Detect Bad Data','2) Ignore Bad Data'); 6 | 7 | 8 | % Read power flow input data and power flow solution data 9 | load('PowerFlowOutput') 10 | % Read state estimator data input file 11 | load ('StateEstimatorData') 12 | 13 | % Read state estimator data input file 14 | load ('StateEstimatorData') 15 | 16 | 17 | %%tolerance = PowerFlowInputData.tolerance; 18 | numbus = PowerFlowInputData.numbus; 19 | numline = PowerFlowInputData.numline; 20 | numgen = PowerFlowInputData.numgen; 21 | numarea = PowerFlowInputData.numarea; 22 | frombus = PowerFlowInputData.frombus; 23 | tobus = PowerFlowInputData.tobus; 24 | R = PowerFlowInputData.R; 25 | X = PowerFlowInputData.X; 26 | Bcap = PowerFlowInputData.Bcap; 27 | Bustype = PowerFlowInputData.Bustype; 28 | Psched = PowerFlowInputData.Psched; 29 | Qsched = PowerFlowInputData.Qsched; 30 | Vsched = PowerFlowInputData.Vsched; 31 | 32 | % Initial values for Y supporting parallel lines 33 | Y=zeros(numbus,numbus); 34 | for j = 1:numline 35 | Y(frombus(j),tobus(j))=Y(frombus(j),tobus(j))-1/(R(j)+sqrt(-1)*X(j)); 36 | Y(tobus(j),frombus(j))=Y(tobus(j),frombus(j))-1/(R(j)+sqrt(-1)*X(j)); 37 | end 38 | for j = 1:numbus 39 | Y(j,j) = -sum(Y(j,:)); 40 | end 41 | 42 | % Getting the G, B before counting in Bcap. Since in our flow measurement, 43 | % H_flow, the B and G in the formula do not include Bcap. 44 | G0=-real(Y); 45 | B0=-imag(Y); 46 | 47 | for j = 1:numline 48 | Y(frombus(j),frombus(j))=Y(frombus(j),frombus(j))+sqrt(-1)*Bcap(j)/2; 49 | Y(tobus(j),tobus(j))=Y(tobus(j),tobus(j))+sqrt(-1)*Bcap(j)/2; 50 | end 51 | 52 | G=real(Y); 53 | %B=imag(Y); we used defintion Y=G-jB in this program. 54 | B=-imag(Y); 55 | 56 | numVmeas = SCADA_voltage_meas_data.number_voltage_meas; 57 | Vmeasbus = SCADA_voltage_meas_data.voltage_meas_bus; 58 | Vmeassigma = SCADA_voltage_meas_data.voltage_meas_sigma; 59 | %%Vmeasvalue = SCADA_voltage_meas_data.voltage_meas_value; 60 | 61 | numAmeas = SCADA_angle_meas_data.number_angle_meas; 62 | Ameasbus = SCADA_angle_meas_data.angle_meas_bus; 63 | Ameassigma = SCADA_angle_meas_data.angle_meas_sigma; 64 | %%Ameasvalue = SCADA_angle_meas_data.angle_meas_value; 65 | 66 | numImeas = SCADA_injection_meas_data.number_injection_meas; 67 | Imeasbus = SCADA_injection_meas_data.injection_meas_bus; 68 | ImeasPsigma = SCADA_injection_meas_data.injection_meas_Psigma; 69 | ImeasQsigma = SCADA_injection_meas_data.injection_meas_Qsigma; 70 | %%ImeasPvalue = SCADA_injection_meas_data.injection_meas_Pvalue; 71 | %%ImeasQvalue = SCADA_injection_meas_data.injection_meas_Qvalue; 72 | 73 | 74 | numFmeas = SCADA_flow_meas_data.number_flow_meas; 75 | Fmeasbranch = SCADA_flow_meas_data.flow_meas_branch; 76 | Fmeasfrombus = SCADA_flow_meas_data.flow_meas_frombus; 77 | Fmeastobus = SCADA_flow_meas_data.flow_meas_tobus; 78 | FmeasPsigma = SCADA_flow_meas_data.flow_meas_Psigma; 79 | FmeasQsigma = SCADA_flow_meas_data.flow_meas_Qsigma; 80 | %%FmeasPvalue = SCADA_flow_meas_data.flow_meas_Pvalue; 81 | %%FmeasQvalue = SCADA_flow_meas_data.flow_meas_Qvalue; 82 | 83 | 84 | %significant level of the hypothesis test 85 | alpha=0.001; 86 | 87 | numFPmeas=numFmeas; 88 | numFQmeas=numFmeas; 89 | numIPmeas=numImeas; 90 | numIQmeas=numImeas; 91 | FPmeasbranch =Fmeasbranch; 92 | FQmeasbranch =Fmeasbranch; 93 | FPmeasfrombus=Fmeasfrombus; 94 | FQmeasfrombus=Fmeasfrombus; 95 | FPmeastobus=Fmeastobus; 96 | FQmeastobus=Fmeastobus; 97 | IPmeasbus=Imeasbus; 98 | IQmeasbus=Imeasbus; 99 | %Give ramdom value to TJ and J, ank make sure J>TJ, so that we can enter 100 | %the threshold testing iteration loop.Later on TJ and J are determined by 101 | %the state estimator and the bad measurement detector. 102 | TJ=0; 103 | J=1; 104 | 105 | while J>TJ 106 | %Begin the detection and Identification Iteration Loop 107 | Nm=numFPmeas+numFQmeas+numIPmeas+numIQmeas; % number of measuremets 108 | Ns=2*(numbus-1); % number of states 109 | %degree of freedom 110 | K=Nm-Ns; 111 | %Calculate TJ, the threshold for J(x). 112 | TJ=2*K-chi2inv(alpha,K); 113 | 114 | 115 | maxiter=20; 116 | % degrees_per_radian= 57.29577951; 117 | iteration=1; 118 | badmeasurementbus=0; 119 | % Build data structure for voltage mag and angle and install flat Start 120 | for i=1:numbus 121 | z.vmag(i)=1.0; 122 | z.vang(i)=0.0; 123 | end 124 | 125 | for i = 1:numVmeas 126 | z.vmag(Vmeasbus(i)) = Vmeasvalue(i); 127 | end 128 | 129 | % Begin the iteration loop 130 | while (iteration0.0000000000000001 %set the critiriar which helps us decide when to stop the iterations. 376 | 377 | 378 | for i=2:numbus 379 | z.vmag(i)=z.vmag(i)+dX((i-1)*2-1); 380 | z.vang(i)=z.vang(i)+dX((i-1)*2); 381 | end 382 | 383 | else break 384 | end 385 | z.vang; 386 | z.vmag; 387 | 388 | 389 | % Caculate Residual again at the end of the iteration loop 390 | % Build residual J 391 | J=zeros(4,1); %Since Vmeasbus=1, Ameasbus=1, which means they are reference bus, there's no need to have residual for voltage and angle measurement. 392 | 393 | % Residual for flow measurements 394 | for i=1:numbus 395 | vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 396 | end 397 | for i = 1:numFPmeas 398 | a=FPmeasfrombus(i); 399 | b=FPmeastobus(i); 400 | Iline = (vr(a) - vr(b))/(R(FPmeasbranch(i))+sqrt(-1)*X(FPmeasbranch(i))); 401 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FPmeasbranch(i))*0.5); 402 | Sline = vr(a) * conj(Iline); 403 | FcalcPvalue(i) = real(Sline); 404 | J1(i)=(FmeasPvalue(i)- FcalcPvalue(i))^2/FmeasPsigma(i)^2; 405 | J(1)=J1(i)+J(1); 406 | end 407 | for i = 1:numFQmeas 408 | a=FQmeasfrombus(i); 409 | b=FQmeastobus(i); 410 | Iline = (vr(a) - vr(b))/(R(FQmeasbranch(i))+sqrt(-1)*X(FQmeasbranch(i))); 411 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FQmeasbranch(i))*0.5); 412 | Sline = vr(a) * conj(Iline); 413 | FcalcQvalue(i)= imag(Sline); 414 | J2(i)=(FmeasQvalue(i)-FcalcQvalue(i))^2/FmeasQsigma(i)^2; 415 | J(2)=J(2)+J2(i); 416 | end 417 | 418 | % Residual for ImeasPvalue 419 | IcalcPvalue=zeros(numIPmeas,1); 420 | IcalcQvalue=zeros(numIQmeas,1); 421 | for i=1:numIPmeas 422 | a = IPmeasbus(i); 423 | for b=1:numbus 424 | Pinj =z.vmag(a)*z.vmag(b)*(cos(z.vang(a)-z.vang(b))*G(a,b)-sin(z.vang(a)-z.vang(b))*B(a,b)); 425 | IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 426 | end 427 | J3(i)=(ImeasPvalue(i)-IcalcPvalue(i))^2/ImeasPsigma(i)^2; 428 | J(3)=J(3)+J3(i); 429 | end 430 | for i=1:numIQmeas 431 | a = IQmeasbus(i); 432 | for b=1:numbus 433 | Qinj =z.vmag(a)*z.vmag(b)*(sin(z.vang(a)-z.vang(b))*G(a,b)+cos(z.vang(a)-z.vang(b))*B(a,b)); 434 | IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 435 | end 436 | J4(i)=(ImeasQvalue(i)-IcalcQvalue(i))^2/ImeasQsigma(i)^2; 437 | J(4)=J(4)+J4(i); 438 | end 439 | J=sum(J); 440 | 441 | 442 | iteration=iteration+1; 443 | 444 | drawnow; 445 | 446 | end %end of state estimator iteration loop 447 | 448 | if J<=TJ 449 | break 450 | else 451 | % Detect and Identify bad measurements. 452 | % Calculate all f(i),y_norm(i) values for Nm measurements. 453 | for i=1:numbus 454 | vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 455 | end 456 | for i = 1:numFPmeas 457 | a=FPmeasfrombus(i); 458 | b=FPmeastobus(i); 459 | Iline = (vr(a) - vr(b))/(R(FPmeasbranch(i))+sqrt(-1)*X(FPmeasbranch(i))); 460 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FPmeasbranch(i))*0.5); 461 | Sline = vr(a) * conj(Iline); 462 | FcalcPvalue(i) = real(Sline); 463 | if sigmaPflow(i)>0.000001 464 | y1_norm(i)=(FmeasPvalue(i)-FcalcPvalue(i))/sigmaPflow(i); 465 | else 466 | y1_norm(i)=0; 467 | end 468 | end 469 | y1_norm=y1_norm(1:numFPmeas); 470 | for i = 1:numFQmeas 471 | a=FQmeasfrombus(i); 472 | b=FQmeastobus(i); 473 | Iline = (vr(a) - vr(b))/(R(FQmeasbranch(i))+sqrt(-1)*X(FQmeasbranch(i))); 474 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FQmeasbranch(i))*0.5); 475 | Sline = vr(a) * conj(Iline); 476 | FcalcQvalue(i)= imag(Sline); 477 | if sigmaQflow(i)>0.000001 478 | y2_norm(i)=(FmeasQvalue(i)-FcalcQvalue(i))/sigmaQflow(i); 479 | else 480 | y2_norm(i)=0; 481 | end 482 | end 483 | y2_norm=y2_norm(1:numFQmeas); 484 | 485 | if numImeas==0 486 | y3_norm=[]; 487 | y4_norm=[]; 488 | else 489 | IcalcPvalue=zeros(numIPmeas,1); 490 | IcalcQvalue=zeros(numIQmeas,1); 491 | for i=1:numIPmeas 492 | a = IPmeasbus(i); 493 | for b=1:numbus 494 | Pinj =z.vmag(a)*z.vmag(b)*(cos(z.vang(a)-z.vang(b))*G(a,b)-sin(z.vang(a)-z.vang(b))*B(a,b)); 495 | IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 496 | end 497 | if sigmaPinjec(i)>0.000001 498 | y3_norm(i)=(ImeasPvalue(i)-IcalcPvalue(i))/sigmaPinjec(i); 499 | else 500 | y3_norm(i)=0; 501 | end 502 | end 503 | y3_norm=y3_norm(1:numIPmeas); 504 | for i=1:numIQmeas 505 | a = IQmeasbus(i); 506 | for b=1:numbus 507 | Qinj = z.vmag(a)*z.vmag(b)*(sin(z.vang(a)-z.vang(b))*G(a,b)+cos(z.vang(a)-z.vang(b))*B(a,b)); 508 | IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 509 | end 510 | if sigmaQinjec(i)>0.000001 511 | y4_norm(i)=(ImeasQvalue(i)-IcalcQvalue(i))/sigmaQinjec(i); 512 | else 513 | y4_norm(i)=0; 514 | end 515 | end 516 | y4_norm=y4_norm(1:numIQmeas); 517 | end 518 | % Assume that numFPmeas, numFQmeas never go to zero. 519 | if numIPmeas==0 520 | y_norm=[y1_norm,y2_norm,y4_norm]; 521 | elseif numIQmeas==0 522 | y_norm=[y1_norm,y2_norm,y3_norm]; 523 | elseif numIPmeas==0&&numIQmeas==0 524 | y_norm=[y1_norm,y2_norm]; 525 | else 526 | y_norm=[y1_norm,y2_norm,y3_norm,y4_norm]; 527 | end 528 | 529 | 530 | % Display 531 | fprintf(' %s \n',' '); 532 | fprintf(' %s \n','--------------------------------------------------------------------------------------'); 533 | fprintf(' %s \n',' From To Measured Calculated Difference Covariance of '); 534 | fprintf(' %s \n',' Bus Bus Value Value Meansurement '); 535 | fprintf(' %s \n','--------------------------------------------------------------------------------------'); 536 | 537 | fprintf(' %s \n','Pflow: '); 538 | for i=1:numFPmeas 539 | fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',FPmeasfrombus(i),FPmeastobus(i),FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA,(FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,FmeasPsigma(i)); 540 | end 541 | fprintf(' %s \n',' '); 542 | fprintf(' %s \n',' '); 543 | 544 | fprintf(' %s \n','Qflow: '); 545 | for i=1:numFQmeas 546 | fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',FQmeasfrombus(i),FQmeastobus(i),FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA,(FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,FmeasQsigma(i)); 547 | end 548 | fprintf(' %s \n',' '); 549 | fprintf(' %s \n',' '); 550 | 551 | 552 | fprintf(' %s \n','Pinjection: '); 553 | for i=1:numIPmeas 554 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',IPmeasbus(i), ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA,(ImeasPvalue(i)-IcalcPvalue(i))*baseMVA, ImeasPsigma(i)); 555 | end 556 | 557 | fprintf(' %s \n',' '); 558 | fprintf(' %s \n',' '); 559 | fprintf(' %s \n','Qinjection: '); 560 | 561 | for i=1:numIQmeas 562 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',IQmeasbus(i), ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA,(ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,ImeasQsigma(i)); 563 | end 564 | 565 | 566 | fprintf(' %s \n',''); 567 | fprintf(' %s \n',''); 568 | fprintf(' %s \n',''); 569 | fprintf(' %s \n','-------------------'); 570 | fprintf(' %s \n','Bad Data Analysis'); 571 | fprintf(' %s \n','-----------------------------------------------------------------------'); 572 | fprintf(' %s \n','Measurement Measurement Caculated Difference Covariance y_norm '); 573 | fprintf(' %s \n','Number Value Value of error '); 574 | fprintf(' %s \n','-----------------------------------------------------------------------'); 575 | fprintf(' %s\n','Pflow measurements:'); 576 | for i=1:numFPmeas 577 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA, (FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,sigmaPflow(i),y1_norm(i)*baseMVA); 578 | end 579 | fprintf(' %s\n','Qflow measurements:'); 580 | for i=1:numFQmeas 581 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA, (FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,sigmaQflow(i),y2_norm(i)*baseMVA); 582 | end 583 | fprintf(' %s\n','Pinjection measurements:'); 584 | for i=1:numIPmeas 585 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', IPmeasbus(i), ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA, (ImeasPvalue(i)-IcalcPvalue(i))*baseMVA,sigmaPinjec(i),y3_norm(i)*baseMVA); 586 | end 587 | fprintf(' %s\n','Qinjection measurements:'); 588 | for i=1:numIQmeas 589 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', IQmeasbus(i), ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA, (ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,sigmaQinjec(i),y4_norm(i)*baseMVA); 590 | end 591 | %find the maximum y_norm(i), which is the prime suspect of error,both 592 | %the value and the index, putting them into Primesuspectvalue and 593 | %Primesuspectindex seperately. 594 | 595 | 596 | [Primesuspectvalue, Primesuspectindex]=max(abs(y_norm)) 597 | if Primesuspectvalue<0.03 598 | fprintf('There is no bad measurement anymore!\n'); 599 | break; 600 | end 601 | 602 | % Remove the bad measurement and display the bad measurement index and 603 | % value. 604 | if Primesuspectindex<=numFPmeas % the removed measurements is a P flow measurement 605 | fprintf('The bad measurement is a P flow measurement. %e\n'); 606 | fprintf('The bad measurement occurs at(the index of P flow measurements): %2d %s', Primesuspectindex,''); 607 | fprintf('Its value is:%e',Primesuspectvalue); 608 | fprintf(' %s \n',' '); 609 | numFPmeas=numFPmeas-1; 610 | if numFPmeas~=0 611 | for i=Primesuspectindex:(numFPmeas) 612 | FmeasPvalue(i)=FmeasPvalue(i+1); 613 | FmeasPsigma(i)=FmeasPsigma(i+1); 614 | FPmeasbranch(i)=FPmeasbranch(i+1); 615 | FPmeasfrombus(i)=FPmeasfrombus(i+1); 616 | FPmeastobus(i)=FPmeastobus(i+1); 617 | end 618 | end 619 | elseif Primesuspectindex>numFPmeas&&Primesuspectindex<=(numFPmeas+numFQmeas) 620 | fprintf('The bad measurement is a Q flow measurement. %e\n'); 621 | fprintf('The bad measurement occurs at (the index of Q flow measurements): %2d %s', (Primesuspectindex-numFPmeas),''); 622 | fprintf('Its value is:%e',Primesuspectvalue); 623 | fprintf(' %s \n',' '); 624 | numFQmeas=numFQmeas-1; 625 | if numFQmeas~=0 626 | for i=(Primesuspectindex-numFPmeas):(numFQmeas) 627 | FmeasQvalue(i)=FmeasQvalue(i+1); 628 | FmeasQsigma(i)=FmeasQsigma(i+1); 629 | FQmeasbranch(i)=FQmeasbranch(i+1); 630 | FQmeasfrombus(i)=FQmeasfrombus(i+1); 631 | FQmeastobus(i)=FQmeastobus(i+1); 632 | end 633 | end 634 | elseif Primesuspectindex>(numFPmeas+numFQmeas) && Primesuspectindex<=(numFPmeas+numFQmeas+numIPmeas) 635 | badmeasurementbus=Primesuspectindex-numFPmeas-numFQmeas; 636 | fprintf('The bad measurement is a P injection measurement. %e\n'); 637 | fprintf('The bad measurement occurs at bus: %2d %s', IPmeasbus(badmeasurementbus),''); 638 | fprintf('Its value is:%2d',Primesuspectvalue); 639 | fprintf(' %s \n',' '); 640 | numIPmeas=numIPmeas-1; 641 | if numIPmeas~=0 642 | for i=(Primesuspectindex-numFPmeas-numFQmeas):(numIPmeas) 643 | ImeasPvalue(i)=ImeasPvalue(i+1); 644 | ImeasPsigma(i)=ImeasPsigma(i+1); 645 | IPmeasbus(i)=IPmeasbus(i+1); 646 | end 647 | IPmeasbus=IPmeasbus(1:numIPmeas); 648 | end 649 | else 650 | badmeasurementbus=Primesuspectindex-numFPmeas-numFQmeas-numIPmeas; 651 | fprintf('The bad measurement is a Q injection measurement. %e\n'); 652 | fprintf('The bad measurement occurs at bus: %2d %s', IQmeasbus(badmeasurementbus), ''); 653 | fprintf('Its value is:%2d',Primesuspectvalue); 654 | fprintf(' %s \n',' '); 655 | numIQmeas=numIQmeas-1; 656 | if numIQmeas~=0 657 | for i=(Primesuspectindex-numFPmeas-numFQmeas-numIPmeas):(numIQmeas) 658 | ImeasQvalue(i)=ImeasQvalue(i+1); 659 | ImeasQsigma(i)=ImeasQsigma(i+1); 660 | IQmeasbus(i)=IQmeasbus(i+1); 661 | end 662 | IQmeasbus=IQmeasbus(1:numIQmeas); 663 | end 664 | end 665 | % Calculate all f(i),y_norm(i) values for Nm measurements. 666 | for i=1:numbus 667 | vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 668 | end 669 | for i = 1:numFPmeas 670 | a=FPmeasfrombus(i); 671 | b=FPmeastobus(i); 672 | Iline = (vr(a) - vr(b))/(R(FPmeasbranch(i))+sqrt(-1)*X(FPmeasbranch(i))); 673 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FPmeasbranch(i))*0.5); 674 | Sline = vr(a) * conj(Iline); 675 | FcalcPvalue(i) = real(Sline); 676 | y1_norm(i)=(FmeasPvalue(i)-FcalcPvalue(i))/sigmaPflow(i); 677 | 678 | end 679 | y1_norm=y1_norm(1:numFPmeas); 680 | 681 | for i = 1:numFQmeas 682 | a=FQmeasfrombus(i); 683 | b=FQmeastobus(i); 684 | Iline = (vr(a) - vr(b))/(R(FQmeasbranch(i))+sqrt(-1)*X(FQmeasbranch(i))); 685 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(FQmeasbranch(i))*0.5); 686 | Sline = vr(a) * conj(Iline); 687 | FcalcQvalue(i)= imag(Sline); 688 | %if FmeasQvalue(i)-FcalcQvalue(i)<0.00001 689 | % y2_norm(i)=0; 690 | %else 691 | y2_norm(i)=(FmeasQvalue(i)-FcalcQvalue(i))/sigmaQflow(i); 692 | 693 | % end 694 | end 695 | y2_norm=y2_norm(1:numFQmeas); 696 | 697 | IcalcPvalue=zeros(numIPmeas,1); 698 | IcalcQvalue=zeros(numIQmeas,1); 699 | for i=1:numIPmeas 700 | a = IPmeasbus(i); 701 | for b=1:numbus 702 | Pinj =z.vmag(a)*z.vmag(b)*(cos(z.vang(a)-z.vang(b))*G(a,b)-sin(z.vang(a)-z.vang(b))*B(a,b)); 703 | IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 704 | end 705 | y3_norm(i)=(ImeasPvalue(i)-IcalcPvalue(i))/sigmaPinjec(i); 706 | 707 | end 708 | y3_norm=y3_norm(1:numIPmeas); 709 | for i=1:numIQmeas 710 | a = IQmeasbus(i); 711 | for b=1:numbus 712 | Qinj = z.vmag(a)*z.vmag(b)*(sin(z.vang(a)-z.vang(b))*G(a,b)+cos(z.vang(a)-z.vang(b))*B(a,b)); 713 | IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 714 | end 715 | y4_norm(i)=(ImeasQvalue(i)-IcalcQvalue(i))/sigmaQinjec(i); 716 | 717 | end 718 | y4_norm=y4_norm(1:numIQmeas); 719 | % Assume that numFPmeas, numFQmeas never go to zero. 720 | if numIPmeas==0 721 | y_norm=[y1_norm,y2_norm,y4_norm]; 722 | elseif numIQmeas==0 723 | y_norm=[y1_norm,y2_norm,y3_norm]; 724 | elseif numIPmeas==0&&numIQmeas==0 725 | y_norm=[y1_norm,y2_norm]; 726 | else 727 | y_norm=[y1_norm,y2_norm,y3_norm,y4_norm]; 728 | end 729 | end % end "Detect and Identify bad measurements" process 730 | 731 | end % end threshold iteration loop 732 | 733 | %Recalculate y_norm 734 | for i = 1:numFPmeas 735 | y1_norm(i)=(FmeasPvalue(i)-FcalcPvalue(i))/sigmaPflow(i); 736 | end 737 | for i=1:numFQmeas 738 | y2_norm(i)=(FmeasQvalue(i)-FcalcQvalue(i))/sigmaQflow(i); 739 | end 740 | for i=1:numIPmeas 741 | y3_norm(i)=(ImeasPvalue(i)-IcalcPvalue(i))/sigmaPinjec(i); 742 | end 743 | for i=1:numIQmeas 744 | y4_norm(i)=(ImeasQvalue(i)-IcalcQvalue(i))/sigmaQinjec(i); 745 | end 746 | 747 | fprintf(' %s \n',' '); 748 | fprintf ('The final value of J is %d\n' , J) 749 | fprintf ('The final value of TJ is %d\n' , TJ) 750 | % Display 751 | fprintf(' %s \n',' '); 752 | fprintf(' %s \n','-----------------------------------------------------------------------------------'); 753 | fprintf(' %s \n','From To Measured Calculated Difference Covariance of '); 754 | fprintf(' %s \n','Bus Bus Value Value Meansurement '); 755 | fprintf(' %s \n','-----------------------------------------------------------------------------------'); 756 | 757 | fprintf(' %s \n','Pflow: '); 758 | for i=1:numFPmeas 759 | fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',FPmeasfrombus(i),FPmeastobus(i),FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA,(FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,FmeasPsigma(i)); 760 | end 761 | fprintf(' %s \n',' '); 762 | fprintf(' %s \n',' '); 763 | 764 | fprintf(' %s \n','Qflow: '); 765 | for i=1:numFQmeas 766 | fprintf(' %5d %5d %8.3f %8.3f %8.3f %8.3f \n',FQmeasfrombus(i),FQmeastobus(i),FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA,(FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,FmeasQsigma(i)); 767 | end 768 | fprintf(' %s \n',' '); 769 | fprintf(' %s \n',' '); 770 | 771 | 772 | fprintf(' %s \n','Pinjection: '); 773 | for i=1:numIPmeas 774 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',IPmeasbus(i),ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA,(ImeasPvalue(i)-IcalcPvalue(i))*baseMVA, ImeasPsigma(i)); 775 | end 776 | 777 | fprintf(' %s \n',' '); 778 | fprintf(' %s \n',' '); 779 | fprintf(' %s \n','Qinjection: '); 780 | 781 | for i=1:numIQmeas 782 | fprintf(' %5d %8.3f %8.3f %8.3f %8.3f \n',IQmeasbus(i),ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA,(ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,ImeasQsigma(i)); 783 | end 784 | 785 | 786 | fprintf(' %s \n',''); 787 | fprintf(' %s \n',''); 788 | fprintf(' %s \n',''); 789 | fprintf(' %s \n','-------------------'); 790 | fprintf(' %s \n','Bad Data Analysis'); 791 | fprintf(' %s \n','-----------------------------------------------------------------------'); 792 | fprintf(' %s \n','Measurement Measurement Caculated Difference Covariance y_norm '); 793 | fprintf(' %s \n','Number Value Value of error '); 794 | fprintf(' %s \n','-----------------------------------------------------------------------'); 795 | fprintf(' %s\n','Pflow measurements:'); 796 | for i=1:numFPmeas 797 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasPvalue(i)*baseMVA, FcalcPvalue(i)*baseMVA, (FmeasPvalue(i)-FcalcPvalue(i))*baseMVA,sigmaPflow(i),y1_norm(i)*baseMVA); 798 | end 799 | fprintf(' %s\n','Qflow measurements:'); 800 | for i=1:numFQmeas 801 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', i, FmeasQvalue(i)*baseMVA, FcalcQvalue(i)*baseMVA, (FmeasQvalue(i)-FcalcQvalue(i))*baseMVA,sigmaQflow(i),y2_norm(i)*baseMVA); 802 | end 803 | fprintf(' %s\n','Pinjection measurements:'); 804 | for i=1:numIPmeas 805 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', IPmeasbus(i), ImeasPvalue(i)*baseMVA, IcalcPvalue(i)*baseMVA, (ImeasPvalue(i)-IcalcPvalue(i))*baseMVA,sigmaPinjec(i),y3_norm(i)*baseMVA); 806 | end 807 | fprintf(' %s\n','Qinjection measurements:'); 808 | for i=1:numIQmeas 809 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f %8.3f\n', IQmeasbus(i), ImeasQvalue(i)*baseMVA, IcalcQvalue(i)*baseMVA, (ImeasQvalue(i)-IcalcQvalue(i))*baseMVA,sigmaQinjec(i),y4_norm(i)*baseMVA); 810 | end 811 | 812 | %Caculate all the flow and injection values from the voltages magnitudes and angles obtained from the state estimator. 813 | for i=1:numbus 814 | vr(i)=z.vmag(i)*(cos(z.vang(i))+sqrt(-1)*sin(z.vang(i))); 815 | end 816 | 817 | 818 | for i = 1:numline 819 | a=frombus(i); 820 | b=tobus(i); 821 | Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 822 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 823 | Sline = vr(a) * conj(Iline); 824 | FcalcPvalue(i) = real(Sline); 825 | end 826 | for i=1:numline 827 | a=tobus(i); 828 | b=frombus(i); 829 | Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 830 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 831 | Sline = vr(a) * conj(Iline); 832 | FcalcPvalue(i+numline) = real(Sline); 833 | end 834 | for i = 1:numline 835 | a=frombus(i); 836 | b=tobus(i); 837 | Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 838 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 839 | Sline = vr(a) * conj(Iline); 840 | FcalcQvalue(i)= imag(Sline); 841 | end 842 | 843 | for i = 1:numline 844 | a=tobus(i); 845 | b=frombus(i); 846 | Iline = (vr(a) - vr(b))/(R(i)+sqrt(-1)*X(i)); 847 | Iline = Iline + vr(a)*(0.0 + sqrt(-1)*Bcap(i)*0.5); 848 | Sline = vr(a) * conj(Iline); 849 | FcalcQvalue(i+numline)= imag(Sline); 850 | end 851 | IcalcPvalue=zeros(numbus,1); 852 | IcalcQvalue=zeros(numbus,1); 853 | for i=1:numbus 854 | for b=1:numbus 855 | Pinj =z.vmag(i)*z.vmag(b)*(cos(z.vang(i)-z.vang(b))*G(i,b)-sin(z.vang(i)-z.vang(b))*B(i,b)); 856 | IcalcPvalue(i)=IcalcPvalue(i)+Pinj; 857 | end 858 | end 859 | 860 | for i=1:numbus 861 | for b=1:numbus 862 | Qinj = z.vmag(i)*z.vmag(b)*(sin(z.vang(i)-z.vang(b))*G(i,b)+cos(z.vang(i)-z.vang(b))*B(i,b)); 863 | IcalcQvalue(i)=IcalcQvalue(i)+Qinj; 864 | end 865 | end 866 | 867 | 868 | % Display AC state estimator result 869 | fprintf(' %s \n',' '); 870 | fprintf(' %s \n','State Estimator Solution:'); 871 | fprintf(' %s \n',' '); 872 | fprintf(' %s \n','Bus Volt. Volt. Mw Mvar To Mw Mvar '); 873 | fprintf(' %s \n','Number Mag. Angle Injec. Injec. Bus Flow Flow '); 874 | fprintf(' %s \n','------ ------ ------ -------- -------- ---- ------- ------- '); 875 | 876 | for i=1:numbus 877 | fprintf('%5d %8.3f %8.3f %8.3f %8.3f \n',i, z.vmag(i),z.vang(i),IcalcPvalue(i)*baseMVA,IcalcQvalue(i)*baseMVA); 878 | for j=1:numline 879 | a=frombus(j); 880 | b=tobus(j); 881 | if b==i 882 | fprintf(' %5d %8.3f %8.3f \n', a, FcalcPvalue(j+numline)*baseMVA, FcalcQvalue(j+numline)*baseMVA); 883 | elseif a==i 884 | fprintf(' %5d %8.3f %8.3f \n', b, FcalcPvalue(j)*baseMVA, FcalcQvalue(j)*baseMVA); 885 | end 886 | end 887 | end 888 | -------------------------------------------------------------------------------- /run_pfnewton.m: -------------------------------------------------------------------------------- 1 | % code to initialize and run a Newton power flow 2 | clear 3 | 4 | %pfdatainput 5 | 6 | pfdatainput_Excel 7 | 8 | powerflownewton; 9 | 10 | 11 | -------------------------------------------------------------------------------- /run_powerflow.m: -------------------------------------------------------------------------------- 1 | % code to initialize and run a Newton power flow 2 | clear; 3 | close all 4 | clc 5 | 6 | %pfdatainput 7 | 8 | %pfdatainput_Excel 9 | network_datainput_Excel 10 | 11 | powerflownewton; 12 | 13 | 14 | -------------------------------------------------------------------------------- /run_scada.m: -------------------------------------------------------------------------------- 1 | % SCADA Program 2 | 3 | % load in the power flow data and solution 4 | load('PowerFlowOutput.mat') 5 | 6 | %Power Flow Input data 7 | %------------------------------------------------------------------- 8 | Maxiter = PowerFlowInputData.Maxiter; 9 | tolerance = PowerFlowInputData.powerflow_tolerance; 10 | numbus = PowerFlowInputData.numbus; 11 | numline = PowerFlowInputData.numline; 12 | numgen = PowerFlowInputData.numgen; 13 | numarea = PowerFlowInputData.numarea; 14 | refbus = PowerFlowInputData.refbus; 15 | frombus = PowerFlowInputData.frombus; 16 | tobus = PowerFlowInputData.tobus; 17 | R = PowerFlowInputData.R; 18 | X = PowerFlowInputData.X; 19 | Bcap = PowerFlowInputData.Bcap; 20 | Bustype = PowerFlowInputData.Bustype; 21 | Psched = PowerFlowInputData.Psched; 22 | Qsched = PowerFlowInputData.Qsched; 23 | Vsched = PowerFlowInputData.Vsched; 24 | Y = PowerFlowInputData.Y; 25 | G = PowerFlowInputData.G; 26 | B = PowerFlowInputData.B; 27 | 28 | %Power Flow Solution Data: 29 | %------------------------------------------------------------------- 30 | Pinj = PowerFlowSolution.Pinj; 31 | Qinj = PowerFlowSolution.Qinj; 32 | vr = PowerFlowSolution.vr; 33 | Vmag = PowerFlowSolution.Vmag; 34 | Theta = PowerFlowSolution.Theta; 35 | Bustype = PowerFlowSolution.Bustype; 36 | 37 | % Read State estimator measurement data 38 | %------------------------------------------------------------------- 39 | measurement_datainput_Excel 40 | 41 | % Create measurement value tables 42 | %------------------------------------------------------------------- 43 | Vmeasvalue = zeros(numVmeas,1); 44 | Ameasvalue = zeros(numAmeas,1); 45 | ImeasPvalue = zeros(numImeas,1); 46 | ImeasQvalue = zeros(numImeas,1); 47 | FmeasPvalue = zeros(numFmeas,1); 48 | FmeasQvalue = zeros(numFmeas,1); 49 | 50 | %------------------------------------------------------------------- 51 | % get the measurement values from the power flow 52 | 53 | RefBus_checkoff = 0; 54 | % store voltage measurements 55 | for i_vmeas = 1:numVmeas 56 | Vmeas_base_value(i_vmeas)=Vmag(Vmeasbus(i_vmeas)); 57 | if Vmeasstatus(i_vmeas) == 1 58 | Vmeasvalue(i_vmeas)=Vmag(Vmeasbus(i_vmeas)); 59 | if Vmeasbus(i_vmeas) == refbus 60 | RefBus_checkoff = 1; 61 | end 62 | end 63 | end 64 | 65 | if RefBus_checkoff ~= 1 66 | fprintf(' %s \n','*************************************************'); 67 | fprintf(' %s \n','Ref Bus must be one of the Voltage measurements'); 68 | fprintf(' %s \n','It must have a status of 1'); 69 | fprintf(' %s \n','*************************************************'); 70 | end 71 | 72 | %get the angle measurements from the power flow 73 | for i_ameas=1:numAmeas 74 | Ameas_base_value(i_ameas)=Theta(Ameasbus(i_ameas)); 75 | if Ameasstatus(i_ameas) == 1 76 | Ameasvalue(i_ameas)=Theta(Ameasbus(i_ameas)); 77 | end 78 | end 79 | 80 | %get the injection measurements from the power flow 81 | for i_injmeas=1:numImeas 82 | Imeas_base_Pvalue(i_injmeas)=Pinj(Imeasbus(i_injmeas)); 83 | Imeas_base_Qvalue(i_injmeas)=Qinj(Imeasbus(i_injmeas)); 84 | if Imeasstatus(i_injmeas) == 1 85 | ImeasPvalue(i_injmeas)=Pinj(Imeasbus(i_injmeas)); 86 | ImeasQvalue(i_injmeas)=Qinj(Imeasbus(i_injmeas)); 87 | end 88 | end 89 | 90 | %get the line P and Q flow values from the power flow 91 | for i_flowmeas = 1:numFmeas 92 | i=Fmeasfrombus(i_flowmeas); 93 | j=Fmeastobus(i_flowmeas); 94 | ibranch = Fmeasbranch(i_flowmeas); 95 | Gline = R(ibranch)/(R(ibranch)^2 + X(ibranch)^2); 96 | Bline = -X(ibranch)/(R(ibranch)^2 + X(ibranch)^2); 97 | Bcapline = Bcap(ibranch)/2; 98 | Fmeas_base_Pvalue(i_flowmeas) = Gline*Vmag(i)^2 - Gline*Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j))-Bline*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j)); 99 | Fmeas_base_Qvalue(i_flowmeas)= -1*Vmag(i)*Vmag(j)*sin(Theta(i)-Theta(j))*Gline - Vmag(i)^2*Bline + Vmag(i)*Vmag(j)*cos(Theta(i)-Theta(j))*Bline - (Vmag(i)^2)*Bcapline; 100 | if Fmeasstatus(i_flowmeas) == 1 101 | FmeasPvalue(i_flowmeas) = Fmeas_base_Pvalue(i_flowmeas); 102 | FmeasQvalue(i_flowmeas) = Fmeas_base_Qvalue(i_flowmeas); 103 | end 104 | end 105 | 106 | noise=0; 107 | 108 | Scadamenu; % alter measurements for demo 109 | 110 | Vmeas_measurement_value = Vmeasvalue; 111 | Ameas_measurement_value = Ameasvalue; 112 | Imeas_measurement_Pvalue = ImeasPvalue; 113 | Imeas_measurement_Qvalue = ImeasQvalue; 114 | Fmeas_measurement_Pvalue = FmeasPvalue; 115 | Fmeas_measurement_Qvalue = FmeasQvalue; 116 | 117 | % Printout of measurement input and measurements with noise 118 | 119 | fprintf(' %s \n',' '); 120 | fprintf(' %s \n','Measurement Base Case Value Measured Value Measurement Measurement '); 121 | fprintf(' %s \n','Name Status kV MW MVAR kV MW MVAR Sigma (P) Sigma (Q) '); 122 | for i = 1:numbus 123 | fprintf(' %s %3d \n',' Bus',i); 124 | Vbase = 230.; 125 | MVABase = 100.; 126 | rad2deg = 180/pi; 127 | 128 | if numVmeas > 0 129 | for j = 1:numVmeas 130 | if Vmeasbus(j) == i 131 | fprintf(' %s %d %6.1f %6.1f %10.1E \n',voltage_meas_NAMES(j,:),Vmeasstatus(j), Vmeas_base_value(j)*Vbase,... 132 | Vmeas_measurement_value(j)*Vbase, Vmeassigma(j) ); 133 | end 134 | end 135 | end 136 | 137 | if numAmeas > 0 138 | for j = 1:numAmeas 139 | if Ameasbus(j) == i 140 | fprintf(' %s %d %6.1f %6.1f %10.1E \n',angle_meas_NAMES(j,:),Ameasstatus(j), Ameas_base_value(j)*rad2deg,... 141 | Ameas_measurement_value(j)*rad2deg, Ameassigma(j)); 142 | end 143 | end 144 | end 145 | 146 | if numImeas > 0 147 | for j = 1:numImeas 148 | if Imeasbus(j) == i 149 | fprintf(' %s %d %6.1f %6.1f %6.1f %6.1f %10.1E %10.1E \n',... 150 | ImeasNAME(j,:),Imeasstatus(j), Imeas_base_Pvalue(j)*MVABase, Imeas_base_Qvalue(j)*MVABase, ... 151 | Imeas_measurement_Pvalue(j)*MVABase, Imeas_measurement_Qvalue(j)*MVABase, ImeasPsigma(j), ImeasQsigma(j) ); 152 | end 153 | end 154 | end 155 | 156 | if numFmeas >0 157 | for j = 1:numFmeas 158 | if Fmeasfrombus(j) == i ; 159 | fprintf(' %s %d %6.1f %6.1f %6.1f %6.1f %10.1E %10.1E \n',... 160 | FmeasNAME(j,:),Fmeasstatus(j), Fmeas_base_Pvalue(j)*MVABase, Fmeas_base_Qvalue(j)*MVABase, ... 161 | Fmeas_measurement_Pvalue(j)*MVABase, Fmeas_measurement_Qvalue(j)*MVABase, FmeasPsigma(j), FmeasQsigma(j) ); 162 | end 163 | end 164 | end 165 | 166 | end 167 | 168 | 169 | %----------------------------------------------------------------------------- 170 | % Add measurement value tables to measurement data structures to 171 | % contain the measurement values and store in mat file 172 | 173 | SCADA_voltage_meas_data.voltage_meas_status = Vmeasstatus; 174 | SCADA_voltage_meas_data.voltage_meas_base_value = Vmeas_base_value; 175 | SCADA_voltage_meas_data.voltage_meas_measurement_value = Vmeas_measurement_value; 176 | 177 | SCADA_angle_meas_data.angle_meas_status = Ameasstatus; 178 | SCADA_angle_meas_data.angle_meas_base_value = Ameas_base_value; 179 | SCADA_angle_meas_data.angle_meas_measurement_value = Ameas_measurement_value; 180 | 181 | SCADA_injection_meas_data.injection_meas_status = Imeasstatus; 182 | SCADA_injection_meas_data.injection_meas_base_Pvalue = Imeas_base_Pvalue; 183 | SCADA_injection_meas_data.injection_meas_base_Qvalue = Imeas_base_Qvalue; 184 | SCADA_injection_meas_data.injection_meas_measurement_Pvalue = Imeas_measurement_Pvalue; 185 | SCADA_injection_meas_data.injection_meas_measurement_Qvalue = Imeas_measurement_Qvalue; 186 | 187 | SCADA_flow_meas_data.flow_meas_status = Fmeasstatus; 188 | SCADA_flow_meas_data.flow_meas_base_Pvalue = Fmeas_base_Pvalue; 189 | SCADA_flow_meas_data.flow_meas_base_Qvalue = Fmeas_base_Qvalue; 190 | SCADA_flow_meas_data.flow_meas_measurement_Pvalue = Fmeas_measurement_Pvalue; 191 | SCADA_flow_meas_data.flow_meas_measurement_Qvalue = Fmeas_measurement_Qvalue; 192 | 193 | 194 | % Save StateEstimatorData.mat file to send to State Estimator 195 | 196 | save('StateEstimatorData','SCADA_voltage_meas_data',... 197 | 'SCADA_angle_meas_data',... 198 | 'SCADA_injection_meas_data',... 199 | 'SCADA_flow_meas_data');%who -file StateEstimatorData 200 | 201 | -------------------------------------------------------------------------------- /scada_store.m: -------------------------------------------------------------------------------- 1 | %scada 2 | 3 | % Add measurement value tables to measurement data structures to 4 | % contain the measurement values 5 | 6 | SCADA_voltage_meas_data.voltage_meas_value = Vmeasvalue; 7 | SCADA_voltage_meas_data.voltage_meas_status = Vmeasstatus; 8 | 9 | SCADA_angle_meas_data.angle_meas_value = Ameasvalue; 10 | SCADA_angle_meas_data.angle_meas_status = Ameasstatus; 11 | 12 | SCADA_injection_meas_data.injection_meas_Pvalue = ImeasPvalue; 13 | SCADA_injection_meas_data.injection_meas_Qvalue = ImeasQvalue; 14 | SCADA_injection_meas_data.injection_meas_status = Imeasstatus; 15 | 16 | SCADA_flow_meas_data.flow_meas_Pvalue = FmeasPvalue; 17 | SCADA_flow_meas_data.flow_meas_Qvalue = FmeasQvalue; 18 | SCADA_flow_meas_data.flow_meas_status = Fmeasstatus; 19 | 20 | % Save StateEstimatorData.mat file to send to State Estimator 21 | 22 | save('StateEstimatorData','SCADA_voltage_meas_data',... 23 | 'SCADA_angle_meas_data',... 24 | 'SCADA_injection_meas_data',... 25 | 'SCADA_flow_meas_data');who -file StateEstimatorData 26 | 27 | -------------------------------------------------------------------------------- /sedatainput_Excel.m: -------------------------------------------------------------------------------- 1 | %&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 2 | % Reading Measurement Data File: 3 | % Input Data File 4 | [file,pathname] = uigetfile('*measurementdata.xls*','Select Spreadsheet File'); 5 | if (pathname == 0), 6 | error('You Must Select A Valid Data File') 7 | end 8 | S=file; % Name of the File that we need to read 9 | 10 | fprintf(' Case ID: %s \n',file); 11 | %-------------------------------------------------------------------------- 12 | % Read measurement data from the spreadsheet 13 | [voltage_measurements, voltage_meas_NAMES_CHAR ] = xlsread(S, 'voltage_measurements'); 14 | 15 | [numrows,N] = size(voltage_meas_NAMES_CHAR); 16 | for i=2:numrows 17 | name = cell2mat(voltage_meas_NAMES_CHAR(i,2)); 18 | [M, numcols] = size(name); 19 | for j = 1:numcols 20 | voltage_meas_NAMES(i-1, j) = name(1,j); 21 | end 22 | end 23 | numVmeas = numrows - 1; 24 | 25 | %-------------------------------------------------------------------------- 26 | [angle_measurements, angle_meas_NAMES_CHAR] = xlsread(S, 'angle_measurements'); 27 | 28 | [numrows,N] = size(angle_meas_NAMES_CHAR); 29 | for i=2:numrows 30 | name = cell2mat(angle_meas_NAMES_CHAR(i,2)); 31 | [M, numcols] = size(name); 32 | for j = 1:numcols 33 | angle_meas_NAMES(i-1, j) = name(1,j); 34 | end 35 | end 36 | numAmeas = numrows - 1; 37 | 38 | %-------------------------------------------------------------------------- 39 | [injection_measurements, injection_meas_NAMES_CHAR] = xlsread(S, 'injection_measurements'); 40 | 41 | [numrows,N] = size(injection_meas_NAMES_CHAR); 42 | for i=2:numrows 43 | name = cell2mat(injection_meas_NAMES_CHAR(i,2)); 44 | [M, numcols] = size(name); 45 | for j = 1:numcols 46 | injection_meas_NAMES(i-1, j) = name(1,j); 47 | end 48 | end 49 | numImeas = numrows - 1; 50 | 51 | %-------------------------------------------------------------------------- 52 | [flow_measurements, flow_meas_NAMES_CHAR] = xlsread(S, 'flow_measurements'); 53 | 54 | [numrows,N] = size(flow_meas_NAMES_CHAR); 55 | for i=2:numrows 56 | name = cell2mat(flow_meas_NAMES_CHAR(i,2)); 57 | [M, numcols] = size(name); 58 | for j = 1:numcols 59 | flow_meas_NAMES(i-1, j) = name(1,j); 60 | end 61 | end 62 | numFmeas = numrows - 1; 63 | %-------------------------------------------------------------------------- 64 | 65 | 66 | 67 | % Get the table dimensions from the tables read off spreadsheet 68 | [numVmeas,numVvariables]=size(voltage_measurements); 69 | [numAmeas,numAvariables]=size(angle_measurements); 70 | [numImeas,numIvariables]=size(injection_measurements); 71 | [numFmeas,numFvariables]=size(flow_measurements); 72 | 73 | %NOTE: This state estimator depends upon the user placing a Vmeas and 74 | % an Ameas at the slack bus 75 | 76 | % Create the data structure for all measurements and fill with spreadsheet data 77 | % NOTE THAT ALL DATA GOES IN AT THIS POINT BUT NOT THE MEAS VALUES 78 | SCADA_voltage_meas_data = struct('number_voltage_meas', numVmeas,... 79 | 'voltage_meas_bus', [voltage_measurements(1:numVmeas,1)],... 80 | 'voltage_meas_NAMES', [voltage_meas_NAMES(1:numVmeas,:)],... 81 | 'voltage_meas_sigma', [voltage_measurements(1:numVmeas,3)],... 82 | 'voltage_meas_status', [voltage_measurements(1:numVmeas,4)],... 83 | 'voltage_meas_base_value', [voltage_measurements(1:numVmeas,5)],... 84 | 'voltage_meas_measurement_value',[voltage_measurements(1:numVmeas,6)] ); 85 | 86 | 87 | 88 | SCADA_angle_meas_data = struct('number_angle_meas', numAmeas,... 89 | 'angle_meas_bus', [angle_measurements(1:numAmeas,1)],... 90 | 'angle_meas_NAMES', [angle_meas_NAMES(1:numAmeas,:)],... 91 | 'angle_meas_sigma', [angle_measurements(1:numAmeas,3)],... 92 | 'angle_meas_status', [angle_measurements(1:numVmeas,4)],... 93 | 'angle_meas_base_value', [angle_measurements(1:numVmeas,5)],... 94 | 'angle_meas_measurement_value',[angle_measurements(1:numVmeas,6)] ); 95 | if numImeas==0 96 | SCADA_injection_meas_data = struct('number_injection_meas', numImeas,... 97 | 'injection_meas_bus', [],... 98 | 'injection_meas_NAMES', [],... 99 | 'injection_meas_Psigma',[],... 100 | 'injection_meas_Qsigma',[],... 101 | 'injection_meas_status',[],... 102 | 'injection_meas_base_Pvalue',[],... 103 | 'injection_meas_base_Qvalue',[],... 104 | 'injection_meas_measurement_Pvalue',[],... 105 | 'injection_meas_measurement_Qvalue',[] ); 106 | 107 | else 108 | SCADA_injection_meas_data = struct('number_injection_meas', numImeas,... 109 | 'injection_meas_bus', [injection_measurements(1:numImeas,1)],... 110 | 'injection_meas_NAMES', [injection_meas_NAMES(1:numImeas,:)],... 111 | 'injection_meas_Psigma', [injection_measurements(1:numImeas,3)],... 112 | 'injection_meas_Qsigma', [injection_measurements(1:numImeas,4)],... 113 | 'injection_meas_status', [injection_measurements(1:numImeas,5)],... 114 | 'injection_meas_base_Pvalue', [injection_measurements(1:numImeas,6)],... 115 | 'injection_meas_base_Qvalue', [injection_measurements(1:numImeas,7)],... 116 | 'injection_meas_measurement_Pvalue',[injection_measurements(1:numImeas,8)],... 117 | 'injection_meas_measurement_Qvalue',[injection_measurements(1:numImeas,9)] ); 118 | end 119 | 120 | if numFmeas==0 121 | SCADA_flow_meas_data = struct('number_flow_meas', numFmeas,... 122 | 'flow_meas_branch', [],... 123 | 'flow_meas_NAMES', [],... 124 | 'flow_meas_frombus',[],... 125 | 'flow_meas_tobus', [],... 126 | 'flow_meas_Psigma', [],... 127 | 'flow_meas_Qsigma', [],... 128 | 'flow_meas_status', [],... 129 | 'flow_meas_base_Pvalue',[],... 130 | 'flow_meas_base_Qvalue',[],... 131 | 'flow_meas_measurement_Pvalue',[],... 132 | 'flow_meas_measurement_Qvalue',[] ); 133 | else 134 | 135 | SCADA_flow_meas_data = struct('number_flow_meas', numFmeas,... 136 | 'flow_meas_branch', [flow_measurements(1:numFmeas,1)],... 137 | 'flow_meas_NAMES', [flow_meas_NAMES(1:numFmeas,:)],... 138 | 'flow_meas_frombus', [flow_measurements(1:numFmeas,3)],... 139 | 'flow_meas_tobus', [flow_measurements(1:numFmeas,4)],... 140 | 'flow_meas_Psigma', [flow_measurements(1:numFmeas,5)],... 141 | 'flow_meas_Qsigma', [flow_measurements(1:numFmeas,6)],... 142 | 'flow_meas_status', [flow_measurements(1:numFmeas,7)],... 143 | 'flow_meas_base_Pvalue', [flow_measurements(1:numFmeas,8)],... 144 | 'flow_meas_base_Qvalue', [flow_measurements(1:numFmeas,9)],... 145 | 'flow_meas_measurement_Pvalue',[flow_measurements(1:numFmeas,10)],... 146 | 'flow_meas_measurement_Qvalue',[flow_measurements(1:numFmeas,11)] ); 147 | end 148 | 149 | % Place data in local arrays for use in calculating values 150 | Vmeasbus = SCADA_voltage_meas_data.voltage_meas_bus; 151 | VmeasNAME = SCADA_voltage_meas_data.voltage_meas_NAMES; 152 | Vmeassigma = SCADA_voltage_meas_data.voltage_meas_sigma; 153 | Vmeasstatus = SCADA_voltage_meas_data.voltage_meas_status; 154 | 155 | Ameasbus = SCADA_angle_meas_data.angle_meas_bus; 156 | AmeasNAME = SCADA_angle_meas_data.angle_meas_NAMES; 157 | Ameassigma = SCADA_angle_meas_data.angle_meas_sigma; 158 | Ameasstatus = SCADA_angle_meas_data.angle_meas_status; 159 | 160 | 161 | Imeasbus = SCADA_injection_meas_data.injection_meas_bus; 162 | ImeasNAME = SCADA_injection_meas_data.injection_meas_NAMES; 163 | ImeasPsigma = SCADA_injection_meas_data.injection_meas_Psigma; 164 | ImeasQsigma = SCADA_injection_meas_data.injection_meas_Qsigma; 165 | Imeasstatus = SCADA_injection_meas_data.injection_meas_status; 166 | 167 | 168 | Fmeasbranch = SCADA_flow_meas_data.flow_meas_branch; 169 | FmeasNAME = SCADA_flow_meas_data.flow_meas_NAMES; 170 | Fmeasfrombus = SCADA_flow_meas_data.flow_meas_frombus; 171 | Fmeastobus = SCADA_flow_meas_data.flow_meas_tobus; 172 | FmeasPsigma = SCADA_flow_meas_data.flow_meas_Psigma; 173 | FmeasQsigma = SCADA_flow_meas_data.flow_meas_Qsigma; 174 | Fmeasstatus = SCADA_flow_meas_data.flow_meas_status; 175 | 176 | -------------------------------------------------------------------------------- /testH.m: -------------------------------------------------------------------------------- 1 | % test meas removal 2 | 3 | H = [1 2 3 4 4 | -5 6 7 8 5 | 9 -10 11 12 6 | 13 14 -15 16 7 | 17 18 19 -20] 8 | 9 | Rcov = [ 100 0 0 0 0 10 | 0 100 0 0 0 11 | 0 0 100 0 0 12 | 0 0 0 100 0 13 | 0 0 0 0 100 ] 14 | 15 | HTHinv = inv(H'*Rcov*H)*H' 16 | 17 | H1 = [1 2 3 4 18 | -5 6 7 8 19 | 13 14 -15 16 20 | 17 18 19 -20] 21 | 22 | Rcov1 = [ 100 0 0 0 23 | 0 100 0 0 24 | 0 0 100 0 25 | 0 0 0 100 ] 26 | 27 | 28 | H1TH1inv = inv(H1'*Rcov1*H1)*H1' 29 | 30 | 31 | H2 = [1 2 3 4 32 | -5 6 7 8 33 | 0 0 0 0 34 | 13 14 -15 16 35 | 17 18 19 -20] 36 | 37 | Rcov2 = [ 100 0 0 0 0 38 | 0 100 0 0 0 39 | 0 0 0 0 0 40 | 0 0 0 100 0 41 | 0 0 0 0 100 ] 42 | 43 | 44 | H2TH2inv = inv(H2'*Rcov2*H2)*H2' 45 | 46 | 47 | -------------------------------------------------------------------------------- /testchi2inv.m: -------------------------------------------------------------------------------- 1 | % test chi2inv 2 | 3 | 4 | clear 5 | 6 | 7 | 8 | K=50; 9 | max = 200; 10 | alpha = zeros(max,1); 11 | P = zeros(max,1); 12 | 13 | 14 | 15 | max_alpha = 1.0; 16 | alpha(1) = max_alpha; 17 | for i = 1:max 18 | 19 | TJ(i) = 1 - chi2inv(alpha(i),K); 20 | % TJ(i) = 2*K - chi2inv(alpha(i),K); 21 | if i < max 22 | alpha(i+1) = alpha(i) - max_alpha/max; 23 | end 24 | end 25 | % 26 | % max_alpha = 1.0; 27 | % alpha(1) = max_alpha; 28 | % for i = 1:max 29 | % 30 | % TJ(i) = chi2inv(alpha(i),K); 31 | % if i < max 32 | % alpha(i+1) = alpha(i) - max_alpha/max; 33 | % end 34 | % end 35 | plot(TJ,alpha) 36 | 37 | 38 | % working with cdf function 39 | 40 | % TJ(1) = 0.0; 41 | % for i = 1:max 42 | % 43 | % alpha(i) = ( 1 - chi2cdf(TJ(i),K) ); 44 | % if i < max 45 | % TJ(i+1) = TJ(i) + 0.5; 46 | % end 47 | % end 48 | % 49 | % TJ(1) = 0.0; 50 | % for i = 1:max 51 | % P(i) = chi2cdf(TJ(i),K); 52 | % if i < max 53 | % TJ(i+1) = TJ(i) + 0.5; 54 | % end 55 | % end 56 | % plot(TJ, P) 57 | 58 | % for i = 1:max 59 | % fprintf(' %7.4f %5.4f \n',TJ(i), alpha(i) ) 60 | % end 61 | 62 | % plot(TJ, alpha) -------------------------------------------------------------------------------- /testequations.m: -------------------------------------------------------------------------------- 1 | % test derivatives 2 | 3 | 4 | clear 5 | i = 1; 6 | j = 2; 7 | bus_angle(i) = 0.0; 8 | bus_angle(j) = 45*(pi/180); 9 | bus_angle 10 | v(i) = 1.0; 11 | v(j) = 0.9; 12 | %v(j) = 1.0; 13 | v 14 | 15 | ibranch = 1; 16 | R(ibranch) = 0.1; 17 | %R(ibranch) = 0.0; 18 | X(ibranch) = 0.2; 19 | Bcap(ibranch) = 0.04; 20 | %Bcap(ibranch) = 0.0; 21 | Gline = R(ibranch)/(R(ibranch)^2 + X(ibranch)^2) 22 | Bline = -X(ibranch)/(R(ibranch)^2 + X(ibranch)^2) 23 | Bcapline = Bcap(ibranch)/2 24 | 25 | P = Gline*v(i)^2 - Gline*v(i)*v(j)*cos(bus_angle(i)-bus_angle(j))-Bline*v(i)*v(j)*sin(bus_angle(i)-bus_angle(j)) 26 | 27 | Q = Bline*v(i)*v(j)*cos(bus_angle(i) - bus_angle(j)) - (Bcapline*v(i)^2) - Bline*v(i)^2 - Gline*v(i)*v(j)*sin(bus_angle(i) - bus_angle(j)) 28 | 29 | 30 | yline = 1/( R(ibranch) + sqrt(-1)*X(ibranch) ) 31 | 32 | ycap = sqrt(-1)*Bcap(ibranch)/2 33 | 34 | vfrom = v(i)*( cos(bus_angle(i)) + sqrt(-1)*sin(bus_angle(i)) ) 35 | vto = v(j)*( cos(bus_angle(j)) + sqrt(-1)*sin(bus_angle(j)) ) 36 | 37 | Iline = (vfrom - vto)*yline + vfrom*ycap 38 | 39 | PjQ = vfrom*conj(Iline) 40 | 41 | % >> syms Gline Bline v(i) v(j) angle(i) angle(j) Bcapline 42 | % 43 | % >> Q = -1*v(i)*v(j)*sin(angle(i)-angle(j))*Gline - v(i)^2*Bline + v(i)*v(j)*cos(angle(i)-angle(j))*Bline - (v(i)^2)*Bcapline 44 | % 45 | % 46 | % >> diff(Q,angle(i)) 47 | % 48 | % - Gline*v(i)*v(j)*cos(angle(i) - angle(j)) - Bline*v(i)*v(j)*sin(angle(i) - angle(j)) 49 | % 50 | % >> diff(Q,v(i)) 51 | % 52 | % Bline*v(j)*cos(angle(i) - angle(j)) - 2*Bcapline*v(i) - 2*Bline*v(i) - Gline*v(j)*sin(angle(i) - angle(j)) 53 | % 54 | % >> diff(Q,angle(j)) 55 | % 56 | % Gline*v(i)*v(j)*cos(angle(i) - angle(j)) + Bline*v(i)*v(j)*sin(angle(i) - angle(j)) 57 | % 58 | % >> diff(Q,v(j)) 59 | % 60 | % Bline*v(i)*cos(angle(i) - angle(j)) - Gline*v(i)*sin(angle(i) - angle(j)) 61 | % 62 | % 63 | -------------------------------------------------------------------------------- /testrandom.m: -------------------------------------------------------------------------------- 1 | % In MATLAB one can produce normally-distributed random variables with an expected value of zero and a standard deviation of 1.0 directly using the function randn. Thus: 2 | % 3 | % z = ev + randn(100,10)*sd 4 | % 5 | % will produce a {100*10} matrix z of random numbers from a distribution with a mean of ev and a standard deviation of sd. 6 | % 7 | 8 | 9 | z = randn(1,1) 10 | --------------------------------------------------------------------------------