Ejemplo n.º 1
0
 /// <summary>
 /// Connects this <see cref="PowerDeliveryElement"/> between <paramref name="bus1"/>
 /// and <paramref name="bus2"/> on matching <paramref name="phases"/>.
 /// </summary>
 /// <param name="bus1">The first <see cref="Bus"/> to connect to.</param>
 /// <param name="bus2">The second <see cref="Bus"/> to connect to.</param>
 /// <param name="phases">The phases to connect the <see cref="PowerDeliveryElement"/>
 /// to the <see cref="Bus"/>es on.</param>
 public void Connect(Bus bus1, Bus bus2, params int[] phases)
 {
     foreach (var phase in phases)
     {
         Connect(phase, bus1, phase, bus2, phase);
     }
 }
 /// <summary>
 /// Connects this power conversion element in Wye to <paramref name="connectTo"/>. Each phase of the
 /// <see cref="PowerConversionElement"/>in <paramref name="pcElementPhases"/> is connected to the phase of the same index in
 /// <paramref name="busPhases"/>.
 /// </summary>
 /// <param name="connectTo">The <see cref="Bus"/> to connect this <see cref="PowerConversionElement"/> to.</param>
 /// <param name="pcElementPhases">The phases of this element that should be connected.</param>
 /// <param name="busPhases">The phases of <paramref name="connectTo"/> to connect to.</param>
 public void ConnectWye(Bus connectTo, IEnumerable<int> pcElementPhases, IEnumerable<int> busPhases)
 {
     foreach (var phasePair in pcElementPhases.Zip(busPhases,(pcElementPhase,busPhase) => new {pcElementPhase,busPhase}))
     {
         Connect(phasePair.pcElementPhase, connectTo, phasePair.busPhase);
     }
 }
 public void Connect()
 {
     FakePCElement pcElem = new FakePCElement();
     Bus b = new Bus("Test", Complex.Zero, 0, null);
     pcElem.Connect(1, b, 1);
     PairConnectionAssertions(pcElem, 1, b, 1);
 }
Ejemplo n.º 4
0
 private static void TraceToSource(Bus FromBus, Bus BusThatStartedItAll, HashSet<Bus> busesInThisTrace, HashSet<Bus> busesOnPath)
 {
     //start at FromBus, take a step away from FromBus.
     //If we're at the source, add the path that we took to BusesOnRouteToSource.
     //If we're at a dead-end, then stop tracing this branch.
     //If we hit a bus that's already on the route, then terminate and add the branch.
     var connectedBuses = FromBus.ConnectedTo.OfType<Line>().Select(line => line.ConnectedTo.OfType<Bus>().Except(FromBus.Yield()).Single()) //all the buses neighbouring this one
         .Except(busesInThisTrace) //exclude any buses we've already touched in this trace
         ;
     foreach (var bus in connectedBuses)
     {
         if (busesOnPath.Contains(bus)) //we're connected to the target bus. no further processing required on this branch.
         {
             busesOnPath.UnionWith(busesInThisTrace.Except(BusThatStartedItAll.Yield()));
             continue;
         }
         else
         {
             //keep searching!
             HashSet<Bus> NextStepTraceList;
             if (connectedBuses.Count() == 1) //if this is the only possible way forward, then just keep using the same thingy.
             {
                 NextStepTraceList = busesInThisTrace;
             }
             else
             {
                 NextStepTraceList = new HashSet<Bus>(busesInThisTrace);
             }
             NextStepTraceList.Add(bus);
             TraceToSource(bus, BusThatStartedItAll, NextStepTraceList, busesOnPath);
         }
     }
 }
Ejemplo n.º 5
0
        /// <summary>
        /// Obtains the direct line length between two buses.
        /// </summary>
        /// <param name="FromBus">The bus to trace from.</param>
        /// <param name="ToBus">The bus to find the line length to.</param>
        /// <returns>The line length, in metres.</returns>
        public static double GetDirectLengthBetweenBuses(Bus FromBus, Bus ToBus)
        {
            var busList = Tracing.BusesOnRouteToTarget(FromBus, ToBus);

            Dictionary<Bus, double> lengths = new Dictionary<Bus, double>();
            Tracing.TraceFromWithCallback(ToBus, busList, (thisBus, line, nextBus) => lengths[nextBus] = (lengths.ContainsKey(thisBus) ? lengths[thisBus] : 0) + line.Length);
            return lengths[FromBus];
        }
