public ACAnalysis():base()
 {
     Name = "AC Analysis " + ID.ToString();
     StartFrequency = "10";
     EndFrequency = "10Meg";
     Points = 101;
     ScanType = ACAnalysisScan.Decade;
     Solver= new ACSweepSolver();
 }
 private void AddVoltage(ACSweepSolver sol5, string NodeName)
 {
     foreach (var data in sol5.Voltages)
     {
         foreach (var item in data.Value)
         {
             if (item.Key == NodeName)
             {
                 Tuple<double, double> p = new Tuple<double, double>(data.Key, item.Value.Magnitude);
                 source1.Collection.Add(p);
                 p = new Tuple<double, double>(data.Key, 180 * item.Value.Phase / Math.PI);
                 source2.Collection.Add(p);
                 break;
             }
         }
     }
 }
        public override bool Solve(Circuit cir, BasicAnalysis ana)
        {
            List <Node> nodos = new List <Node>();

            CurrentAnalysis = ana as ComplexPlainAnalysis;
            CurrentCircuit  = cir;

            //List<Node> nodosnorton = new List<Node>();
            //List<Node> nodoscalculables = new List<Node>();
            //List<SpecialComponentInfo> especialcomponents;
            Voltages     = new Dictionary <Complex32, Dictionary <string, Complex32> >();
            Currents     = new Dictionary <Complex32, Dictionary <string, Complex32> >();
            WfromIndexes = new Dictionary <Tuple <int, int>, Complex32>();
            SolveInfo solveinfo = new SolveInfo();

            PreAnalizeToSolve(cir, nodos, solveinfo);


            ComplexPlainAnalysis analis = ana as ComplexPlainAnalysis;
            double w, sig, wi, wf, deltaw, deltasig, sigmamin, sigmamax;

            wi       = analis.WMin;
            wf       = analis.WMax;
            sigmamax = analis.SigmaMax;
            sigmamin = analis.SigmaMin;
            w        = wi;
            sig      = sigmamin;
            deltaw   = (wf - wi) / analis.Points;
            deltasig = (sigmamax - sigmamin) / analis.Points;

            Complex32 W = Complex32.Zero;

            for (int i = 0; i <= analis.Points; i++)
            {
                for (int j = 0; j <= analis.Points; j++)
                {
                    //Calculo de tensiones de nodos
                    W = new Complex32((float)(sigmamin + j * deltasig), (float)(wi + i * deltaw));
                    ACSweepSolver.Calculate(solveinfo, W);

                    //          Node    Voltage
                    Dictionary <string, Complex32> result = new Dictionary <string, Complex32>();

                    #region almacenamiento temporal

                    foreach (var nodo in nodos)
                    {
                        result.Add(nodo.Name, nodo.Voltage);
                    }
                    if (!Voltages.ContainsKey(W))
                    {
                        Voltages.Add(W, result);
                        WfromIndexes.Add(new Tuple <int, int>(i, j), W);
                    }
                    else
                    {
                        throw new NotImplementedException();
                    }
                    // Results[i,j] = new Tuple<Complex32,Complex32>(W,

                    #endregion

                    //calculo las corrientes:
                    CalculateCurrents(cir, W);
                    Dictionary <string, Complex32> currents = new Dictionary <string, Complex32>();
                    StorageCurrents(cir, currents);
                    Currents.Add(W, currents);
                }
            }
            cir.State = Circuit.CircuitState.Solved;

            return(true);
        }
 private void AddCurren(ACSweepSolver sol5, string CurrentName)
 {
     foreach (var data in sol5.Currents)
     {
         foreach (var item in data.Value)
         {
             if (item.Key == CurrentName)
             {
                 Tuple<double, double> p = new Tuple<double, double>(data.Key, item.Value.Magnitude);
                 source1.Collection.Add(p);
                 p = new Tuple<double, double>(data.Key, 90 * item.Value.Phase / Math.PI);
                 source2.Collection.Add(p);
                 break;
             }
         }
     }
 }