using System;

using System.Numerics;

using System.Data;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    public class Bus

​

    {

​

        public string C { get; set; }   // Type of the bus (Slack/Swing

        public int N { get; set; }  // Bus Seq

        public string T { get; set; }   // Bus Tag

        public double V { get; set; }  // Bus Nominal Voltage

        public Complex Vit { get; set; }  // Bus pu Iteration Voltage

        public double Vo { get; set; }  // Bus Operating Voltage

        public double Deg { get; set; }  // Angle

        public double Vpu { get; set; }  // Bus Per Unit Voltage

        public double Vb { get; set; }  // Applicable Base Voltage for this Bus

        public Complex Ybb { get; set; }  // Self Admittance (sum of admittances of all connected branches)

        public Complex Sit { get; set; }  // Sum of all connected loads at each Iteration

        public List<Bus> Cn { get; set; }  // Connected Bus List

​

        public Bus(string c, string t, double v)

        {

            C = c; T = t; V = v;

            Vit = new Complex(1, 0); // initialised

            Sit = new Complex(1, 0); // initialised

            Cn = new List<Bus>() { };

            N = Buses.Count();

            Vpu = 1; // initilised

        }

    };

​

​

​

    public class Branch

    {

        public string C { get; set; }  // Category

        public int N { get; set; }   // Branch Sequence No

        public string T { get; set; }   // Branch Tag

        public Bus Bf { get; set; }     // Bus From

        public Bus Bt { get; set; }     // Bus To

        public Complex Yact { get; set; } // Branch Admittance in PU

        public Complex Y { get; set; } // Branch Admittance in PU

        public Branch(string c, string t, Bus bf, Bus bt, Complex y)

        {

            C = c;

            N = Branches.Count();

            T = t;

            Bf = bf;

            Bt = bt;

            Yact = y;

        }

    };

​

​

​

    public class Cable

    {

        public string C { get; set; }  // Category

        public int Bfn { get; set; }     // Bus From

        public int Btn { get; set; }     // Bus To

        public string T { get; set; }   // Branch Tag

        public int N { get; set; }   // Branch Sequence No

        public Bus Bf { get; set; }     // Bus From

        public Bus Bt { get; set; }     // Bus To

        public double R { get; set; }  // Branch Resistance per kM

        public double X { get; set; }  // Branch Reactance (+ve for Inductive) per kM

        public double Rn { get; set; }  // Run per phase

        public double L { get; set; }  // Cable Length in m

        public double Vb { get; set; }  // Applicable Base Voltage for this Cable Branch

        public double Zb { get; set; }  // Applicable Base Impedenace for this Cable Branch

        public double Ib { get; set; }  // Applicable Base Current for this Cable Branch

        public Complex Y { get; set; } // Branch Admittance in PU

        public Cable(string c, string t, string bft, string btt, double r, double x, double rn, double l)

        {

            C = c;

            N = Cables.Count();

            T = t;

            R = r ;

            X = x ;

            Rn = rn;

            L = l;

            Bf = Buses.Where(bus => bus.T == bft).ToList()[0];

            Bt = Buses.Where(bus => bus.T == btt).ToList()[0];

            if (Bf == null || Bt == null)

            {

                Console.WriteLine(String.Format("Error !! Branch Tag {0} connected to bus {1} and {2} is not defined yet.", T, Bf.N, Bt.N));

            }

            else

            {

                Bfn = Bf.N;

                Btn = Bt.N;

                if (Bf.Cn.Contains(Bt) == false) { Bf.Cn.Add(Bt); }

                if (Bt.Cn.Contains(Bf) == false) { Bt.Cn.Add(Bf); }

            }

​

​

            if (Bf.V != Bt.V)

            {

                Console.WriteLine(String.Format("Error !! Branch Tag {0} " +

                    "connected to bus {1} and {2} which are of different voltages {3} and {4}",

                            T, Bf.N, Bt.N, Bf.V, Bt.V));

            }

        }

    };

​

​