Ejemplo n.º 6
0
 /// <summary>
 /// Obtains a list of all buses directly or indirectly connected to <paramref name="FromBus"/>,
 /// so long as they are connected in a fashion that does not rely upon the presence of any elements of
 /// <paramref name="BusesToExclude"/>
 /// </summary>
 /// <param name="FromBus">The <see cref="Bus"/> to trace from.</param>
 /// <param name="BusesToExclude">A set of <see cref="Bus"/>es that should be avoided in the trace operation.</param>
 /// <returns>A list of all buses directly or indirectly connected to <paramref name="FromBus"/>, 
 /// so long as connection is not through any element in <paramref name="BusesToExclude"/>.</returns>
 public static IEnumerable<Bus> TraceWithoutCrossingBuses(Bus FromBus, IEnumerable<Bus> BusesToExclude)
 {
     var BusesInTrace = new HashSet<Bus>(FromBus.Yield());
     var BusesInPath = new HashSet<Bus>();
     _traceWithoutCrossingBuses(FromBus, new HashSet<Bus>(BusesToExclude), BusesInTrace, BusesInPath);
     BusesInPath.Add(FromBus);
     return BusesInPath;
 }
Ejemplo n.º 7
0
        /// <summary>
        /// Instantiates a new <see cref="NetworkModel"/>.
        /// </summary>
        /// <param name="Buses">All the buses in the network.</param>
        /// <param name="Lines">All the lines in the network.</param>
        /// <param name="Loads">All the loads in the network.</param>
        /// <param name="Generators">All the generators in the network.</param>
        /// <param name="Losses">The losses (in kVA) across the whole network.</param>
        /// <param name="SourceBus">The source bus (fixed bus) of the network.</param>
        public NetworkModel(Dictionary<String, Bus> Buses, Collection<Line> Lines, Collection<Load> Loads, Collection<Generator> Generators, Complex Losses, Bus SourceBus)
        {
            this.Buses = Buses;
            this.Lines = Lines;
            this.Loads = Loads;
            this.Generators = Generators;
            this.LosseskVA = Losses;
            this.SourceBus = SourceBus;

            networkBounds = FindNetworkBounds();
        }
Ejemplo n.º 8
0
 /// <summary>
 /// Obtains a list of all buses that are directly on-route from
 /// <paramref name="FromBus"/> to <paramref name="TargetBus"/>.
 /// </summary>
 /// <param name="FromBus">The <see cref="Bus"/> to trace from.</param>
 /// <param name="TargetBus">The <see cref="Bus"/> to trace to.</param>
 /// <returns>A list of all buses that are directly on-route from
 /// <paramref name="FromBus"/> to <paramref name="TargetBus"/> (inclusive).</returns>
 public static IEnumerable<Bus> BusesOnRouteToTarget(Bus FromBus, Bus TargetBus)
 {
     //start at FromBus, take a step away from FromBus.
     //If we're at the source, add the path that we took to BusesOnRouteToSource.
     //If we're at a dead-end, then stop tracing this branch.
     //If we hit a bus that's already on the route, then terminate and add the branch.
     HashSet<Bus> results = new HashSet<Bus>(TargetBus.Yield());
     HashSet<Bus> thisTrace = new HashSet<Bus>(FromBus.Yield());
     TraceToSource(FromBus, FromBus, thisTrace, results);
     results.Add(FromBus);
     return (IEnumerable<Bus>)results;
 }
