Ejemplo n.º 1
0
        public async Task<ObservableCollection<DataSeriesInfo>> ProcessPressure(InputData inputData)
        {
            return await Task.Run(() =>
            {
                var result = new ObservableCollection<DataSeriesInfo>();
                var collection = new List<DataSeriesItem>();
                try
                {
                    for (var W = inputData.WStart; W < inputData.WEnd; W += inputData.H)
                    {
                        var epsilon = inputData.Delta/inputData.D;
                        var Re = W*inputData.D*inputData.Ro/inputData.Mu;
                        double lambda = 0;
                        if (Re < 2320)
                        {
                            lambda = 64/Re;

                        }
                        else
                        {
                            if (Re < 10/epsilon)
                            {
                                lambda = 0.316/Math.Pow(Re, 0.25);
                            }
                            else
                            {
                                if (Re < 560/epsilon)
                                {
                                    lambda = 0.11*Math.Pow(epsilon + 68/Re, 0.25);
                                }
                                else
                                {
                                    lambda = 0.11*Math.Pow(epsilon, 0.25);
                                }
                            }
                        }
                        var deltaP = lambda*inputData.L*Math.Pow(W, 2)*inputData.Ro/(2*inputData.D);
                        deltaP += 2*KsiB(inputData.D)*(Math.Pow(W, 2)/2)*inputData.Ro;
                        deltaP +=
                            inputData.Items.Select(t => A(t.Phi)*B(t.R/inputData.D))
                                .Select(PsiP => PsiP*(Math.Pow(W, 2)/2)*inputData.Ro)
                                .Sum();
                        for (var i = inputData.Items.Count; i < inputData.N; i++)
                        {
                            var PsiP = A(0)*B(0);
                            deltaP += PsiP*(Math.Pow(W, 2)/2)*inputData.Ro;
                        }
                        collection.Add(new DataSeriesItem { X = Math.Round(W, 2), Y = Math.Round(deltaP, 2) });
                    }
                }
                catch (DivideByZeroException)
                {

                }
                result.Add(new DataSeriesInfo {DataSeriesItems = collection, DataSeriesName = "Зависимость ΔP от W"});
                return result;
            });
        }
        private static string _currentlyOpenedFile = "Untitled.mml";                             // Открытый в данный момент файл

        /// <summary>
        /// Функция SaveFile(InputData inpDObj)
        /// 
        /// Сохраняет объект в файл. Введенные пользователем данные, сформированные в объект
        /// сохраняются в JSON формате
        /// </summary>
        /// <param name="inpDObj"></param>
        public async static Task SaveFile(InputData inpDObj)
        {
            if (inpDObj == null) return;                                                        // Если поступил null объект, выходим из функции
            if (_currentlyOpenedFile != "Untitled.mml")                                         // Если был открыт файл, перезаписываем в него
            {
                await OutputObjectToFile(inpDObj, _currentlyOpenedFile);                        // Выводим объект в этот файл
            }
            else                                                                                // Если нет, то
            {
                await SaveAsFile(inpDObj);                                                      // Действуем по аналогии с SaveAs
            }
        }
Ejemplo n.º 3
0
        public async Task<double> Process(InputData inputData)
        {
            return await Task.Run(() =>
            {
                var result = 0.0;
                try
                {
                    var W = 4 * inputData.Nu / (3600 * Math.PI * Math.Pow(inputData.D, 2));
                    var epsilon = inputData.Delta / inputData.D;
                    var Re = W*inputData.D*inputData.Ro/inputData.Mu;
                    double lambda = 0;
                    if (Re < 2320)
                    {
                        lambda = 64/Re;

                    }
                    else
                    {
                        if (Re<10/epsilon)
                        {
                            lambda = 0.316/Math.Pow(Re, 0.25);
                        }
                        else
                        {
                            if (Re < 560/epsilon)
                            {
                                lambda = 0.11*Math.Pow(epsilon + 68/Re, 0.25);
                            }
                            else
                            {
                                lambda = 0.11*Math.Pow(epsilon, 0.25);
                            }
                        }
                    }
                    var deltaP = lambda*inputData.L*Math.Pow(W, 2)*inputData.Ro/(2*inputData.D);
                    deltaP += 2*KsiB(inputData.D)*(Math.Pow(W, 2)/2)*inputData.Ro;
                    deltaP += inputData.Items.Select(t => A(t.Phi)*B(t.R/inputData.D)).Select(PsiP => PsiP*(Math.Pow(W, 2)/2)*inputData.Ro).Sum();
                    for (var i = inputData.Items.Count; i < inputData.N; i++)
                    {
                        var PsiP = A(0) * B(0);
                        deltaP += PsiP * (Math.Pow(W, 2) / 2) * inputData.Ro;
                    }
                    result = Math.Round(deltaP,2);
                }
                catch (DivideByZeroException)
                {
                    
                }

                return result;
            });
        }
 /// <summary>
 /// Функция SaveFile(InputData inpDObj)
 /// 
 /// Сохраняет объект в файл, предложив окно сохранения. Введенные пользователем данные, сформированные в объект
 /// сохраняются в JSON формате
 /// </summary>
 /// <param name="inpDObj"></param>
 public async static Task SaveAsFile(InputData inpDObj)
 {
     var sdg = new Microsoft.Win32.SaveFileDialog                                    // Создаем диалоговое окно сохранения 
     {
         FileName = "Document",                                                      // Имя файла по умолчанию
         DefaultExt = ".mml",                                                        // Расширение файла по умолчанию
         Filter = "MM Data (.mml)|*.mml"                                             // Фильтр расширений файла
     };
     var result = sdg.ShowDialog();                                                  // Открывает диалоговое окно сохранения
     if (result != true) return;                                                     // Обрабатываем результат выполнения диалогового окна сохранения
     var filename = sdg.FileName;                                                    // Получаем имя файла, введенное пользователем
     await OutputObjectToFile(inpDObj, filename);                                    // Записываем объект в файл
     _currentlyOpenedFile = filename;                                                // Сохраняем имя файла
 }
 /// <summary>
 /// Функция OutputObjectToFile(InputData inDObj, string filename)
 /// 
 /// Функция, выводящая объект в заданный файл
 /// </summary>
 /// <param name="inDObj"></param>
 /// <param name="filename"></param>
 private async static Task OutputObjectToFile(InputData inDObj, string filename)
 {
     if (File.Exists(filename)) File.Delete(filename);                         // Если файл существует, удаляем его
     var json = JsonConvert.SerializeObject(inDObj);                           // Сериализуем объект в строку JSON
     using (var swt = new StreamWriter(new FileStream(filename,                // Вывод в файл
         FileMode.OpenOrCreate, FileAccess.Write)))
     {
         await swt.WriteAsync(json);                                           // Записываем строку в файл
         swt.Close();                                                          // Закрываем поток записи
     }
 }