​

    public class Transformer

    {

        public string C { get; set; }  // Category

        public int N { get; set; }   // Sequence No

        public int Bfn { get; set; }     // Bus From seq

        public int Btn { get; set; }     // Bus To seq

        public string T { get; set; }   // Branch Tag

        public Bus Bf { get; set; }     // Bus From

        public Bus Bt { get; set; }     // Bus To

        public double Z { get; set; }  // Impedance pu

        public double V1 { get; set; }  // From (1) side Open Circuit Voltage

        public double V2 { get; set; }  // To (2) side Open Circuit Voltage

        public double XR { get; set; }  // X/R Ratio

        public double KVA { get; set; }  // kVA

        public double KVAF { get; set; }  // KVA Forced Cooling Rating

        public Complex Y { get; set; } // Branch Admittance in PU

        public Transformer(string c, string t, string bft, string btt, double v1, double v2, double kVA, double z, double xr, double kVAF)

        {

            C = c;

            N = Transformers.Count;

            T = t;

            Bf = Buses.Where(bus => bus.T == bft).ToList()[0];

            Bt = Buses.Where(bus => bus.T == btt).ToList()[0];

            if (Bf == null || Bt == null)

            {

                Console.WriteLine(String.Format("Error !! Transformer Tag {0} connected to bus {1} and {2} is not defined yet.", T, Bf.N, Bt.N));

            }

            else

            {

                Bfn = Bf.N;

                Btn = Bt.N;

                if (Bf.Cn.Contains(Bt) == false) { Bf.Cn.Add(Bt); }

                if (Bt.Cn.Contains(Bf) == false) { Bt.Cn.Add(Bf); }

                V1 = v1;

                V2 = v2;

                XR = xr;

                KVA = kVA;

                KVAF = kVAF;

                Z = z;

                // calculate applicable base boltage

                //Bf.Vb = V1; // currently considered base voltage same as transformer to be changed later

                //Bt.Vb = V2; // currently considered base voltage same as transformer to be changed later

                //Y = new Complex(0.01 * Z, 0) / (new Complex(1, XR) / Math.Pow((1 + XR * XR), 0.5)) * (Sb / (1000 * KVA));    // later

                //Bf.Vpu = Bf.Vb / Bf.Vb;

                //Bt.Vpu = Bt.Vb / Bt.Vb;

            }

        }

    };

​

​

​

​

​

​

    public class Load

    {

        public string C { get; set; }  // Category "Motor"/ "Static"

        public int N { get; set; }   // Load Sequence No

        public string T { get; set; }   // Load Tag

        public int Bn { get; set; }  // Connected Bus seq. no.

        public Bus B { get; set; }     // Connected Bus

        public Complex S { get; set; }  // Complex Load in p.u

        public Complex Spu { get; set; }  // Complex Load in p.u

        public double P { get; set; }   // kW

        public double Q { get; set; }   // kVAR (+ve for inductive)

        public double FXZPC { get; set; }   // Fixed Z Percentage

        public double F { get; set; }   // Load Factor

        public Load(string c, string t, string bt, double p, double q, double fxzpc, double f)

        {

            C = c; T = t; P = p; Q = q;

            N = Loads.Count();

            FXZPC = (fxzpc < 0 || fxzpc >= 100) ? 100 : ((fxzpc >= 0 && fxzpc <= 1) ? fxzpc * 100 : fxzpc);

            F = (f < 0 || f > 100) ? 1 : (f > 1 ? f / 100 : f);

            B = Buses.Where(bus => bus.T == bt).ToList()[0];

            Bn = B.N;

            S = new Complex(1000 * P * F, 1000 * Q * F) / Sb;   // P & Q are in kilo and Sb in VA

        }

    };

​

​

​

    public class BusVisit

    {

        public Bus B { get; set; }  // Bus

        public bool V { get; set; }  // Bus Visited

        public BusVisit(Bus b, bool v)

        {

            B = b;

            V = v;

        }

    }

    public static double Sb = 5000000;

    public static double Vbg = 1000; // global if there is no transformer