Ejemplo n.º 9
0
 /// <summary>
 /// Connects the <see cref="PowerDeliveryElement"/> on the phases in <paramref name="bus1AndLinePhases"/>
 /// to the same phases on <paramref name="bus1"/>, and to the correspondingly-indexed phases <paramref name="bus2Phases"/>
 /// on <paramref name="bus2"/>.
 /// </summary>
 /// <example>
 /// The following code connects the <see cref="PowerDeliveryElement"/> to <paramref name="bus1"/>
 /// and <paramref name="bus2"/>, with the following phasing:
 /// <code>
 /// // key: line phase -> bus1 phase, bus2 phase
 /// // 1 -> 1, 2
 /// // 2 -> 2, 3
 /// // 3 -> 3, 1
 /// myPowerDeliveryElement.Connect(bus1, new[] {1,2,3}, bus2, new[] {2,3,1});
 /// </code></example>
 /// <param name="bus1">The first <see cref="Bus"/> to connect to. Shares common phases with the <see cref="PowerDeliveryElement"/>.</param>
 /// <param name="bus1AndLinePhases">The common phases to connect between the <see cref="PowerDeliveryElement"/> and the <see cref="Bus"/>.</param>
 /// <param name="bus2">The second <see cref="Bus"/> to connect to.</param>
 /// <param name="bus2Phases">Phase connections for <paramref name="bus2"/>.</param>
 public void Connect(Bus bus1, IEnumerable<int> bus1AndLinePhases, Bus bus2, IEnumerable<int> bus2Phases)
 {
     foreach (var phasePair in bus1AndLinePhases.Zip(bus2Phases, (phase1, phase2) => new { Bus1AndLinePhase = phase1, Bus2Phase = phase2 }))
     {
         NetworkElement.ConnectBetween(this,
             phasePair.Bus1AndLinePhase,
             bus1,
             phasePair.Bus1AndLinePhase,
             bus2,
             phasePair.Bus2Phase
             );
     }
 }
Ejemplo n.º 10
0
        public void PrepBalanced()
        {
            Dictionary<String, Bus> buses = new Dictionary<string, Bus>();
            buses["b1"] = new Bus("b1", pr(132.79, 0), 132.79, new Point(0, 0));
            buses["b2"] = new Bus("b2", pr(133.73, -0.1), 132.79, new Point(0, 0));
            buses["b3"] = new Bus("b3", pr(133.55, -0.1), 132.79, new Point(0, 0));
            buses["b4"] = new Bus("b4", pr(133.99, -0.1), 132.79, new Point(0, 0));

            var lb1b2 = new Line("b1b2", 1);
            lb1b2.Connect(buses["b1"], buses["b2"]);
            var lb1b3 = new Line("b1b3", 2);
            lb1b3.Connect(buses["b1"], buses["b3"]);
            var lb2b4 = new Line("b2b4", 3);
            lb2b4.Connect(buses["b2"], buses["b4"]);
            var lb3b4 = new Line("b3b4", 4);
            lb3b4.Connect(buses["b3"], buses["b4"]);

            Collection<Line> lines = new Collection<Line>();
            lines.Add(lb1b2);
            lines.Add(lb1b3);
            lines.Add(lb2b4);
            lines.Add(lb3b4);

            Generator g = new Generator("g4", new Complex(318000, 0));

            g.Connect(buses["b4"]);
            Collection<Generator> generators = new Collection<Generator>();
            generators.Add(g);

            Collection<Load> loads = new Collection<Load>();
            var l1 = new Load("l1", new Complex(50000, 30990));
            l1.Connect(buses["b1"]);
            var l2 = new Load("l2", new Complex(170000, 105350));
            l2.Connect(buses["b2"]);
            var l3 = new Load("l3", new Complex(200000, 12940));
            l3.Connect(buses["b3"]);
            var l4 = new Load("l4", new Complex(80000, 49580));
            l4.Connect(buses["b4"]);
            loads.Add(l1);
            loads.Add(l2);
            loads.Add(l3);
            loads.Add(l4);

            model = new NetworkModel(buses, lines, loads, generators, new Complex(19580, -17810600), buses["b1"]);
        }
Ejemplo n.º 11
0
 /// <summary>
 /// Connects this <see cref="PowerDeliveryElement"/> between two <see cref="Bus"/>es. This method is for
 /// building three-phase balanced networks. Use
 /// <see cref="Connect3Phase"/>, <see cref="Connect(int,Bus,int,Bus,int)"/>, <see cref="Connect(Bus,Bus,int[])"/>
 /// and <see cref="Connect(Bus,IEnumerable{int},Bus,IEnumerable{int})"/> for arbitrarily-phased networks.
 /// </summary>
 ///<param name="bus1">The <see cref="Bus"/> to connect on one side of this <see cref="PowerDeliveryElement"/>.</param>
 /// <param name="bus2">The <see cref="Bus"/> to connect on the other side of this <see cref="PowerDeliveryElement"/>.</param>
 public void Connect(Bus bus1, Bus bus2)
 {
     Connect3Phase(bus1, bus2);
 }
