Пример #1
0
        /// <summary>
        /// Initialize new instance of UndiscoveredDepositsViewModel
        /// </summary>
        /// <param name="logger">Logging for the MapWizard.</param>
        /// <param name="dialogService">Service for using dialogs and notifications.</param>
        /// <param name="settingsService">Service for using and editing settings.</param>
        public UndiscoveredDepositsViewModel(ILogger logger, IDialogService dialogService, ISettingsService settingsService)
        {
            this.logger          = logger;
            this.dialogService   = dialogService;
            this.settingsService = settingsService;
            result = new UndiscoveredDepositsResultModel();
            TractChangedCommand        = new RelayCommand(TractChanged, CanRunTool);
            FindTractsCommand          = new RelayCommand(FindTractIDs, CanRunTool);
            RunToolCommand             = new RelayCommand(RunTool, CanRunTool);
            AddEstimationCommand       = new RelayCommand(AddEstimation, CanRunTool);
            AddCustomEstimationCommand = new RelayCommand(AddCustomEstimation, CanRunTool);
            SelectModelCommand         = new RelayCommand(SelectResult, CanRunTool);
            ShowModelDialog            = new RelayCommand(OpenModelDialog, CanRunTool);
            OpenUndiscDepPlotCommand   = new RelayCommand(OpenUndiscDepPlot, CanRunTool);
            viewModelLocator           = new ViewModelLocator();
            UndiscoveredDepositsInputParams inputParams = new UndiscoveredDepositsInputParams();
            string projectFolder = Path.Combine(settingsService.RootPath, "UndiscDep");

            if (!Directory.Exists(projectFolder))
            {
                Directory.CreateDirectory(projectFolder);
            }
            string param_json = Path.Combine(projectFolder, "undiscovered_deposits_input_params.json");

            if (File.Exists(param_json))
            {
                try
                {
                    inputParams.Load(param_json);
                    Model = new UndiscoveredDepositsModel
                    {
                        DepositsCsvString       = inputParams.DepositsNegativeCSV,
                        CustomFunctionCsvString = inputParams.DepositsCustomCSV,
                        EstN90        = inputParams.N90,
                        EstN50        = inputParams.N50,
                        EstN10        = inputParams.N10,
                        EstN5         = inputParams.N5,
                        EstN1         = inputParams.N1,
                        SelectedTract = inputParams.TractID,
                        NegBinomialExtensionFolder = "",
                        Mark3ExtensionFolder       = "",
                        CustomExtensionFolder      = "",
                        EstimateRationale          = inputParams.EstRationaleTXT,
                        MARK3EstimateRationale     = inputParams.Mark3EstRationaleTXT,
                        CustomEstimateRationale    = inputParams.CustomEstRationaleTXT,
                        LastRunTract = inputParams.LastRunTract
                    };
                }
                catch (Exception ex)
                {
                    Model = new UndiscoveredDepositsModel();
                    logger.Error(ex, "Failed to read json file");
                    dialogService.ShowNotification("Couldn't load Undiscovered Deposits tool's inputs correctly. Inputs were initialized to default values.", "Error");
                    viewModelLocator.SettingsViewModel.WriteLogText("Couldn't load Undiscovered Deposits tool's inputs correctly. Inputs were initialized to default values.", "Error");
                }
            }
            else
            {
                Model = new UndiscoveredDepositsModel();
            }
            FindTractIDs();
            LoadResults();
            try
            {
                if (Model.SelectedTract != null)
                {
                    projectFolder = Path.Combine(projectFolder, Model.SelectedTract);
                    if (Directory.Exists(projectFolder))
                    {
                        //  Find saved results from all the methods.
                        DirectoryInfo projectFolderInfo = null;
                        Model.ModelNames.Clear();
                        if (Directory.Exists(Path.Combine(projectFolder, "NegativeBinomial")))
                        {
                            projectFolderInfo = new DirectoryInfo(Path.Combine(projectFolder, "NegativeBinomial")); //NegativeBinomial results
                            FindModelnames(projectFolderInfo);
                        }
                        if (Directory.Exists(Path.Combine(projectFolder, "MARK3")))
                        {
                            projectFolderInfo = new DirectoryInfo(Path.Combine(projectFolder, "MARK3")); //MARK3 results
                            FindModelnames(projectFolderInfo);
                        }
                        if (Directory.Exists(Path.Combine(projectFolder, "Custom")))
                        {
                            projectFolderInfo = new DirectoryInfo(Path.Combine(projectFolder, "Custom")); //Custom results
                            FindModelnames(projectFolderInfo);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "Failed to load model names");
                dialogService.ShowNotification("Failed to load model names.", "Error");
                viewModelLocator.SettingsViewModel.WriteLogText("Failed to load model names correctly in Undiscovered Deposits tool.", "Error");
            }
            var lastRunFile = Path.Combine(settingsService.RootPath, "UndiscDep", "undiscovered_deposits_last_run.lastrun");

            if (File.Exists(lastRunFile))
            {
                Model.LastRunDate = "Last Run: " + (new FileInfo(lastRunFile)).LastWriteTime.ToString();
            }
        }
Пример #2
0
        /// <summary>
        /// Initialize new instance of ReportingViewModel class.
        /// </summary>
        /// <param name="logger">Logging for the MapWizard</param>
        /// <param name="dialogService">Service for using project's dialogs and notifications</param>
        /// <param name="settingsService">Service for using and editing project's settings</param>
        public ReportingViewModel(ILogger logger, IDialogService dialogService, ISettingsService settingsService)
        {
            this.logger                          = logger;
            this.dialogService                   = dialogService;
            this.settingsService                 = settingsService;
            viewModelLocator                     = new ViewModelLocator();
            RunToolCommand                       = new RelayCommand(RunTool, CanRunTool);
            GoToTractReportCommand               = new RelayCommand(GoToTractReport, CanChangeView);
            GoToReportSelectionCommand           = new RelayCommand(GoToReportSelection, CanChangeView);
            CheckTractFilesCommand               = new RelayCommand(CheckFiles, CanRunTool);
            FindTractsCommand                    = new RelayCommand(FindTractIDs, CanRunTool);
            SelectTractImageFileCommand          = new RelayCommand(SelectTractImageFile, CanRunTool);
            SelectKnownDepositsFileCommand       = new RelayCommand(SelectKnownDepositsFile, CanRunTool);
            SelectProspectsOccurencesFileCommand = new RelayCommand(SelectProspectsOccurencesFile, CanRunTool);
            SelectExplorationFileCommand         = new RelayCommand(SelectExplorationFile, CanRunTool);
            SelectSourcesFileCommand             = new RelayCommand(SelectSourcesFile, CanRunTool);
            SelectReferencesFileCommand          = new RelayCommand(SelectReferencesFile, CanRunTool);
            ReportingInputParams inputParams = new ReportingInputParams();
            string outputFolder = Path.Combine(settingsService.RootPath, "Reporting");

            if (!Directory.Exists(outputFolder))
            {
                Directory.CreateDirectory(outputFolder);
            }
            string param_json = Path.Combine(outputFolder, "tract_report_input_params.json");

            if (File.Exists(param_json))
            {
                try
                {
                    inputParams.Load(param_json);
                    Model = new ReportingModel
                    {
                        TractImageFile          = inputParams.TractImageFile,
                        KnownDepositsFile       = inputParams.KnownDepositsFile,
                        ProspectsOccurencesFile = inputParams.ProspectsOccurencesFile,
                        ExplorationFile         = inputParams.ExplorationFile,
                        SourcesFile             = inputParams.SourcesFile,
                        ReferencesFile          = inputParams.ReferencesFile,
                        SelectedTract           = inputParams.SelectedTract,
                        Authors         = inputParams.Authors,
                        Country         = inputParams.Country,
                        DescModelPath   = inputParams.DescModel,
                        DescModelName   = inputParams.DescModelName,
                        GTModelPath     = inputParams.GTModel,
                        GTModelName     = inputParams.GTModelName,
                        AddDescriptive  = Convert.ToBoolean(inputParams.AddDescriptive),
                        AddGradeTon     = Convert.ToBoolean(inputParams.AddGradeTon),
                        EnableDescCheck = Convert.ToBoolean(inputParams.EnableDescCheck),
                        EnableGTCheck   = Convert.ToBoolean(inputParams.EnableGTCheck),
                        AsDate          = inputParams.AsDate,
                        AsDepth         = inputParams.AsDepth,
                        AsLeader        = inputParams.AsLeader,
                        AsTeamMembers   = inputParams.AsTeamMembers,
                        IsRaefDone      = inputParams.IsRaefDone,
                        IsScreenerDone  = inputParams.IsScreenerDone,
                        IsUndiscDepDone = inputParams.IsUndiscDepDone
                    };
                    FindTractIDs();                  // Gets the tractID names from PermissiveTractTool's Tracts folder.
                    CheckFiles();                    // Check which of the needed files for creating a report exist.
                    if (Model.SelectedTract != null) // Check if the tool have ever been correctly ran before.
                    {
                        //Model.RunStatus = 0; Remove this?
                        string docOutputFile = Path.Combine(outputFolder, Model.SelectedTract, "TractReport" + Model.SelectedTract + ".docx");
                        if (File.Exists(docOutputFile))// If reporting file exist then the tool have been ran.
                        {
                            Model.RunStatus = 1;
                        }
                    }
                    SaveInputs();  // Save inputs to tract_report_input_params.json file. This might be not needed(?).
                }
                catch (Exception ex)
                {
                    // If something goes wrong then the tool will be initialized to have default parameters.
                    Model = new ReportingModel();
                    logger.Error(ex, "Failed to read json file");
                    dialogService.ShowNotification("Couldn't load Reporting tool's inputs correctly. Inputs were initialized to default values.", "Error");
                    viewModelLocator.SettingsViewModel.WriteLogText("Couldn't load Reporting tool's inputs correctly. Inputs were initialized to default values.", "Error");
                }
            }
            else
            {
                Model = new ReportingModel();
                FindTractIDs(); // Gets the tractID names from PermissiveTractTool's Trats folder.
            }
            // Check if the DepositType have been given correctly for the project.
            if (settingsService.Data.DepositType != null)
            {
                Model.DepositType = settingsService.Data.DepositType;
            }
            var lastRunFile = Path.Combine(settingsService.RootPath, "Reporting", "tract_report_last_run.lastrun");

            if (File.Exists(lastRunFile))
            {
                Model.LastRunDate = "Last Run: " + (new FileInfo(lastRunFile)).LastWriteTime.ToString();
            }
        }
 /// <summary>
 /// Initializes an instance of MonteCarloSimulationViewModel Class.
 /// </summary>
 /// <param name="logger">Logging for the MapWizard.</param>
 /// <param name="dialogService">Service for using dialogs and notifications.</param>
 /// <param name="settingsService">Service for using and editing settings.</param>
 public MonteCarloSimulationViewModel(ILogger logger, IDialogService dialogService, ISettingsService settingsService)
 {
     this.logger = logger;
     this.dialogService = dialogService;
     this.settingsService = settingsService;
     viewModelLocator = new ViewModelLocator();
     result = new MonteCarloSimulationResultModel();
     RunToolCommand = new RelayCommand(RunTool, CanRunTool);
     FindTractsCmd = new RelayCommand(FindTracts, CanRunTool);
     TractChangedCommand = new RelayCommand(TractChanged, CanRunTool);
     ShowModelDialog = new RelayCommand(OpenModelDialog, CanRunTool);
     SelectModelCommand = new RelayCommand(SelectResult, CanRunTool);
     SelectGradeObjectCommand = new RelayCommand(SelectGradeObject, CanRunTool);
     SelectTonnageObjectCommand = new RelayCommand(SelectTonnageObject, CanRunTool);
     SelectGradeTonnageObjectCommand = new RelayCommand(SelectGradeTonnageObject, CanRunTool);
     SelectNDepositsPmfObjectCommand = new RelayCommand(SelectNDepositsPmfObject, CanRunTool);
     OpenResultExcelObjectCommand = new RelayCommand(OpenResultExcelObject, CanRunTool);
     OpenTotalTonnagePlotCommand = new RelayCommand(OpenTotalTonnagePlot, CanRunTool);
     OpenMarginalPlotCommand = new RelayCommand(OpenMarginalPlot, CanRunTool);
     MonteCarloSimulationInputParams inputParams = new MonteCarloSimulationInputParams();
     string projectFolder = Path.Combine(settingsService.RootPath, "MCSim");
     if (!Directory.Exists(projectFolder))
     {
         Directory.CreateDirectory(projectFolder);
     }
     string param_json = Path.Combine(projectFolder, "monte_carlo_simulation_input_params.json");
     if (File.Exists(param_json))
     {
         try
         {
             inputParams.Load(param_json);
             Model = new MonteCarloSimulationModel
             {
                 GradePlot = inputParams.GradePlot,
                 TonnagePlot = inputParams.TonnagePlot,
                 NDepositsPmf = inputParams.NDepositsPmf,
                 SelectedTract = inputParams.TractID,
                 LastRunTract = "Tract: " + inputParams.LastRunTract
             };
             FindTractIDs();  // Gets the tractID names from PermissiveTractTool's Delineation folder.
             //FindMCSimTractIDs(); // Gets the tractID names from MCSim folder
         }
         catch (Exception ex)
         {
             Model = new MonteCarloSimulationModel();
             logger.Error(ex, "Failed to read json file");
             dialogService.ShowNotification("Couldn't load Monte Carlo Simulation tool's inputs correctly. Inputs were initialized to default values.", "Error");
             viewModelLocator.SettingsViewModel.WriteLogText("Couldn't load Monte Carlo Simulation tool's inputs correctly. Inputs were initialized to default values.", "Error");
         }
     }
     else
     {
         Model = new MonteCarloSimulationModel();
         FindTractIDs();  // Gets the tractID names from PermissiveTractTool's Delineation folder.
         //FindMCSimTractIDs(); // Gets the tractID names from MCSim folder
     }
     if (Model.SelectedTract != null)
     {
         LoadResults();
     }
     if (Model.SelectedTract != null)
     {
         projectFolder = Path.Combine(projectFolder, Model.SelectedTract);
         if (Directory.Exists(projectFolder))
         {
             Model.ModelNames.Clear();
             FindModelnames(projectFolder);  // Find saved results.
         }
     }
     var lastRunFile = Path.Combine(settingsService.RootPath, "MCSim", "monte_carlo_simulation_last_run.lastrun");
     if (File.Exists(lastRunFile))
     {
         Model.LastRunDate = "Last Run: " + (new FileInfo(lastRunFile)).LastWriteTime.ToString();
     }
 }
Пример #4
0
        /// <summary>
        /// Initializes a new instance of the GradeTonnageViewModel class.
        /// </summary>
        /// <param name="logger">Logging for the MapWizard.</param>
        /// <param name="dialogService">Service for using dialogs and notifications.</param>
        /// <param name="settingsService">Service for using and editing settings.</param>
        public GradeTonnageViewModel(ILogger logger, IDialogService dialogService, ISettingsService settingsService)
        {
            this.logger          = logger;
            this.dialogService   = dialogService;
            this.settingsService = settingsService;
            var GTFolder  = Path.Combine(settingsService.RootPath, "GTModel");
            var GTDirInfo = new DirectoryInfo(GTFolder);

            if (!Directory.Exists(GTFolder))
            {
                Directory.CreateDirectory(GTFolder);
            }
            RunToolCommand         = new RelayCommand(RunTool, CanRunTool);
            SelectFileCommand      = new RelayCommand(SelectFile, CanRunTool);
            SelectMetalFileCommand = new RelayCommand(SelectMetalFile, CanRunTool);
            SelectFolderCommand    = new RelayCommand(SelectFolder, CanRunTool);
            SelectModelCommand     = new RelayCommand(SelectResult, CanRunTool);
            ShowModelDialog        = new RelayCommand(OpenModelDialog, CanRunTool);
            OpenGradePlotCommand   = new RelayCommand(OpenGradePlot, CanRunTool);
            OpenTonnagePlotCommand = new RelayCommand(OpenTonnagePlot, CanRunTool);
            viewModelLocator       = new ViewModelLocator();
            result = new GradeTonnageResultModel();
            GradeTonnageInputParams inputParams = new GradeTonnageInputParams();
            string projectFolder         = Path.Combine(settingsService.RootPath, "GTModel");
            string selectedProjectFolder = Path.Combine(settingsService.RootPath, "GTModel", "SelectedResult");

            if (!Directory.Exists(selectedProjectFolder))
            {
                Directory.CreateDirectory(selectedProjectFolder);
            }
            string param_json = Path.Combine(selectedProjectFolder, "GradeTonnage_input_params.json");

            if (File.Exists(param_json))
            {
                try
                {
                    inputParams.Load(param_json);
                    Model = new GradeTonnageModel
                    {
                        CSVPath           = inputParams.CSVPath,
                        IsTruncated       = inputParams.IsTruncated,
                        PdfType           = inputParams.PDFType,
                        MinDepositCount   = Convert.ToInt32(inputParams.MinDepositCount),
                        RandomSampleCount = Convert.ToInt32(inputParams.RandomSampleCount),
                        Seed            = Convert.ToInt32(inputParams.Seed),
                        Folder          = inputParams.Folder,
                        ExtensionFolder = inputParams.ExtensionFolder,
                        RunGrade        = inputParams.RunGrade,
                        RunTonnage      = inputParams.RunTonnage,
                        ModelType       = inputParams.ModelType
                    };
                }
                catch (Exception ex)
                {
                    Model = new GradeTonnageModel();
                    logger.Error(ex, "Failed to read json file");
                    dialogService.ShowNotification("Couldn't load Grade Tonnage tool's inputs correctly.", "Error");
                    viewModelLocator.SettingsViewModel.WriteLogText("Couldn't load Grade Tonnage tool's inputs correctly.", "Error");
                }
            }
            else
            {
                Model = new GradeTonnageModel();
            }
            if (Directory.GetFiles(selectedProjectFolder).Length != 0)
            {
                LoadResults();
            }
            FindModelnames(projectFolder);
            var lastRunFile = Path.Combine(projectFolder, "GradeTonnage_last_run.lastrun");

            if (File.Exists(lastRunFile))
            {
                Model.LastRunDate = "Last Run: " + (new FileInfo(lastRunFile)).LastWriteTime.ToString();
            }
        }
Пример #5
0
        /// <summary>
        /// Initializes a new instance of the TractAggregationViewModel class.
        /// </summary>
        /// <param name="logger">Logging for the MapWizard.</param>
        /// <param name="dialogService">Service for using dialogs and notifications.</param>
        /// <param name="settingsService">Service for using and editing settings.</param>
        public TractAggregationViewModel(ILogger logger, IDialogService dialogService, ISettingsService settingsService)
        {
            this.logger          = logger;
            this.dialogService   = dialogService;
            this.settingsService = settingsService;
            viewModelLocator     = new ViewModelLocator();
            model  = new TractAggregationModel();
            result = new TractAggregationResultModel();
            SelectCorrelationMatrixCommand = new RelayCommand(SelectCorrelationMatrix, CanRunTool);
            SelectProbDistFileCommand      = new RelayCommand(SelectProbDistFile, CanRunTool);
            FindTractsCommand            = new RelayCommand(FindTractIDs, CanRunTool);
            RunToolCommand               = new RelayCommand(RunTool, CanRunTool);
            CombineDistFilesCommand      = new RelayCommand(CombineDistFiles, CanRunTool);
            AddFilesToCombineListCommand = new RelayCommand(AddFilesToCombineList, CanRunTool);
            CombineTractsCommand         = new RelayCommand(CombineTracts, CanRunTool);
            TractAggregationInputParams inputParams = new TractAggregationInputParams();
            string projectFolder = Path.Combine(settingsService.RootPath, "TractAggregation");

            if (!Directory.Exists(projectFolder))
            {
                Directory.CreateDirectory(projectFolder);
            }
            string param_json = Path.Combine(projectFolder, "tract_aggregation_input_params.json");

            if (File.Exists(param_json))
            {
                try
                {
                    inputParams.Load(param_json);
                    Model = new TractAggregationModel
                    {
                        CorrelationMatrix    = inputParams.CorrelationMatrix,
                        ProbDistFile         = inputParams.ProbDistFile,
                        WorkingDir           = inputParams.WorkingDir,
                        TestName             = inputParams.TestName,
                        CreateInputFile      = bool.Parse(inputParams.CreateInputFile),
                        TractCombinationName = inputParams.TractCombinationName
                    };
                }
                catch (Exception ex)
                {
                    Model = new TractAggregationModel();
                    logger.Error(ex, "Failed to read json file");
                    dialogService.ShowNotification("Couldn't load Tract Aggregation tool's inputs correctly. Inputs were initialized to default values.", "Error");
                    viewModelLocator.SettingsViewModel.WriteLogText("Couldn't load Tract Aggregation tool's inputs correctly. Inputs were initialized to default values.", "Error");
                }
            }
            else
            {
                Model = new TractAggregationModel();
            }
            FindTractIDs();
            if (Directory.Exists(Path.Combine(settingsService.RootPath, "TractAggregation", "AggResults")))
            {
                LoadResults();
            }
            var lastRunFile = Path.Combine(settingsService.RootPath, "TractAggregation", "tract_aggregation_last_run.lastrun");

            if (File.Exists(lastRunFile))
            {
                Model.LastRunDate = "Last Run: " + (new FileInfo(lastRunFile)).LastWriteTime.ToString();
            }
        }