​

    public static List<Bus> Buses = new List<Bus>();

    public static List<Branch> Branches = new List<Branch>();

    public static List<Cable> Cables = new List<Cable>();

    public static List<Transformer> Transformers = new List<Transformer>();

    public static List<Load> Loads = new List<Load>();

​

    public static List<BusVisit> BusVisited = new List<BusVisit>();

    public static void Main()

    {

​

        // Bus Data

        {

            Buses.Add(new Bus("Swing", "Bus53", 33));

            Buses.Add(new Bus("Variable", "Bus52", 33));

            Buses.Add(new Bus("Variable", "Bus54", 33));

            Buses.Add(new Bus("Variable", "Bus59", 33));

            Buses.Add(new Bus("Variable", "Bus51", 6.6));

            Buses.Add(new Bus("Variable", "Bus50", 6.6));

            Buses.Add(new Bus("Variable", "Bus67", 6.6));

            Buses.Add(new Bus("Variable", "Bus64", 6.6));

            Buses.Add(new Bus("Variable", "Bus56", 6.6));

            Buses.Add(new Bus("Variable", "Bus70", 0.415));

            Buses.Add(new Bus("Variable", "Bus71", 0.415));

            Buses.Add(new Bus("Variable", "Bus75", 0.415));

            Buses.Add(new Bus("Variable", "Bus77", 0.415));

            Buses.Add(new Bus("Variable", "Bus78", 0.415));

            //Buses.Add(new Bus("Swing", "Bus46", 33));

            //Buses.Add(new Bus("Variable", "Bus47", 33));

            //Buses.Add(new Bus("Variable", "Bus55", 33));

            //Buses.Add(new Bus("Variable", "Bus61", 33));

            //Buses.Add(new Bus("Variable", "Bus48", 6.6));

            //Buses.Add(new Bus("Variable", "Bus49", 6.6));

            //Buses.Add(new Bus("Variable", "Bus58", 6.6));

            //Buses.Add(new Bus("Variable", "Bus66", 6.6));

            //Buses.Add(new Bus("Variable", "Bus69", 6.6));

            //Buses.Add(new Bus("Variable", "Bus74", 0.415));

            //Buses.Add(new Bus("Variable", "Bus73", 0.415));

            //Buses.Add(new Bus("Variable", "Bus82", 0.415));

            //Buses.Add(new Bus("Variable", "Bus83", 0.415));

            //Buses.Add(new Bus("Variable", "Bus84", 0.415));

        }

        //foreach(Bus bus in Buses){      Console.WriteLine(String.Format("Type: {0}  Tag: {1} ({2}V)", bus.C, bus.T, bus.V ));}

​

        // Transformer Data

        {

            Transformers.Add(new Transformer("Transformer", "T8", "Bus54", "Bus51", 33, 6.9, 20000, 10, 10, 25000));

            Transformers.Add(new Transformer("Transformer", "T10", "Bus56", "Bus70", 6.6, 0.433, 2000, 6.25, 10, 2500));

            //Transformers.Add(new Transformer("Transformer", "T7", "Bus55", "Bus48", 33, 6.9, 20000, 10, 10, 25000));

            //Transformers.Add(new Transformer("Transformer", "T12", "Bus58", "Bus74", 6.6, 0.433, 2000, 6.25, 10, 2500));

        }

​

        // Cable Data

        {

            Cables.Add(new Cable("Cable", "C44", "Bus53", "Bus52", 0.051, 0.113, 1, 700));

            Cables.Add(new Cable("Cable", "C47", "Bus52", "Bus54", 0.051, 0.113, 1, 70));

            Cables.Add(new Cable("Cable", "C56", "Bus52", "Bus59", 0.051, 0.113, 1, 400));

            Cables.Add(new Cable("Cable", "C43", "Bus51", "Bus50", 0.102, 0.0999, 1, 100));

            Cables.Add(new Cable("Cable", "C66", "Bus50", "Bus67", 0.161, 0.105, 1, 100));

            Cables.Add(new Cable("Cable", "C62", "Bus50", "Bus64", 0.161, 0.105, 1, 100));

            Cables.Add(new Cable("Cable", "C51", "Bus50", "Bus56", 0.161, 0.105, 1, 100));

            Cables.Add(new Cable("Cable", "C70", "Bus70", "Bus71", 0.033, 0.091, 4, 100));

            Cables.Add(new Cable("Cable", "C74", "Bus71", "Bus75", 0.157, 0.073, 1, 100));

            Cables.Add(new Cable("Cable", "C76", "Bus71", "Bus77", 0.157, 0.073, 1, 100));

            Cables.Add(new Cable("Cable", "C78", "Bus71", "Bus78", 0.205, 0.074, 1, 300));

            //Cables.Add(new Cable("Cable", "c40", "Bus46", "Bus47", 0.051, 0.113, 1, 700));

            //Cables.Add(new Cable("Cable", "c48", "Bus47", "Bus55", 0.051, 0.113, 1, 70));

            //Cables.Add(new Cable("Cable", "c58", "Bus47", "Bus61", 0.051, 0.113, 1, 400));

            //Cables.Add(new Cable("Cable", "C41", "Bus48", "Bus49", 0.102, 0.0999, 1, 100));

            //Cables.Add(new Cable("Cable", "C54", "Bus49", "Bus58", 0.161, 0.105, 1, 100));

            //Cables.Add(new Cable("Cable", "C64", "Bus49", "Bus66", 0.161, 0.105, 1, 100));

            //Cables.Add(new Cable("Cable", "C68", "Bus49", "Bus69", 0.161, 0.105, 1, 100));

            //Cables.Add(new Cable("Cable", "C72", "Bus74", "Bus73", 0.033, 0.091, 4, 100));

            //Cables.Add(new Cable("Cable", "C82", "Bus73", "Bus82", 0.157, 0.073, 1, 100));

            //Cables.Add(new Cable("Cable", "C83", "Bus73", "Bus83", 0.157, 0.073, 1, 100));

            //Cables.Add(new Cable("Cable", "C84", "Bus73", "Bus84", 0.205, 0.074, 1, 300));

        }

        // Load Data

        {

            Loads.Add(new Load("Lump", "Lump2", "Bus59", 8000, 6000, 100, 100));

            Loads.Add(new Load("Motor", "Mtr5", "Bus67", 589, 247, 0, 100));

            Loads.Add(new Load("Lump", "Lump5", "Bus64", 800, 600, 100, 100));

            Loads.Add(new Load("Lump", "Lump8", "Bus75", 240, 180, 0, 100));

            Loads.Add(new Load("Lump", "Load11", "Bus77", 296, 400, 0, 100));

            Loads.Add(new Load("Lump", "Mtr8", "Bus78", 130, 57, 0, 100));

            //Loads.Add(new Load("Lump", "Lump4", "Bus61", 8000, 6000, 80, 100));

            //Loads.Add(new Load("Motor", "Mtr7", "Bus69", 589, 247, 0, 100));

            //Loads.Add(new Load("Lump", "Lump7", "Bus66", 800, 600, 80, 100));

            //Loads.Add(new Load("Lump", "Load12", "Bus82", 240, 180, 0, 100));

            //Loads.Add(new Load("Lump", "Load12", "Bus83", 296, 400, 0, 100));

            //Loads.Add(new Load("Lump", "Mtr10", "Bus84", 130, 57, 0, 100));

        }

​

​

        foreach (Cable cable in Cables)

        {

            Branches.Add(new Branch("Cable", cable.T, cable.Bf, cable.Bt, cable.Y));

            //Console.WriteLine(String.Format("#{0}  From {1} ({2}V) to {3} ({4}V) R:{5} X: {6} Zb, {7}  Y: ({8}, {9})", cable.T, cable.Bf.T, cable.Bf.V, cable.Bt.T, cable.Bt.V, cable.R, cable.X, Math.Round(cable.Zb, 2), Math.Round(cable.Y.Real, 2), Math.Round(cable.Y.Imaginary, 2)  ));

        };

​

        foreach (Transformer trafo in Transformers)

        {

            Branches.Add(new Branch("Transformer", trafo.T, trafo.Bf, trafo.Bt, trafo.Y));

        };

​

        foreach (Load load in Loads)

        {

            Console.WriteLine(String.Format("#{0}  Tag: {1} Connected to{2} ({3}V)  S: {8} p.u.  P: {4} kW  Q:{5} kVAR FixedZ: {6} Load Factor: {7})", load.N, load.T, load.B.T, load.B.V, load.P, load.Q, load.FXZPC, load.F, load.S.Magnitude  ));

        }

        //Console.WriteLine(" ok");

        // Breadth First Search

​

        foreach (Bus bus in Buses) { BusVisited.Add(new BusVisit(bus, false)); }; // Initialised

        Buses.Sort((x, y) => x.C.CompareTo(y.C));

        Buses.OrderBy(x => x.C); // sorting by Category (Swing Bus first)

​

        //foreach (Bus bus in Buses) {Console.WriteLine(String.Format(" Bus {0}  {1}", bus.T, bus.C ));}

        string ParentBusT;

        Bus ParentBus;

        foreach (Bus swingBus in Buses.Where(b => b.C == "Swing").ToList()) {

            ParentBusT = swingBus.T;

            ParentBus = Buses.Where(b => b.T == ParentBusT).ToList()[0];

            // Apply Base voltage to this starting Swing Bus

            Buses.Where(b => b.T == ParentBusT).ToList()[0].Vb = Buses.Where(b => b.T == ParentBusT).ToList()[0].V;

            Buses.Where(b => b.T == ParentBusT).ToList()[0].Vpu = 1; // Initialised

            FunctionBFS(Buses.Where(b => b.T == ParentBusT).ToList()[0], Buses.Where(b => b.T == ParentBusT).ToList()[0]);

        }

        // Calculating Zb and Zpu for all cable branches

        foreach (Cable cable in Cables)

        {

            cable.Vb = cable.Bf.Vb;

            cable.Zb = Math.Pow(cable.Vb, 2) / Sb;

            cable.Y = new Complex(cable.Zb, 0) / new Complex(cable.R * (cable.L / 1000) / cable.Rn, cable.X * (cable.L / 1000) / cable.Rn);

​

            Branches.Where(b => b.T == cable.T).ToList()[0].Y = cable.Y;

​

            //Bf.Vb = V1; // currently considered base voltage same as transformer to be changed later

            //Bt.Vb = V2; // currently considered base voltage same as transformer to be changed later

            //Y = new Complex(0.01 * Z, 0) / (new Complex(1, XR) / Math.Pow((1 + XR * XR), 0.5)) * (Sb / (1000 * KVA));    // later

            //Bf.Vpu = Bf.Vb / Bf.Vb;

            //Bt.Vpu = Bt.Vb / Bt.Vb;

        }

        // Calculating Zb and Zpu for all transformer branches

        foreach (Transformer trafo in Transformers)

        {

            trafo.Y = Math.Pow(trafo.V1/trafo.Bf.Vb,2)* new Complex(0.01 * trafo.Z, 0) / (new Complex(1, trafo.XR) / Math.Pow((1 + trafo.XR * trafo.XR), 0.5)) * (Sb / (1000 * trafo.KVA));

        }

​

        //

​

        DoLoadFlow();

    }

    public static void FunctionBFS(Bus prntBus, Bus thisBus)

    {

        //Console.WriteLine(String.Format(" BFS for Parent Bus : {0}   This Bus : {1} ", prntBus.T, thisBus.T));

        Bus B = Buses.Where(b => b.T == thisBus.T).ToList()[0];

        foreach (Bus childBus in B.Cn)

        {

            if (childBus.T == prntBus.T) { continue; }

            Branch BR = Branches.Where(br => (br.Bf.T == thisBus.T && br.Bt.T == childBus.T) || (br.Bt.T == thisBus.T && br.Bf.T == childBus.T)).ToList()[0];

            // if this branch is a cable

            if (BR.C == "Cable")

            {

                // set Base Voltage for this child bus same as the Base Voltage of thisBus

                Buses.Where(b => b.T == childBus.T).ToList()[0].Vb = thisBus.Vb;

​

            }

            else if (BR.C == "Transformer")

            {

                Transformer TR = Transformers.Where(tr => tr.T == BR.T).ToList()[0];

                double V1, V2;

                V1 = (TR.Bf.T == thisBus.T) ? TR.V1 : TR.V2;

                V2 = (TR.Bt.T == thisBus.T) ? TR.V1 : TR.V2;

                Buses.Where(b => b.T == childBus.T).ToList()[0].Vb = thisBus.Vb * V2 / V1;

                Buses.Where(b => b.T == childBus.T).ToList()[0].Vpu = 1; // Initialised

            }

            //Console.WriteLine(String.Format("Parent Bus: {0}  This Bus: {1} Child Bus: {2}  Branch: {3}({6})  Vb This: {4}  Vb Child: {5}", prntBus.T, thisBus.T, childBus.T, BR.T, Buses.Where(b => b.T == thisBus.T).ToList()[0].Vb, Buses.Where(b => b.T == childBus.T).ToList()[0].Vb, BR.C));

            // check if this is the end of this branch

            if (childBus.Cn.Count() == 1 )        // no more connection 

            {

                //Console.WriteLine(String.Format(" == 1 : childBus {0} .Cn.Count() {1} ", childBus.T, childBus.Cn.Count()));

                BusVisited.Where(bv => bv.B.T == childBus.T).ToList()[0].V = true;            // mark this child bus as 'visited'

                if (BusVisitComplete(childBus, thisBus)== true) // all downstream connections are visited

                {

                    BusVisited.Where(bv => bv.B.T == thisBus.T).ToList()[0].V = true;

                }

            }

            else // more further connections

            {

                //Console.WriteLine(String.Format(" > 1 : childBus {0} .Cn.Count() {1} ", childBus.T, childBus.Cn.Count()));

                // call the function

                FunctionBFS(thisBus, childBus);

            }

        }

    }