Ejemplo n.º 12
0
 /// <summary>
 /// Connects this <see cref="PowerDeliveryElement"/> between two <see cref="Bus"/>es,
 /// on phases 1,2,3.
 /// </summary>
 ///<param name="bus1">The <see cref="Bus"/> to connect on one side of this <see cref="PowerDeliveryElement"/>.</param>
 /// <param name="bus2">The <see cref="Bus"/> to connect on the other side of this <see cref="PowerDeliveryElement"/>.</param>
 public void Connect3Phase(Bus bus1, Bus bus2)
 {
     Connect(bus1, bus2, 1, 2, 3);
 }
Ejemplo n.º 13
0
 /// <summary>
 /// Traces from <paramref name="FromBus"/> along all buses in <paramref name="AllowedBuses"/>,
 /// and executing <paramref name="Callback"/> for every connection between two buses.
 /// </summary>
 /// <param name="FromBus">The bus to trace from.</param>
 /// <param name="AllowedBuses">All buses that are to be allowed in the trace.</param>
 /// <param name="Callback">A custom action to execute for every connection.</param>
 public static void TraceFromWithCallback(Bus FromBus, IEnumerable<Bus> AllowedBuses, Action<Bus, Line, Bus> Callback)
 {
     HashSet<Bus> thisTrace = new HashSet<Bus>(FromBus.Yield());
     _traceFromWithCallback(FromBus, AllowedBuses, thisTrace, Callback);
 }
Ejemplo n.º 14
0
        public void PrepUnbalanced()
        {
            Dictionary<String, Bus> buses = new Dictionary<string, Bus>();
            buses["b1"] = new Bus("b1", pc3pr(130770, 0.4, 132860, -120.8, 134130, 120.6), 132.79, new Point(0, 0));
            buses["b2"] = new Bus("b2", pc3pr(866380, 99.9, 83445, -21.2, 86499, -142.5), 132.79, new Point(0, 0));
            buses["b3"] = new Bus("b3", pc3pr(94825, 14.5, 96205, -107.4, 98249, 134.2), 132.79, new Point(0, 0));
            buses["b4"] = new Bus("b4", pc3pr(67374, 68.6, 65606, -54, 69131, -174), 132.79, new Point(0, 0));

            var lb1b2 = new Line("b1b2", 1);
            lb1b2.Connect(buses["b1"], new[] { 1, 2, 3 }, buses["b2"], new[] { 2, 3, 1 });
            var lb1b3 = new Line("b1b3", 2);
            lb1b3.Connect3Phase(buses["b1"], buses["b3"]);
            var lb2b4 = new Line("b2b4", 3);
            lb2b4.Connect3Phase(buses["b2"], buses["b4"]);
            var lb3b4 = new Line("b3b4", 4);
            lb3b4.Connect(buses["b3"], buses["b4"], new[] { 1, 2 });

            Collection<Line> lines = new Collection<Line>();
            lines.Add(lb1b2);
            lines.Add(lb1b3);
            lines.Add(lb2b4);
            lines.Add(lb3b4);

            Generator g = new Generator("g4", pc3(106000, 0.9797, 106000, -1.3930, 106000, 0.4265));

            g.ConnectWye(buses["b4"]);
            Collection<Generator> generators = new Collection<Generator>();
            generators.Add(g);

            Collection<Load> loads = new Collection<Load>();
            var l1 = new Load("l1", pc3(16382, 10280, 16852, 10108, 16766, 10601));
            l1.ConnectWye(buses["b1"], 1, 2, 3);
            var l2 = new Load("l2", pcV(2, 85000, 52674, 3, 85000, 52675));
            l2.ConnectWye(buses["b2"], 2, 3);
            var l3 = new Load("l3", pcV(1, 200000, 12940));
            l3.ConnectWye(buses["b3"], 1, 2);
            var l4 = new Load("l4", pc3(26666, 16527, 26666, 16527, 26666, 16527));
            l4.ConnectWye(buses["b4"], 1, 2, 3);
            loads.Add(l1);
            loads.Add(l2);
            loads.Add(l3);
            loads.Add(l4);

            model = new NetworkModel(buses, lines, loads, generators, new Complex(140424, 692575), buses["b1"]);
        }
