/// <summary>
/// Generates a .csv file containing the factor information displayed in the grid.
/// The user can edit this file to more efficiently enable or disable factors in bulk.
/// </summary>
/// <param name="sender">Sender object.</param>
/// <param name="args">Event arguments.</param>
private void OnExportCsv(object sender, EventArgs args)
{
try
{
var path = explorerPresenter.MainPresenter.AskUserForSaveFileName("*.csv", null);
if (path != null)
{
// Clone the datatable and add an enabled column.
var data = view.List.DataSource.Copy();
data.Columns.Add("Enabled?", typeof(bool));
foreach (DataRow row in data.Rows)
{
var simulationName = row[0].ToString();
row["Enabled"] = !experiment.DisabledSimNames.Contains(simulationName);
}
// Convert datatable to csv and write to path.
using (var writer = new StreamWriter(path))
DataTableUtilities.DataTableToText(data, 0, ",", true, writer);
explorerPresenter.MainPresenter.ShowMessage(string.Format("Successfully generated {0}.", path), Simulation.MessageType.Information);
}
}
catch (Exception e)
{
explorerPresenter.MainPresenter.ShowError(e);
}
}
/// <summary>Convert a DataTable to a string.</summary>
public static string TableToString(DataTable data)
{
StringWriter writer = new StringWriter();
DataTableUtilities.DataTableToText(data, 0, ",", true, writer);
return(writer.ToString());
}
/// <summary>Create a text report from tables in this data store.</summary>
/// <param name="dataStore">The data store.</param>
/// <param name="fileName">Name of the file.</param>
private static void WriteAllTables(DataStore dataStore, string fileName)
{
// Write out each table for this simulation.
foreach (string tableName in dataStore.TableNames)
{
if (tableName != "Messages" && tableName != "InitialConditions")
{
DataTable firstRowOfTable = dataStore.RunQuery("SELECT * FROM " + tableName + " LIMIT 1");
if (firstRowOfTable != null)
{
string fieldNamesString = "";
for (int i = 1; i < firstRowOfTable.Columns.Count; i++)
{
if (i > 1)
{
fieldNamesString += ", ";
}
fieldNamesString += "[" + firstRowOfTable.Columns[i].ColumnName + "]";
}
string sql = String.Format("SELECT Name, {0} FROM Simulations, {1} " +
"WHERE Simulations.ID = {1}.SimulationID " +
"ORDER BY Name",
fieldNamesString, tableName);
DataTable data = dataStore.RunQuery(sql);
if (data != null && data.Rows.Count > 0)
{
StreamWriter report = new StreamWriter(Path.ChangeExtension(fileName, "." + tableName + ".csv"));
report.Write(DataTableUtilities.DataTableToText(data, 0, ",", true));
report.Close();
}
}
}
}
}
/// <summary>
/// Adds an older yield prophet job to the APSIM cloud.
/// </summary>
/// <param name="yieldProphet">The job specification.</param>
public void AddYP(string yieldProphetXML, DataTable weatherData, DataTable soilProbeData)
{
// Parse the PaddockXML.
XmlDocument doc = new XmlDocument();
doc.LoadXml(yieldProphetXML);
// Set the report type to indicate to the run machine to do a current growth stage.
//XmlHelper.SetValue(Doc.DocumentElement, "ReportType", "Current growth stage");
// Get the paddock node.
XmlNode PaddockNode = XmlUtilities.FindByType(doc.DocumentElement, "Paddock");
if (PaddockNode == null)
{
throw new Exception("Cannot find a <paddock> node in the PaddockXML");
}
// Get a temporary working folder.
string workingDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(workingDirectory);
// Save the xml to file so that we can attach it to the email.
string ypFileName = Path.Combine(workingDirectory, "YieldProphet.xml");
doc.Save(ypFileName);
// Write the weather file.
string weatherFileName = Path.Combine(workingDirectory, "observed.csv");
StreamWriter writer = new StreamWriter(weatherFileName);
DataTableUtilities.DataTableToText(weatherData, 0, ",", true, writer);
writer.Close();
// Write the soil probe file.
string soilProbeFileName = Path.Combine(workingDirectory, "soilprobe.csv");
writer = new StreamWriter(soilProbeFileName);
DataTableUtilities.DataTableToText(soilProbeData, 0, ",", true, writer);
writer.Close();
// Send email to run machine.
MailMessage mail = new MailMessage();
mail.Subject = "YieldProphet run";
mail.To.Add(new MailAddress("*****@*****.**"));
mail.From = new System.Net.Mail.MailAddress("*****@*****.**");
mail.IsBodyHtml = false;
mail.Attachments.Add(new Attachment(ypFileName));
mail.Attachments.Add(new Attachment(weatherFileName));
mail.Attachments.Add(new Attachment(soilProbeFileName));
SmtpClient smtp = new SmtpClient("smtp-relay.csiro.au");
smtp.Send(mail);
mail.Dispose();
// Clean up our directory.
Directory.Delete(workingDirectory, true);
}
/// <summary>Main run method for performing our post simulation calculations</summary>
public void Run()
{
// Note - we seem to be assuming that the predicted data table is called Report.
// If the predicted table has not been modified during the most recent simulations run, don't do anything.
if (dataStore?.Writer != null && !dataStore.Writer.TablesModified.Contains("Report"))
{
return;
}
string sql = "SELECT * FROM [Report]";
DataTable predictedData = dataStore.Reader.GetDataUsingSql(sql);
if (predictedData != null)
{
IndexedDataTable predictedDataIndexed = new IndexedDataTable(predictedData, null);
string outputNames = StringUtilities.Build(Outputs, ",", "\"", "\"");
string inputNames = StringUtilities.Build(Inputs, ",", "\"", "\"");
string anovaVariableValuesFileName = GetTempFileName("anovaVariableValues", ".csv");
// Write variables file
using (var writer = new StreamWriter(anovaVariableValuesFileName))
DataTableUtilities.DataTableToText(predictedDataIndexed.ToTable(), 0, ",", true, writer, excelFriendly: true);
string script = string.Format(
"inputs <- c({0})" + Environment.NewLine +
"inputs <- inputs[inputs != \"\"]" + Environment.NewLine +
"outputs <- c({1})" + Environment.NewLine +
"outputs <- outputs[outputs != \"\"]" + Environment.NewLine +
"factorial_data <- read.csv(\"{2}\")" + Environment.NewLine +
"indices <- data.frame(matrix(ncol = 4, nrow = 0))" + Environment.NewLine +
"colnames(indices) <- c(\"Input\", \"Output\", \"FirstOrder\", \"TotalOrder\")" + Environment.NewLine +
"for (output in outputs){{" + Environment.NewLine +
" data <- factorial_data[, names(factorial_data) %in% inputs | names(factorial_data) == output]" + Environment.NewLine +
" data[, names(data) %in% inputs] <- lapply(data[, names(data) %in% inputs], factor)" + Environment.NewLine +
" output_mean <- mean(data[[output]])" + Environment.NewLine +
" TSS <- sum((data[[output]] - output_mean)^2)" + Environment.NewLine +
" anova_model <- aov(data[[output]] ~ (.)^1000, data = data[, names(data) %in% inputs])" + Environment.NewLine +
" SSi <- summary(anova_model)[[1]][2]" + Environment.NewLine +
" variance_contributions <- SSi / TSS" + Environment.NewLine +
" parameter_names <- trimws(rownames(SSi), which = \"both\")" + Environment.NewLine +
" all_results <- data.frame(parameter_names, variance_contributions, row.names = NULL)" + Environment.NewLine +
" names(all_results) <- list(\"input\", \"% of variance\") " + Environment.NewLine +
" for (input in inputs){{" + Environment.NewLine +
" first <- all_results[all_results$input == input, colnames(all_results) == \"% of variance\"]" + Environment.NewLine +
" total <- sum(all_results[grepl(input, all_results$input), colnames(all_results) == \"% of variance\"])" + Environment.NewLine +
" result <- data.frame(Input=c(input), Output=c(output), FirstOrder=c(first), TotalOrder=c(total))" + Environment.NewLine +
" indices <- rbind(indices, result)" + Environment.NewLine +
" }}" + Environment.NewLine +
"}}" + Environment.NewLine +
"write.table(indices, sep=\",\", row.names=FALSE)" + Environment.NewLine
,
inputNames, outputNames, anovaVariableValuesFileName.Replace("\\", "/"));
DataTable results = RunR(script);
results.TableName = Name + "Statistics";
dataStore.Writer.WriteTable(results);
}
}
/// <summary>Create a text report from tables in this data store.</summary>
/// <param name="storage">The data store.</param>
/// <param name="fileName">Name of the file.</param>
public static void WriteAllTables(IStorageReader storage, string fileName)
{
// Write out each table for this simulation.
foreach (string tableName in storage.TableNames)
{
DataTable data = storage.GetData(tableName);
if (data != null && data.Rows.Count > 0)
{
StreamWriter report = new StreamWriter(Path.ChangeExtension(fileName, "." + tableName + ".csv"));
DataTableUtilities.DataTableToText(data, 0, ",", true, report);
report.Close();
}
}
}
/// <summary>
/// Write the specified table to the TextWriter.
/// </summary>
/// <param name="writer">The writer to write to</param>
/// <param name="table">The table to write</param>
/// <param name="html">Indicates whether html format should be produced</param>
/// <param name="includeHeadings">Include headings in the html table produced?</param>
/// <param name="className">The class name of the generated html table</param>
private static void WriteTable(TextWriter writer, DataTable table, bool html, bool includeHeadings, string className)
{
if (html)
{
bool showHeadings = className != "PropertyTable";
string line = DataTableUtilities.DataTableToText(table, 0, " ", showHeadings);
line = line.Replace("\r\n", "<br/>");
writer.WriteLine(line);
}
else
{
bool showHeadings = className != "PropertyTable";
string line = DataTableUtilities.DataTableToText(table, 0, " ", showHeadings);
writer.WriteLine(line);
}
}
protected void Page_Load(object sender, EventArgs e)
{
Response.Clear();
Response.AppendHeader("Content-Disposition", "attachment; filename=Registrations.csv");
Response.Buffer = false;
Response.ContentType = "text/plain";
SqlDataSource1.ConnectionString = System.IO.File.ReadAllText(@"D:\Websites\dbConnect.txt") + ";Database=APSIM.Registration";
System.Data.DataView dv = (DataView)SqlDataSource1.Select(new DataSourceSelectArguments());
DataTable Data = dv.ToTable();
StringWriter writer = new StringWriter();
DataTableUtilities.DataTableToText(Data, 1, ",", true, writer, excelFriendly: true);
Response.Write(writer.ToString());
Response.Flush(); // send our content to the client browser.
Response.SuppressContent = true; // stops .net from writing it's stuff.
}
/// <summary>
/// Calculate factors that we need to run. Put combinations into allCombinations
/// </summary>
private void CalculateFactors()
{
if (allCombinations.Count == 0)
{
if (ParameterValues == null || ParameterValues.Rows.Count == 0)
{
ParameterValues = RunRToGetParameterValues();
}
if (ParameterValues == null || ParameterValues.Rows.Count == 0)
{
throw new Exception("The morris function in R returned null");
}
if (ParameterValues.Rows.Count != NumPaths * (Parameters.Count + 1))
{
StringBuilder msg = new StringBuilder();
msg.AppendLine("Morris error: Number of parameter values from R is not equal to num paths * (N + 1).");
msg.AppendLine($"Number of parameters from R = {ParameterValues.Rows.Count}");
msg.AppendLine($"NumPaths={NumPaths}");
msg.AppendLine($"Parameters.Count={Parameters.Count}");
msg.AppendLine($"ParameterValues as returned from R:");
using (StringWriter writer = new StringWriter(msg))
DataTableUtilities.DataTableToText(ParameterValues, 0, ",", true, writer);
Console.WriteLine(msg.ToString());
}
int simulationNumber = 1;
foreach (DataRow parameterRow in ParameterValues.Rows)
{
var factors = new List <CompositeFactor>();
foreach (Parameter param in Parameters)
{
object value = Convert.ToDouble(parameterRow[param.Name], CultureInfo.InvariantCulture);
CompositeFactor f = new CompositeFactor(param.Name, param.Path, value);
factors.Add(f);
}
string newSimulationName = Name + "Simulation" + simulationNumber;
allCombinations.Add(factors);
simulationNumber++;
}
}
}
/// <summary>
/// Write the specified table to the TextWriter.
/// </summary>
/// <param name="writer">The writer to write to</param>
/// <param name="table">The table to write</param>
/// <param name="outtype">Indicates the format to be produced</param>
/// <param name="className">The class name of the generated html table</param>
/// <param name="document">Document object if using MigraDoc to generate output, null otherwise </param>
private static void WriteTable(TextWriter writer, DataTable table, OutputType outtype, string className, Document document)
{
bool showHeadings = className != "PropertyTable";
if (outtype == OutputType.html)
{
if (showHeadings)
{
writer.WriteLine("<table class='headered'>");
writer.Write("<tr>");
for (int i = 0; i < table.Columns.Count; i++)
{
writer.Write("<th");
if (i == 0)
{
writer.Write(" class='col1'");
}
writer.Write(">" + table.Columns[i].ColumnName + "</th>");
}
}
else
{
writer.WriteLine("<table>");
}
foreach (DataRow row in table.Rows)
{
bool titleRow = Convert.IsDBNull(row[0]);
if (titleRow)
{
writer.Write("<tr class='total'>");
}
else
{
writer.Write("<tr>");
}
for (int i = 0; i < table.Columns.Count; i++)
{
string st;
if (titleRow && i == 0)
{
st = "Total";
}
else
{
st = row[i].ToString();
}
writer.Write("<td");
if (i == 0)
{
writer.Write(" class='col1'");
}
writer.Write(">");
writer.Write(st);
writer.Write("</td>");
}
writer.WriteLine("</tr>");
}
writer.WriteLine("</table><br/>");
}
else if (outtype == OutputType.rtf)
{
MigraDoc.DocumentObjectModel.Tables.Table tabl = new MigraDoc.DocumentObjectModel.Tables.Table();
tabl.Borders.Width = 0.75;
foreach (DataColumn col in table.Columns)
{
Column column = tabl.AddColumn(Unit.FromCentimeter(18.0 / table.Columns.Count));
}
if (showHeadings)
{
MigraDoc.DocumentObjectModel.Tables.Row row = tabl.AddRow();
row.Shading.Color = Colors.PaleGoldenrod;
tabl.Shading.Color = new Color(245, 245, 255);
for (int i = 0; i < table.Columns.Count; i++)
{
Cell cell = row.Cells[i];
Paragraph paragraph = cell.AddParagraph();
if (i == 0)
{
paragraph.Format.Alignment = ParagraphAlignment.Left;
}
else
{
paragraph.Format.Alignment = ParagraphAlignment.Right;
}
paragraph.AddText(table.Columns[i].ColumnName);
}
}
foreach (DataRow row in table.Rows)
{
bool titleRow = Convert.IsDBNull(row[0]);
string st;
MigraDoc.DocumentObjectModel.Tables.Row newRow = tabl.AddRow();
for (int i = 0; i < table.Columns.Count; i++)
{
if (titleRow && i == 0)
{
st = "Total";
newRow.Format.Font.Color = Colors.DarkOrange;
newRow.Format.Font.Bold = true;
}
else
{
st = row[i].ToString();
}
Cell cell = newRow.Cells[i];
Paragraph paragraph = cell.AddParagraph();
if (!showHeadings)
{
cell.Borders.Style = BorderStyle.None;
paragraph.Format.Alignment = ParagraphAlignment.Left;
}
else if (i == 0)
{
paragraph.Format.Alignment = ParagraphAlignment.Left;
}
else
{
paragraph.Format.Alignment = ParagraphAlignment.Right;
}
if (showHeadings && i == 0)
{
paragraph.AddFormattedText(st, TextFormat.Bold);
}
else
{
paragraph.AddText(st);
}
}
}
document.LastSection.Add(tabl);
document.LastSection.AddParagraph(); // Just to give a bit of spacing
}
else
{
DataTableUtilities.DataTableToText(table, 0, " ", showHeadings, writer);
}
}
/// <summary>
/// Get a list of parameter values that we are to run. Call R to do this.
/// </summary>
private void RunRPostSimulation(DataTable predictedValues, out DataTable eeDataRaw, out DataTable statsDataRaw)
{
string morrisParametersFileName = GetTempFileName("parameters", ".csv");
string apsimVariableFileName = GetTempFileName("apsimvariable", ".csv");
string rFileName = GetTempFileName("morrisscript", ".r");
string eeFileName = GetTempFileName("ee", ".csv");
string statsFileName = GetTempFileName("stats", ".csv");
// write predicted values file
using (StreamWriter writer = new StreamWriter(apsimVariableFileName))
DataTableUtilities.DataTableToText(predictedValues, 0, ",", true, writer);
// Write parameters
using (StreamWriter writer = new StreamWriter(morrisParametersFileName))
DataTableUtilities.DataTableToText(ParameterValues, 0, ",", true, writer);
string paramNames = StringUtilities.Build(Parameters.Select(p => p.Name), ",", "\"", "\"");
string lowerBounds = StringUtilities.Build(Parameters.Select(p => p.LowerBound), ",");
string upperBounds = StringUtilities.Build(Parameters.Select(p => p.UpperBound), ",");
string script = GetMorrisRScript();
script += string.Format
("apsimMorris$X <- read.csv(\"{0}\")" + Environment.NewLine +
"values = read.csv(\"{1}\", check.names = F)" + Environment.NewLine +
"allEE <- data.frame()" + Environment.NewLine +
"allStats <- data.frame()" + Environment.NewLine +
"for (columnName in colnames(values))" + Environment.NewLine +
"{{" + Environment.NewLine +
" apsimMorris$y <- values[[columnName]]" + Environment.NewLine +
" tell(apsimMorris)" + Environment.NewLine +
" ee <- data.frame(apsimMorris$ee)" + Environment.NewLine +
" ee$variable <- columnName" + Environment.NewLine +
" ee$path <- c(1:{2})" + Environment.NewLine +
" allEE <- rbind(allEE, ee)" + Environment.NewLine +
" mu <- apply(apsimMorris$ee, 2, mean)" + Environment.NewLine +
" mustar <- apply(apsimMorris$ee, 2, function(x) mean(abs(x)))" + Environment.NewLine +
" sigma <- apply(apsimMorris$ee, 2, sd)" + Environment.NewLine +
" stats <- data.frame(mu, mustar, sigma)" + Environment.NewLine +
" stats$param <- params" + Environment.NewLine +
" stats$variable <- columnName" + Environment.NewLine +
" allStats <- rbind(allStats, stats)" + Environment.NewLine +
"}}" + Environment.NewLine +
"write.csv(allEE,\"{3}\", row.names=FALSE)" + Environment.NewLine +
"write.csv(allStats, \"{4}\", row.names=FALSE)" + Environment.NewLine,
morrisParametersFileName.Replace("\\", "/"),
apsimVariableFileName.Replace("\\", "/"),
NumPaths,
eeFileName.Replace("\\", "/"),
statsFileName.Replace("\\", "/"));
File.WriteAllText(rFileName, script);
// Run R
R r = new R();
r.RunToTable(rFileName);
eeDataRaw = ApsimTextFile.ToTable(eeFileName);
statsDataRaw = ApsimTextFile.ToTable(statsFileName);
}
/// <summary>
/// Calculate factors that we need to run. Put combinations into allCombinations
/// </summary>
private void CalculateFactors()
{
if (allCombinations.Count == 0)
{
if (ParameterValues == null || ParameterValues.Rows.Count == 0)
{
ParameterValues = RunRToGetParameterValues();
}
if (ParameterValues == null || ParameterValues.Rows.Count == 0)
{
throw new Exception("The morris function in R returned null");
}
int n = NumPaths * (Parameters.Count + 1);
// Sometimes R will return an incorrect number of parameter values, usually
// this happens when jump is too high. In this situation, we retry up to 10 times.
for (int numTries = 1; numTries < 10 && ParameterValues.Rows.Count != n; numTries++)
{
StringBuilder msg = new StringBuilder();
msg.AppendLine("Morris error: Number of parameter values from R is not equal to num paths * (N + 1).");
msg.AppendLine($"Number of parameters from R = {ParameterValues.Rows.Count}");
msg.AppendLine($"NumPaths={NumPaths}");
msg.AppendLine($"Parameters.Count={Parameters.Count}");
msg.AppendLine($"Trying again...");
Console.WriteLine(msg.ToString());
ParameterValues = RunRToGetParameterValues();
}
if (ParameterValues.Rows.Count != n)
{
// We've tried and failed 10 times to generate the right number of parameter values.
// Time to give up and throw a fatal.
StringBuilder msg = new StringBuilder();
msg.AppendLine("Morris error: Number of parameter values from R is not equal to num paths * (N + 1).");
msg.AppendLine($"Number of parameters from R = {ParameterValues.Rows.Count}");
msg.AppendLine($"NumPaths={NumPaths}");
msg.AppendLine($"Parameters.Count={Parameters.Count}");
msg.AppendLine($"ParameterValues as returned from R:");
using (StringWriter writer = new StringWriter(msg))
DataTableUtilities.DataTableToText(ParameterValues, 0, ",", true, writer);
throw new Exception(msg.ToString());
}
int simulationNumber = 1;
foreach (DataRow parameterRow in ParameterValues.Rows)
{
var factors = new List <CompositeFactor>();
foreach (Parameter param in Parameters)
{
object value = Convert.ToDouble(parameterRow[param.Name], CultureInfo.InvariantCulture);
CompositeFactor f = new CompositeFactor(param.Name, param.Path, value);
factors.Add(f);
}
string newSimulationName = Name + "Simulation" + simulationNumber;
allCombinations.Add(factors);
simulationNumber++;
}
}
}
/// <summary>Main run method for performing our calculations and storing data.</summary>
public void Run()
{
if (dataStore?.Writer != null && !dataStore.Writer.TablesModified.Contains("Report"))
{
return;
}
DataTable predictedData = dataStore.Reader.GetData("Report", filter: "SimulationName LIKE '" + Name + "%'", orderBy: "SimulationID");
if (predictedData != null)
{
IndexedDataTable variableValues = new IndexedDataTable(null);
// Determine how many years we have per simulation
DataView view = new DataView(predictedData);
view.RowFilter = "SimulationName='" + Name + "Simulation1'";
var Years = DataTableUtilities.GetColumnAsIntegers(view, "Clock.Today.Year");
// Create a results table.
IndexedDataTable results;
if (Years.Count() > 1)
{
results = new IndexedDataTable(new string[] { "Year" });
}
else
{
results = new IndexedDataTable(null);
}
// Loop through all years and perform analysis on each.
List <string> errorsFromR = new List <string>();
foreach (double year in Years)
{
view.RowFilter = "Clock.Today.Year=" + year;
foreach (DataColumn predictedColumn in predictedData.Columns)
{
if (predictedColumn.DataType == typeof(double))
{
var values = DataTableUtilities.GetColumnAsDoubles(view, predictedColumn.ColumnName);
if (values.Distinct().Count() > 1)
{
variableValues.SetValues(predictedColumn.ColumnName, values);
}
}
}
string paramNames = StringUtilities.Build(Parameters.Select(p => p.Name), ",", "\"", "\"");
string sobolx1FileName = GetTempFileName("sobolx1", ".csv");
string sobolx2FileName = GetTempFileName("sobolx2", ".csv");
string sobolVariableValuesFileName = GetTempFileName("sobolvariableValues", ".csv");
// Write variables file
using (var writer = new StreamWriter(sobolVariableValuesFileName))
DataTableUtilities.DataTableToText(variableValues.ToTable(), 0, ",", true, writer, excelFriendly: false, decimalFormatString: "F6");
// Write X1
using (var writer = new StreamWriter(sobolx1FileName))
DataTableUtilities.DataTableToText(X1, 0, ",", true, writer, excelFriendly: false, decimalFormatString: "F6");
// Write X2
using (var writer = new StreamWriter(sobolx2FileName))
DataTableUtilities.DataTableToText(X2, 0, ",", true, writer, excelFriendly: false, decimalFormatString: "F6");
string script = string.Format(
$".libPaths(c('{R.PackagesDirectory}', .libPaths()))" + Environment.NewLine +
$"library('boot', lib.loc = '{R.PackagesDirectory}')" + Environment.NewLine +
$"library('sensitivity', lib.loc = '{R.PackagesDirectory}')" + Environment.NewLine +
"params <- c({0})" + Environment.NewLine +
"n <- {1}" + Environment.NewLine +
"nparams <- {2}" + Environment.NewLine +
"X1 <- read.csv(\"{3}\")" + Environment.NewLine +
"X2 <- read.csv(\"{4}\")" + Environment.NewLine +
"sa <- sobolSalt(model = NULL, X1, X2, scheme=\"A\", nboot = 100)" + Environment.NewLine +
"variableValues = read.csv(\"{5}\")" + Environment.NewLine +
"for (columnName in colnames(variableValues))" + Environment.NewLine +
"{{" + Environment.NewLine +
" sa$y <- variableValues[[columnName]]" + Environment.NewLine +
" tell(sa)" + Environment.NewLine +
" sa$S$Parameter <- params" + Environment.NewLine +
" sa$T$Parameter <- params" + Environment.NewLine +
" sa$S$ColumnName <- columnName" + Environment.NewLine +
" sa$T$ColumnName <- columnName" + Environment.NewLine +
" sa$S$Indices <- \"FirstOrder\"" + Environment.NewLine +
" sa$T$Indices <- \"Total\"" + Environment.NewLine +
" if (!exists(\"allData\"))" + Environment.NewLine +
" allData <- rbind(sa$S, sa$T)" + Environment.NewLine +
" else" + Environment.NewLine +
" allData <- rbind(allData, sa$S, sa$T)" + Environment.NewLine +
"}}" + Environment.NewLine +
"write.table(allData, sep=\",\", row.names=FALSE)" + Environment.NewLine
,
paramNames, NumPaths, Parameters.Count,
sobolx1FileName.Replace("\\", "/"),
sobolx1FileName.Replace("\\", "/"),
sobolVariableValuesFileName.Replace("\\", "/"));
DataTable resultsForYear = null;
try
{
resultsForYear = RunR(script);
// Put output from R into results table.
if (Years.Count() > 1)
{
results.SetIndex(new object[] { year.ToString() });
}
foreach (DataColumn col in resultsForYear.Columns)
{
if (col.DataType == typeof(string))
{
results.SetValues(col.ColumnName, DataTableUtilities.GetColumnAsStrings(resultsForYear, col.ColumnName));
}
else
{
results.SetValues(col.ColumnName, DataTableUtilities.GetColumnAsDoubles(resultsForYear, col.ColumnName));
}
}
}
catch (Exception err)
{
string msg = err.Message;
if (Years.Count() > 1)
{
msg = "Year " + year + ": " + msg;
}
errorsFromR.Add(msg);
}
}
var resultsRawTable = results.ToTable();
resultsRawTable.TableName = Name + "Statistics";
dataStore.Writer.WriteTable(resultsRawTable);
if (errorsFromR.Count > 0)
{
string msg = StringUtilities.BuildString(errorsFromR.ToArray(), Environment.NewLine);
throw new Exception(msg);
}
}
}
/// <summary>
/// Write the specified table to the TextWriter.
/// </summary>
/// <param name="writer">The writer to write to</param>
/// <param name="table">The table to write</param>
/// <param name="html">Indicates whether html format should be produced</param>
/// <param name="includeHeadings">Include headings in the html table produced?</param>
/// <param name="className">The class name of the generated html table</param>
private static void WriteTable(TextWriter writer, DataTable table, bool html, bool includeHeadings, string className)
{
if (html)
{
if (className == string.Empty)
{
writer.WriteLine("<table>");
}
else
{
writer.WriteLine("<table class=\"" + className + "\">");
}
if (includeHeadings)
{
writer.Write("<tr>");
foreach (DataColumn col in table.Columns)
{
writer.Write("<th>");
writer.Write(col.ColumnName);
writer.Write("</th>");
}
writer.WriteLine("</tr>");
}
foreach (DataRow row in table.Rows)
{
bool titleRow = Convert.IsDBNull(row[0]);
if (titleRow)
{
writer.Write("<tr class=\"TitleRow\">");
}
else
{
writer.Write("<tr>");
}
foreach (DataColumn col in table.Columns)
{
string st = row[col].ToString();
if (titleRow && col.Ordinal == 0)
{
st = "Total";
}
if (className == "MessageTable")
{
if (col.Ordinal == 0)
{
writer.WriteLine("<td class=\"col1\">");
}
else
{
writer.WriteLine("<td class=\"col2\">");
}
}
else
{
writer.Write("<td>");
}
if (st.Contains("\n"))
{
st = st.Replace("\n", "<br/>");
}
if (st.Contains("WARNING:"))
{
st = "<p class=\"Warning\">" + st + "</p>";
}
else if (st.Contains("ERROR:"))
{
st = "<p class=\"Error\">" + st + "</p>";
}
// For property table, bold the value field.
if (className == "PropertyTable" && col.Ordinal == 1)
{
writer.Write("<b>" + st + "</b>");
}
else
{
writer.Write(st);
}
writer.Write("</td>");
}
writer.WriteLine("</tr>");
}
writer.WriteLine("</table>");
}
else
{
bool showHeadings = className != "PropertyTable";
writer.WriteLine(DataTableUtilities.DataTableToText(table, 0, " ", showHeadings));
}
}
/// <summary>Concatenates the specified output files into one file.</summary>
/// <param name="outFiles">The out files.</param>
private static void ConcatenateOutputFiles(string[] outFiles, string fileName, string outputFileType)
{
if (outFiles.Length > 0)
{
// Assume they are all structured the same i.e. same headings and units.
// Read in data from all files.
DataTable allData = null;
foreach (string outputFileName in outFiles)
{
DataTable data = null;
ApsimTextFile reader = new ApsimTextFile();
try
{
reader.Open(outputFileName);
List <string> constantsToAdd = new List <string>();
constantsToAdd.Add("Title");
data = reader.ToTable(constantsToAdd);
}
finally
{
reader.Close();
}
if (data != null && data.Columns.Count > 0 && data.Rows.Count > 0)
{
if (allData == null)
{
allData = data;
}
else
{
DataTableUtilities.CopyRows(data, allData);
}
}
}
if (allData != null)
{
// Move the title column to be first.
allData.Columns["Title"].SetOrdinal(0);
// Strip off the outputFileType (e.g. Yearly) from the titles.
foreach (DataRow row in allData.Rows)
{
row["Title"] = row["Title"].ToString().Replace(outputFileType, "");
}
// Write data.
string workingFolder = Path.GetDirectoryName(outFiles[0]);
string singleOutputFileName = Path.Combine(workingFolder, fileName);
using (StreamWriter outWriter = new StreamWriter(singleOutputFileName))
DataTableUtilities.DataTableToText(allData, 0, ", ", true, outWriter);
}
// Delete the .out files.
foreach (string outputFileName in outFiles)
{
File.Delete(outputFileName);
}
}
}
/// <summary>
/// Write the specified table to the TextWriter.
/// </summary>
/// <param name="writer">The writer to write to</param>
/// <param name="table">The table to write</param>
/// <param name="outtype">Indicates the format to be produced</param>
/// <param name="className">The class name of the generated html table</param>
private static void WriteTable(TextWriter writer, DataTable table, OutputType outtype, string className)
{
bool showHeadings = className != "PropertyTable";
if (outtype == OutputType.html)
{
if (showHeadings)
{
writer.WriteLine("<table class='headered'>");
writer.Write("<tr>");
for (int i = 0; i < table.Columns.Count; i++)
{
writer.Write("<th");
if (i == 0)
{
writer.Write(" class='col1'");
}
writer.Write(">" + table.Columns[i].ColumnName + "</th>");
}
writer.WriteLine();
}
else
{
writer.WriteLine("<table>");
}
foreach (DataRow row in table.Rows)
{
bool titleRow = Convert.IsDBNull(row[0]);
if (titleRow)
{
writer.Write("<tr class='total'>");
}
else
{
writer.Write("<tr>");
}
for (int i = 0; i < table.Columns.Count; i++)
{
string st;
if (titleRow && i == 0)
{
st = "Total";
}
else
{
st = row[i].ToString();
}
writer.Write("<td");
if (i == 0)
{
writer.Write(" class='col1'");
}
writer.Write(">");
writer.Write(st);
writer.Write("</td>");
}
writer.WriteLine("</tr>");
}
writer.WriteLine("</table><br/>");
}
else if (outtype == OutputType.Markdown)
{
writer.WriteLine(DataTableUtilities.ToMarkdown(table, true));
writer.WriteLine();
}
else
{
DataTableUtilities.DataTableToText(table, 0, " ", showHeadings, writer);
}
}