​

    static bool BusVisitComplete(Bus bb, Bus parentBus)

    {

        foreach (Bus b in bb.Cn)

        {

            if (b.T == parentBus.T) { continue; }

            BusVisit BV = BusVisited.Where(bv => bv.B.T == b.T).ToList()[0];

            if (BusVisitComplete(BV.B, bb) == false) { return false; }

        }

        return true;

    }

    static void DoLoadFlow()

    {

        Console.WriteLine("Starting Load Flow.......");

        Buses.Sort((x, y) => x.C.CompareTo(y.C));

        Buses.OrderBy(x => x.C); // sorting by Category (Swing Bus first)

        int n = Buses.Count; // bus

        int iteration = 10;

​

​

        foreach (Bus b1 in Buses)

        {

            b1.Ybb = new Complex(0, 0);  // initialising self addmittances (sum of admittance of connected branches

            foreach (Bus b2 in b1.Cn)

            {

                b1.Ybb = b1.Ybb + Branches.Where(branch => (branch.Bf == b1 && branch.Bt == b2) || branch.Bf == b2 && branch.Bt == b1).ToList()[0].Y;

            }

        }

​

​

​

        for (int k = 0; k < iteration; k++)

        {

​

            //consider bus 0 is a swing bus whose voltage is fixed at 1.0 pu

            // iterate for the remaining bus

            foreach (Bus bus in Buses)

            {

                if (bus.C == "Swing") continue;

​

                //adjusting the VA as per bus voltages

                List<Load> BLoads = new List<Load>() { };

                BLoads = Loads.Where(load => load.B.T == bus.T).ToList(); // listing all the loads which are connected to this bus

                bus.Sit = new Complex(0, 0);    // initialised

                foreach (Load load in BLoads)

                {

                    bus.Sit = bus.Sit + load.S* (1-load.FXZPC/100) + load.S * (load.FXZPC/100) * Math.Pow(bus.Vit.Magnitude / bus.Vpu, 2); ;

                }

                Console.WriteLine(String.Format("Iteration {0} : Bus {1} ({2}) : S: {7} ({3} {4}) : Vit : {5} Vpu : {6}", k, bus.N, bus.T, Math.Round(Sb*bus.Sit.Real/1000, 2), Math.Round(Sb*bus.Sit.Imaginary/1000, 2), Math.Round(bus.Vit.Magnitude, 2), Math.Round(bus.Vpu, 2),  Math.Round(bus.Sit.Magnitude,3)  ));

​

                // let initial educated guess for IV[i] = 1.o p.u

                Complex IV = new Complex(bus.Vit.Real, bus.Vit.Imaginary);

                Branch BB;

                Complex Ybb;

                Complex VY = new Complex(0, 0);

                foreach (Bus b1 in bus.Cn)

                {

                    BB = Branches.Where(branch => (branch.Bf == bus && branch.Bt == b1) || branch.Bt == bus && branch.Bf == b1).ToList()[0];

                    string stemp = BB.Bf.N.ToString() + " - " + BB.Bt.N.ToString();

                    Ybb = BB.Y;

                    VY = VY + b1.Vit * Ybb;

                }

​

                //Console.WriteLine(String.Format("Iteration {5} : VY for {6} >  Array : ({0} {1}) : Class : ({2} {3}) : {4}", VY.Real, VY.Imaginary, VY1.Real, VY1.Imaginary, (VY == VY1).ToString(), k, bus.N));

​

                Double d;

                int count = 0;

                do

                {

                    bus.Vit = (VY - Complex.Conjugate(bus.Sit / IV)) / bus.Ybb;

                    d = (bus.Vit - IV).Magnitude / bus.Vit.Magnitude;

                    IV = new Complex(bus.Vit.Real, bus.Vit.Imaginary);

                    //Console.WriteLine(String.Format("Iteration {0} : Bus{1} ({2}) : d: {5} & {6} same : {3}  IV: {7} & {8} same: {4}", k, bus.N, bus.T, d == d1, IV == IV1, d, d1, IV, IV1));

                    count = count + 1;

                } while (d > 0.000001 && count < 10);

​

            }

​

​

        }

​

        //results

​

        foreach (Bus b in Buses)

        {

            Console.WriteLine(String.Format(

                "Bus # {0} : {1} : Voltage : {2}%  {3} deg    [{4},{5}]",

                b.N, b.T, Math.Round(100 * Complex.Abs(b.Vit), 2), Math.Round(b.Vit.Phase * 180 / Math.PI, 2),

                Math.Round(100 * b.Vit.Real, 2), Math.Round(100 * b.Vit.Imaginary, 2)));

        }

​

        Console.WriteLine();

​

        foreach (Branch br in Branches)

        {

            Complex In = (br.Bf.Vit - br.Bt.Vit) * br.Y;

            Complex Sn1 = br.Bf.Vit * Complex.Conjugate(In);

            Complex Sn2 = br.Bt.Vit * Complex.Conjugate(In);

            Complex Loss = (br.Bf.Vit - br.Bt.Vit) * Complex.Conjugate(In);

            Console.WriteLine(String.Format(

                            "Branch {0}-{1}: {2} A  S{0}: {3} ({4},{5})  S{1}: {6} ({7},{8})  Loss: ({9}, {10})",

                            br.Bf.N, br.Bt.N, Math.Round((500 / 1.732) * Complex.Abs(In), 3),

                            Math.Round(500 * Complex.Abs(Sn1), 1), Math.Round(500 * Sn1.Real, 1), Math.Round(500 * Sn1.Imaginary, 1),

                            Math.Round(500 * Complex.Abs(Sn2), 1), Math.Round(500 * Sn2.Real, 1), Math.Round(500 * Sn2.Imaginary, 1),

                            Math.Round(500 * Loss.Real, 3), Math.Round(500 * Loss.Imaginary, 3)));

​

        }

​

    }

​

    }

​