Ejemplo n.º 15
0
        private static void _traceFromWithCallback(Bus FromBus, IEnumerable<Bus> AllowedBuses, HashSet<Bus> busesInThisTrace, Action<Bus, Line, Bus> Callback)
        {
            var connectedBuses = FromBus.ConnectedTo.OfType<Line>().Select(line => Tuple.Create(line, line.ConnectedTo.OfType<Bus>().Except(FromBus.Yield()).Single())) //all the buses neighbouring this one
                .Where(t => !busesInThisTrace.Contains(t.Item2) && AllowedBuses.Contains(t.Item2)) //exclude any buses we've already touched in this trace, and any buses that aren't in the allowed set.
                ;
            foreach (var bus in connectedBuses)
            {
                Callback(FromBus, bus.Item1, bus.Item2);

                //keep searching!
                HashSet<Bus> NextStepTraceList = connectedBuses.Count() == 1 ? busesInThisTrace : new HashSet<Bus>(busesInThisTrace);

                NextStepTraceList.Add(bus.Item2);
                _traceFromWithCallback(bus.Item2, AllowedBuses, NextStepTraceList, Callback);
            }
        }
Ejemplo n.º 16
0
 private static void _traceWithoutCrossingBuses(Bus FromBus, HashSet<Bus> ExcludeList, HashSet<Bus> busesInThisTrace, HashSet<Bus> busesOnPath)
 {
     var connectedBuses = FromBus.ConnectedTo.OfType<Line>().Select(line => line.ConnectedTo.OfType<Bus>().Except(FromBus.Yield()).Single()) //all the buses neighbouring this one
        .Except(busesInThisTrace) //exclude any buses we've already touched in this trace
        ;
     if (connectedBuses.Count() == 0)
     {
         busesOnPath.UnionWith(busesInThisTrace);
         return;
     }
     foreach (var bus in connectedBuses)
     {
         if (ExcludeList.Contains(bus)) //we're connected to the target bus. end the thread.
         {
             continue;
         }
         else
         {
             //keep searching!
             HashSet<Bus> NextStepTraceList;
             if (connectedBuses.Count() == 1) //if this is the only possible way forward, then just keep using the same thingy.
             {
                 NextStepTraceList = busesInThisTrace;
             }
             else
             {
                 NextStepTraceList = new HashSet<Bus>(busesInThisTrace);
             }
             NextStepTraceList.Add(bus);
             _traceWithoutCrossingBuses(bus, ExcludeList, NextStepTraceList, busesOnPath);
         }
     }
 }
Ejemplo n.º 17
0
 /// <summary>
 /// Connects this <see cref="PowerConversionElement"/> to a <see cref="Bus"/>.
 /// This is the connection method for three-phase balanced networks. Use
 /// <see cref="O:ElecNetKit.NetworkModelling.PowerConversionElement.ConnectWye" /> and <see cref="Connect(int,Bus,int)"/>
 /// for arbitrarily-phased networks.
 /// </summary>
 /// <param name="connectTo">The <see cref="Bus"/> to connect to.</param>
 /// <overloads>There are multiple overloads for this method:</overloads>
 public void Connect(Bus connectTo)
 {
     ConnectWye(connectTo, 1, 2, 3);
 }
Ejemplo n.º 18
0
 /// <summary>
 /// Connects a phase of a power conversion element between two phases of a single <see cref="Bus"/>.
 /// </summary>
 /// <param name="thisPhase">The phase of this <see cref="PowerConversionElement"/> to connect between phases of the bus.</param>
 /// <param name="connectTo">The bus to connect <paramref name="thisPhase"/> of this <see cref="PowerConversionElement"/> to.</param>
 /// <param name="connectToPhasePrimary">The primary phase of the bus to connect to. Should be an active phase.</param>
 public void Connect(int thisPhase, Bus connectTo, int connectToPhasePrimary)
 {
     base.Connect(thisPhase, connectTo, connectToPhasePrimary);
 }
Ejemplo n.º 19
0
 /// <summary>
 /// Connects this <see cref="PowerDeliveryElement"/> between two <see cref="Bus"/>es. This method is for
 /// building three-phase balanced networks. Use
 /// <see cref="Connect3Phase"/>, <see cref="Connect(int,Bus,int,Bus,int)"/>, <see cref="Connect(Bus,Bus,int[])"/>
 /// and <see cref="Connect(Bus,IEnumerable{int},Bus,IEnumerable{int})"/> for arbitrarily-phased networks.
 /// </summary>
 ///<param name="bus1">The <see cref="Bus"/> to connect on one side of this <see cref="PowerDeliveryElement"/>.</param>
 /// <param name="bus2">The <see cref="Bus"/> to connect on the other side of this <see cref="PowerDeliveryElement"/>.</param>
 public void Connect(Bus bus1, Bus bus2)
 {
     Connect3Phase(bus1, bus2);
 }
Ejemplo n.º 20
0
 /// <summary>
 /// Connects this power conversion element in Wye to <paramref name="connectTo"/>. Each phase of
 /// the <see cref="PowerConversionElement"/> specified in <paramref name="phases"/> will be connected
 /// to the corresponding active phase.
 /// </summary>
 /// <param name="connectTo">The <see cref="Bus"/> that the <see cref="PowerConversionElement"/> should connect to.</param>
 /// <param name="phases">The phases of the <see cref="PowerConversionElement"/> and the active phases of the <see cref="Bus"/>
 /// to connect on.</param>
 /// <overloads>There are multiple overloads for this method:</overloads>
 public void ConnectWye(Bus connectTo, params int[] phases)
 {
     if (phases.Length == 0)
         phases = new[] { 1, 2, 3 };
     ConnectWye(connectTo, phases, phases);
 }
Ejemplo n.º 21
0
 /// <summary>
 /// Connects <paramref name="thisPhase"/> of this <see cref="PowerDeliveryElement"/> between
 /// <paramref name="bus1Phase"/> of <paramref name="bus1"/> and <paramref name="bus2Phase"/>
 /// of <paramref name="bus2"/>.
 /// </summary>
 /// <param name="thisPhase">The phase of this element to connect.</param>
 /// <param name="bus1">The <see cref="Bus"/> to connect on one side of this <see cref="PowerDeliveryElement"/>.</param>
 /// <param name="bus1Phase">The phase of <paramref name="bus1"/> to connect to.</param>
 /// <param name="bus2">The <see cref="Bus"/> to connect on the other side of this <see cref="PowerDeliveryElement"/>.</param>
 /// <param name="bus2Phase">The phase of <paramref name="bus2"/> to connect to.</param>
 public void Connect(int thisPhase, Bus bus1, int bus1Phase, Bus bus2, int bus2Phase)
 {
     NetworkElement.ConnectBetween(this, thisPhase, bus1, bus1Phase, bus2, bus2Phase);
 }
Ejemplo n.º 22
0
 /// <summary>
 /// Connects <paramref name="thisPhase"/> of this <see cref="PowerDeliveryElement"/> between
 /// <paramref name="bus1Phase"/> of <paramref name="bus1"/> and <paramref name="bus2Phase"/>
 /// of <paramref name="bus2"/>.
 /// </summary>
 /// <param name="thisPhase">The phase of this element to connect.</param>
 /// <param name="bus1">The <see cref="Bus"/> to connect on one side of this <see cref="PowerDeliveryElement"/>.</param>
 /// <param name="bus1Phase">The phase of <paramref name="bus1"/> to connect to.</param>
 /// <param name="bus2">The <see cref="Bus"/> to connect on the other side of this <see cref="PowerDeliveryElement"/>.</param>
 /// <param name="bus2Phase">The phase of <paramref name="bus2"/> to connect to.</param>
 public void Connect(int thisPhase, Bus bus1, int bus1Phase, Bus bus2, int bus2Phase)
 {
     NetworkElement.ConnectBetween(this, thisPhase, bus1, bus1Phase, bus2, bus2Phase);
 }
Ejemplo n.º 23
0
 /// <summary>
 /// Connects this <see cref="PowerDeliveryElement"/> between two <see cref="Bus"/>es,
 /// on phases 1,2,3.
 /// </summary>
 ///<param name="bus1">The <see cref="Bus"/> to connect on one side of this <see cref="PowerDeliveryElement"/>.</param>
 /// <param name="bus2">The <see cref="Bus"/> to connect on the other side of this <see cref="PowerDeliveryElement"/>.</param>
 public void Connect3Phase(Bus bus1, Bus bus2)
 {
     Connect(bus1, bus2, 1, 2, 3);
 }