guiDrought_Model.java [src/java/m/cfa/drought] Revision: Date:
package m.cfa.drought;
import WaterData.WaterData;
import WaterData.WaterDataInterface;
import m.cfa.CircleDrawer;
import m.cfa.DoubleArray;
import m.cfa.DoubleMath;
import m.cfa.Graphing;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.annotations.XYAnnotation;
import org.jfree.chart.annotations.XYDrawableAnnotation;
import org.jfree.chart.annotations.XYPointerAnnotation;
import org.jfree.chart.annotations.XYTextAnnotation;
import org.jfree.chart.annotations.XYTitleAnnotation;
import org.jfree.chart.axis.DateAxis;
import org.jfree.chart.axis.DateTickMarkPosition;
import org.jfree.chart.axis.LogarithmicAxis;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.axis.NumberTickUnit;
import org.jfree.chart.axis.TickUnits;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.block.BlockBorder;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.StackedXYBarRenderer;
import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.chart.title.LegendTitle;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeTableXYDataset;
import org.jfree.data.time.Year;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.ui.RectangleAnchor;
import org.jfree.ui.RectangleEdge;
import org.jfree.ui.TextAnchor;
/**
* Last Updated: 9-April-2019
* @author Tyler Wible
* @since 10-July-2012
*/
public class guiDrought_Model {
//Inputs
String directory = "E:/Projects/TylerWible_repos/NetBeans/data/CFA/Drought";
String database = "USGS";//"CDWR";//"STORET";//"CDSN";//"UserData";//
String orgId = "n/a";//"n/a";//"21COL001";//"CITYFTCO_WQX";//"n/a";//
String stationId = "06752000";//"CLAGRECO";//"000028";//"1EFF";//"n/a";//
String stationName = "CACHE LA POUDRE RIV AT MO OF CN, NR FT COLLINS, CO";//"Cache La Poudre Near Greeley";//"BIG THOMPSON R NEAR MOUTH";//"n/a";//"n/a";//
String startDate = "";//"1900-01-01";//
String endDate = "";//"2002-01-01";//
String lambdaString = "optimize";//"1";//
String action = "all";//"optimizeModel";//"optimizeParameters";//"useParameters";//
String phiValues = "1";
String thetaValues = "";
double droughtLimit = -1;
boolean mergeDatasets = false;//true;//
String mergeMethod = "user";//"public";//"max";//"average";//"min";//
String userData = "";//"Date\tFlow\n1997-04-29\t8.3\n1998-05-09\t60.2\n1999-05-29\t20.1";
//Outputs
String len = "-1";
String start = "?";
String end = "?";
String dataSource = "?";
//Gets
public File getResult(){ return new File(directory, "drought_summary.txt"); }
public String getTimeseriesGraph(){ return "drought1_timeseries.jpg"; }
public String getColumnChart(){ return "drought2_column.jpg"; }
public String getFittedDataGraph(){ return "drought3_fitted.jpg"; }
public String getProjectedDataGraph(){ return "drought4_projected.jpg"; }
public String getDroughtRecurrenceGraph(){ return "drought5_recurrence.jpg"; }
public String getOptimizedModel_ARgraph(){ return "optimize_drought_graph1.jpg"; }
public String[] getOptimizedModel_ARMAgraphs(){
String[] graphs = {"optimize_drought_graph3.jpg", "optimize_drought_graph4.jpg"};
return graphs;
}
public File getTimeseriesOutput(){ return new File(directory, "drought1_timeseries.out"); }//for use with JSHighCharts
public File getColumnChartOutput(){ return new File(directory, "drought2_column.outt"); }//for use with JSHighCharts
public File getFittedGraphOutput(){ return new File(directory, "drought3_fitted.out"); }//for use with JSHighCharts
public File getProjectedGraphOutput(){ return new File(directory, "drought4_projected.out"); }//for use with JSHighCharts
public File getRecurrenceGraphOutput(){ return new File(directory, "drought5_recurrence.out"); }
public String getLen(){ return len; }
public String getStart(){ return start; }
public String getEnd(){ return end; }
public String getDataSource(){ return dataSource; }
public String getDroughtLimit(){ return String.valueOf(droughtLimit); }
//These 'gets' are to help decide which return function to perform
public String getAction(){ return action; }
public String getThetaValues(){ return thetaValues; }
//Sets
public void setDirectory(String directory_str){ directory = directory_str; }
public void setDatabase(String database_str){ database = database_str; }
public void setOrganizationID(String orgId_str){ orgId = orgId_str; }
public void setStationId(String stationId_str){ stationId = stationId_str; }
public void setStationName(String stationName_str){ stationName = stationName_str; }
public void setStartDate(String startDate_str){ startDate = startDate_str; }
public void setEndDate(String endDate_str){ endDate = endDate_str; }
public void setLambdaString(String lambdaString_str){ lambdaString = lambdaString_str; }
public void setAction(String action_str){ action = action_str; }
public void setPhiValues(String phiValues_str){ phiValues = phiValues_str; }
public void setThetaValues(String thetaValues_str){ thetaValues = thetaValues_str; }
public void setDroughtLimit(double droughtLimit_dbl){ droughtLimit = droughtLimit_dbl; }
public void setMergeDatasets(boolean mergeDatasets_TF){ mergeDatasets = mergeDatasets_TF; }
public void setMergeMethod(String mergeMethod_str){ mergeMethod = mergeMethod_str; }
public void setUserData(String userData_str){ userData = userData_str; }
/**
* Performs a drought analysis on the provided sortedData (daily average stream flow value) and calculates the long-term
* average water supply to be taken as the drought threshold. First it calculates total annual river flows based on the
* provided daily stream flow averages, then calculates the long-term average of these annual flow values, then calculates
* the properties of the droughts (deficit, duration, intensity) compared against the drought threshold. Finally graphs a
* timeseries of the annual flow data against the water demand.
* @param sortedData a string[][] containing daily average stream flow values in the following format: column1 = dates (yyyy-mm-dd format),
* column2 = daily average stream flow values (cfs)
* @return a String[] containing a tab-delimited summary of the droughts (water supply < water demand)
* @throws IOException
* @throws java.text.ParseException
*/
public String[] generalDroughtAnalysis(String[][] sortedData) throws IOException, ParseException{
//Calculate total annual flows
double[][] annualData = sumAnnualFlows(sortedData);
//Get the flow values and calculate the long-term (total) average of them
droughtLimit = DoubleMath.meanArithmetic(DoubleArray.getColumn(annualData, 1));
//Call built in function to perform the drough analysis and graph the resulting data
String[] droughtInfo = generalDroughtAnalysis(sortedData, droughtLimit);
return droughtInfo;
}
/**
* Performs a drought analysis on the provided sortedData (daily average stream flow value) and the provided long-term
* average water demand specified by the user. First it calculated total annual river flows based on the provided daily
* stream flow averages, then calculates the properties of the droughts (deficit, duration, intensity) compared against
* the water demand. Finally graphs a timeseries of the annual flow data against the water demand.
* @param sortedData a string[][] containing daily average stream flow values in the following format: column1 = dates (yyyy-mm-dd format),
* column2 = daily average stream flow values (cfs)
* @param droughtLimit a double representing the annual drought limit (water demand) on the watershed as specified by the user (in units of acre-ft/year)
* @return a String[] containing a tab-delimited summary of the droughts (water supply < water demand)
* @throws IOException
* @throws ParseException
*/
public String[] generalDroughtAnalysis(String[][] sortedData,
double droughtLimit) throws IOException, ParseException{
// //Test AR(p) model on sample data
// double[][] annualData = sumAnnualFlows(sortedData);
// Object[] returnArray = autoRegression.AR(p, annualData);
// annualData = (double[][]) returnArray[0];
// double[][] generatedData = (double[][]) returnArray[1];
// autoRegression.graphAR1Double(annualData, generatedData);
AutoRegression autoRegression = new AutoRegression();
//Calculate total annual flows
double[][] annualData = sumAnnualFlows(sortedData);
//Convert the data to only the stoicastic portion to modeled using AR(1) or ARMA(1,1)
double average = DoubleMath.meanArithmetic(DoubleArray.getColumn(annualData, 1));
double stDev = DoubleMath.StandardDeviationSample(DoubleArray.getColumn(annualData, 1));
double[][] stocaisticData = autoRegression.StoicasticConversion(annualData, average, stDev, true);
//Perform a transformation on the stoicastic data to change its distribution to a normal distribution
double lambda = 1.0;
if(lambdaString.equalsIgnoreCase("optimize")){
lambda = autoRegression.BoxCox(stocaisticData);
}else{
lambda = Double.parseDouble(lambdaString);
}
double[][] transformedData = autoRegression.BoxCox(lambda, stocaisticData, true);
// double[][] transformedData = autoRegression.SalasExampleTransformation(stocaisticData, true);
//Run the user specified auto-regressive model on the data
double[][] fittedData = null;
double[][] predictedData = null;
String methodType = "";
Object[] returnArray = autoRegression.AutoregressiveModel(directory, action, phiValues, thetaValues, transformedData);
if(action.equalsIgnoreCase("optimizeParameters")){
//Find the parameters of the regression only and report these back
String[] stringArray = (String[]) returnArray;
//Perform regression with data and graph the resulting data
Object[] dataArray = autoRegression.AutoregressiveModel(directory, "useParameters", stringArray[0], stringArray[1], transformedData);
//Keep the data from the regression and graph it
methodType = (String) dataArray[0];
transformedData = (double[][]) dataArray[1];
fittedData = (double[][]) dataArray[2];
predictedData = (double[][]) dataArray[3];
}else if(action.equalsIgnoreCase("optimizeModel")){
if(thetaValues.equalsIgnoreCase("")){
//Calculate optimal AR(p) model and return the optimal phi values
ArrayList<Double> aic = (ArrayList<Double>) returnArray[0];
ArrayList<Double> bic = (ArrayList<Double>) returnArray[1];
String phi = (String) returnArray[2];
String theta = (String) returnArray[3];
//Graph the AIC/BIC curve for the user
graphAR_AIC_BIC(aic, bic);
String[] optimalValues = {phi + "$$", theta};
return optimalValues;
}else{
//Calculate optimal ARMA(p,q) model and return the optimal phi/theta values
double[][] results = (double[][]) returnArray[0];
String phi = (String) returnArray[1];
String theta = (String) returnArray[2];
//Graph the AIC/BIC curve for the user
graphARMA_AIC_BIC("AIC", results, 3);
graphARMA_AIC_BIC("BIC" , results, 4);
String[] optimalValues = {phi + "$$", theta};
return optimalValues;
}
}else{
//Keep the data from the regression and graph it
methodType = (String) returnArray[0];
transformedData = (double[][]) returnArray[1];
fittedData = (double[][]) returnArray[2];
predictedData = (double[][]) returnArray[3];
}
//Un-transform the stoicastic historic and stoicastic generated data so as to graph real stream flow values
transformedData = autoRegression.BoxCox(lambda, transformedData, false);
fittedData = autoRegression.BoxCox(lambda, fittedData, false);
predictedData = autoRegression.BoxCox(lambda, predictedData, false);
// transformedData = autoRegression.SalasExampleTransformation(transformedData, false);
// fittedData = autoRegression.SalasExampleTransformation(fittedData, false);
// predictedData = autoRegression.SalasExampleTransformation(predictedData, false);
//Convert back from the stoicastic component of the data to the entire original data
double[][] originalData = autoRegression.StoicasticConversion(transformedData, average, stDev, false);
fittedData = autoRegression.StoicasticConversion(fittedData, average, stDev, false);
predictedData = autoRegression.StoicasticConversion(predictedData, average, stDev, false);
//Calculate the droughts, their accumulated deficits, durations, and intensities
DroughtProperties historicDroughtProps = new DroughtProperties(annualData, droughtLimit);
DroughtProperties predictedDroughtProps = new DroughtProperties(predictedData, droughtLimit);
//Determine the return periods for the droughts on record
double[][] historicDroughts = recurrenceInterval(historicDroughtProps, droughtLimit, annualData);
double[][] predictedDroughts = recurrenceInterval(predictedDroughtProps, droughtLimit, predictedData);
//Graph the drought data
graphTimeseries(annualData, droughtLimit); //graph1
graphNegativeBarChart(annualData, droughtLimit); //graph2
graphFittedData(originalData, fittedData, methodType); //graph3
graphPredictedData(originalData, predictedData, methodType);//graph4
graphReturnPeriod(historicDroughts, predictedDroughts); //graph5
//Populate the return array with the information gained from the drought analysis
String[] droughtInfo = new String[historicDroughtProps.numberOfDroughts() + 1];
droughtInfo[0] = "Deficit [acre-ft]\tLambda\tDuration [years]\tIntensity\tFinal Year";
for(int i=0; i<historicDroughtProps.numberOfDroughts(); i++){
droughtInfo[i+1] = String.valueOf(historicDroughtProps.getDeficit(i)) + "\t" +
String.valueOf(historicDroughtProps.getDeficit(i)/droughtLimit) + "\t" +
String.valueOf(historicDroughtProps.getDuration(i)) + "\t" +
String.valueOf(historicDroughtProps.getIntensity(i)) + "\t" +
String.valueOf(historicDroughtProps.getEndYear(i));
}
if(action.equalsIgnoreCase("optimizeParameters")){
//Return only the parameters of the regression
String[] stringArray = (String[]) returnArray;
stringArray[0] = stringArray[0] + "$$";
return stringArray;
}else if(action.equalsIgnoreCase("updateParameters")){
//Return only the parameters of the regression
String[] stringArray = {phiValues + "$$", thetaValues};
return stringArray;
}
return droughtInfo;
}
/**
* Calculates the average recurrence interval for each drought on record and the lambda coefficient of each drought (deficit = lambda * droughtLimit)
* @param currentDroughtProps the DroughtProperties class containing the droughts to be analyzed
* @param droughtLimit the value of the water demand in acre-ft to calculate lambda from (lambda = deficit/water demand)
* @param flowData the double[][] array containing the annual flow data with column1 = years, column2 = flow values in acre-ft
* @return a double[][] array containing: column1 = lambda sets of eleven lambda values {0. 0.5, 0.75, 1.0, 2.0}, column2 = average recurrence interval (return period), column3 = length of drought (from 1 to 11
*/
private double[][] recurrenceInterval(DroughtProperties currentDroughtProps, double droughtLimit, double[][] flowData){
double[] lambda = {0.0, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0};
ArrayList<Double> droughtLambda = new ArrayList<>();
ArrayList<Double> droughtRecurrence = new ArrayList<>();
ArrayList<Double> droughtLength = new ArrayList<>();
//Loop through lambda values
for(int i=0; i<lambda.length; i++){
//Loop drought year length
for(int j=1; j<11; j++){
ArrayList<Double> recurrence = new ArrayList<>();
int endYear = (int) flowData[0][0];
//Loop through droughts
for(int k=0; k<currentDroughtProps.numberOfDroughts(); k++){
//Compare the properties of the current drought to the provided
if(currentDroughtProps.getDeficit(k) > lambda[i]*droughtLimit && currentDroughtProps.getDuration(k) == j){
//Measure recurrence from start of drought to start of drought (Salas, 2005 pg 385)
recurrence.add((double) (currentDroughtProps.getEndYear(k) - endYear));
endYear = currentDroughtProps.getEndYear(k);
}
}
//There were observed droughts larger than this one, calculate the average recurrence interval
if(!recurrence.isEmpty()){
droughtLambda.add(lambda[i]);//lambda value
droughtRecurrence.add(DoubleMath.meanArithmetic(recurrence));//average recurrence = return period
droughtLength.add((double) j);//length of drought
}
}
}
//Return the drought properties in a single double[][]
double[][] newDroughts = new double[droughtLambda.size()][3];
for(int i=0; i<droughtLambda.size(); i++){
newDroughts[i][0] = droughtLambda.get(i);//lambda value
newDroughts[i][1] = droughtRecurrence.get(i);//average recurrence = return period
newDroughts[i][2] = droughtLength.get(i);//length of drought
}
return newDroughts;
}
/**
* Calculated the annual flow values given the average daily data provided. This sums the daily cfs values and
* converts it to acre-ft/day adding each day's worth of flow to the annual total
* @param sortedData a String[][] containing the flow data in the following format: column1 = dates (yyyy-mm-dd format),
* column2 = average daily streamflow values (cubic feet per second, cfs)
* @return
*/
private double[][] sumAnnualFlows(String[][] sortedData){
//Check for size issues and return early
if(sortedData.length<=1){
return new double[0][2];
}
//Get a unique list of years along with their accumulated flow values
ArrayList<String> uniqueYears = new ArrayList<>();
ArrayList<Double> uniqueFlows = new ArrayList<>();
ArrayList<Integer> uniqueDays = new ArrayList<>();
uniqueYears.add(sortedData[0][0].substring(0,4));
uniqueFlows.add((Double.parseDouble(sortedData[0][1])*24*3600)/43560);
uniqueDays.add(1);
int ctr = 0;
for(int i=1; i<sortedData.length; i++){
String previousYear = sortedData[i-1][0].substring(0,4);
String currentYear = sortedData[i][0].substring(0,4);
if(previousYear.equalsIgnoreCase(currentYear)){
//If the current year matches the previous year then add its flow value to the current total and continue
double currentFlowTotal = uniqueFlows.remove(ctr);
int currentNumberOfDays = uniqueDays.remove(ctr);
//convert daily cfs into acre-ft contributed by one day
//acre-ft = cfs * 1day * 24hr/1day * 3600sec/1hr * 1acre-ft/43560 ft^3
double currentFlow = (Double.parseDouble(sortedData[i][1])*24*3600)/43560;
uniqueFlows.add(ctr, currentFlowTotal + currentFlow);
uniqueDays.add(ctr, currentNumberOfDays + 1);
}else{
//If the current year does not match the previous year, then we are in a new year so add the year to the
//uniqueYear list and reset the annual flow total
uniqueYears.add(currentYear);
uniqueDays.add(1);
//convert daily cfs into acre-ft for one day
//acre-ft = cfs * 1day * 24hr/1day * 3600sec/1hr * 1acre-ft/43560 ft^3
double currentFlow = (Double.parseDouble(sortedData[i][1])*24*3600)/43560;
uniqueFlows.add(currentFlow);
ctr++;
}
}
System.out.println("Total Years: " + uniqueYears.size() + "\tTotal Flows: " + uniqueFlows.size());
// //Compute average flow/day for each year in acre-ft/day and then annualize this value for a total flow per year value
// //This average allows some years to have minimal data but still be used in the drought analysis
// for(int i=0; i<uniqueYears.size(); i++){
// int totalDays = uniqueDays.remove(i);
// if(totalDays < 365){
// //If less than a full year's worth of flows has been added, annualize each year's flow based on an average of the available data
// double totalFlow = uniqueFlows.remove(i);
// String year = uniqueYears.get(i);
// System.out.println(year + "\tOld flow: " + totalFlow + "acre-ft/day\t" + totalDays + " days");
//
// double averageFlowDay = totalFlow/totalDays;
// double annualFlow = averageFlowDay*365;
//
// uniqueFlows.add(i, annualFlow);
// uniqueDays.add(i, 365);
// System.out.println(year + "\tNew flow: " + annualFlow + "acre-ft/day\t365 days");
//
// }else{
// //If it is a full year of data, then don't change anything
// uniqueDays.add(i, totalDays);
// }
// }
double[][] uniqueData = new double[uniqueYears.size()][2];
for(int i=0; i<uniqueYears.size(); i++){
uniqueData[i][0] = Double.parseDouble(uniqueYears.get(i));//years
uniqueData[i][1] = uniqueFlows.get(i);//annual flow value
}
return uniqueData;
}
/**
* Graph the timeseries data and save the resulting graph to the specified location
* @param sortedData the String[][] containing sorted data for the timeseries (column 1 = dates (yyyy-mm-dd) column 2 = values)
* @param droughtLimit the calculated drought limit (if supply < drought limit then that year is a drought)
* @throws IOException
* @throws ParseException
*/
private void graphTimeseries(double[][] sortedData, double droughtLimit) throws IOException, ParseException{
//Round the long term average to fit the data better
double tempRounding = droughtLimit*1000;
tempRounding = Math.round(tempRounding)/1000;
//Create TimeSeries graph
TimeSeries series = new TimeSeries("Annual Flow Rate");
TimeSeries averageSeries = new TimeSeries("Drought Limit: " + String.valueOf(tempRounding) + " [acre-ft]");
String[][] graphData = new String[sortedData.length][3];
for(int i=0; i < sortedData.length; i++) {
int year_int = (int) sortedData[i][0];
if(year_int >= 1900){//artificial limit for JFreeCharts' "Day" class
Year year = new Year(year_int);
series.add(year, sortedData[i][1]);
averageSeries.add(year,droughtLimit);
}
graphData[i][0] = String.valueOf(year_int);
graphData[i][1] = String.valueOf(sortedData[i][1]);
graphData[i][2] = String.valueOf(droughtLimit);
}
//Save results for graphing with JSHighcharts
DoubleArray.writeTimeSeries(directory, graphData, "Yearly", getTimeseriesOutput().getName(), false);
//Graph data
XYPlot plotTime = new XYPlot();
plotTime = Graphing.addTimeseriesData(plotTime, series, true, Color.blue, false, false, false, true, 0);
plotTime = Graphing.addTimeseriesData(plotTime, averageSeries, true, Color.black, false, false, true, true, 1);
//Create Y axis
ValueAxis rangeTime = new NumberAxis("Annual Flow Rate [acre-ft]");
plotTime.setRangeAxis(0, rangeTime);
//Create X Axes
DateAxis domainTime = new DateAxis("Year");
domainTime.setLowerMargin(0.05);
domainTime.setUpperMargin(0.05);
plotTime.setDomainAxis(0, domainTime);
//Set extra plot preferences
plotTime = Graphing.setTimeAxisPreferences(plotTime);
//Create the chart with the plot and a legend
String graphTitle = "Annual Time Series for " + database + " Station: " + stationId + "; " + stationName;
JFreeChart chart = new JFreeChart(graphTitle, Graphing.titleFont, plotTime, true);
//Set legend Font
LegendTitle legendTitle = chart.getLegend();
legendTitle.setItemFont(Graphing.masterFont);
//Save resulting graph for use later
try{
String path = directory + File.separator + getTimeseriesGraph();
ChartUtilities.saveChartAsJPEG(new File(path), chart, 1280, 800);
System.out.println("Graph located at:\t" + path);
}catch(IOException e){
System.err.println("A problem occurred while trying to creating the chart.");
}
}
/**
* Graph the bar chart of the timeseries data where the values graphed ar those in sortedData and save the resulting graph to the specified location
* @param sortedData the String[][] containing sorted data for the timeseries (column 1 = dates (yyyy-mm-dd) column 2 = values)
* @param droughtLimit the calculated drought limit (if supply < drought limit then that year is a drought)
* @throws IOException
*/
private void graphNegativeBarChart(double[][] sortedData, double droughtLimit) throws IOException{
//Round the long term average to fit the data better
double tempRounding = droughtLimit*1000;
tempRounding = Math.round(tempRounding)/1000;
//Create TimeSeries graph
TimeTableXYDataset dataset = new TimeTableXYDataset();
boolean deficitFirst = false;
String[][] graphData = new String[sortedData.length][2];
for(int i=0; i < sortedData.length; i++) {
Year year = new Year((int) sortedData[i][0]);
if(sortedData[i][1] < droughtLimit){
dataset.add(year, sortedData[i][1] - droughtLimit, "Deficit");
if(i == 0){
//If the first year is a deficit mark it as true to get the colors for the graph right
deficitFirst = true;
}
}else{
dataset.add(year, sortedData[i][1] - droughtLimit, "Surplus");
}
graphData[i][0] = String.valueOf((int) sortedData[i][0]);
graphData[i][1] = String.valueOf(sortedData[i][1] - droughtLimit);
}
//Save results for graphing with JSHighcharts
DoubleArray.writeXYseries(directory, graphData, getColumnChartOutput().getName());
//Define axis and properties
NumberAxis numberaxis = new NumberAxis("Annual Deficit/Surplus of Drought Limit (" + tempRounding + " acre-ft)");
DateAxis dateaxis = new DateAxis("Year");
dateaxis.setTickMarkPosition(DateTickMarkPosition.MIDDLE);
dateaxis.setLowerMargin(0.01D);
dateaxis.setUpperMargin(0.01D);
//Define renderer properties for stacked graph
StackedXYBarRenderer stackedxybarrenderer = new StackedXYBarRenderer(0);
stackedxybarrenderer.setDrawBarOutline(false);
stackedxybarrenderer.setShadowVisible(false);
if(deficitFirst){
stackedxybarrenderer.setSeriesPaint(0, Color.red);
stackedxybarrenderer.setSeriesPaint(1, Color.blue);
}else{
stackedxybarrenderer.setSeriesPaint(0, Color.blue);
stackedxybarrenderer.setSeriesPaint(1, Color.red);
}
//Graph the dataset using the renderer and create a chart
XYPlot plot = new XYPlot(dataset, dateaxis, numberaxis, stackedxybarrenderer);
//Set extra plot preferences
plot = Graphing.setTimeAxisPreferences(plot);
//Create the chart with the plot
String graphTitle = "Annual Drought/Surplus for " + database + " Station: " + stationId + "; " + stationName;
JFreeChart chart = new JFreeChart(graphTitle, Graphing.titleFont, plot, false);
//Save resulting graph for use later
try{
String path = directory + File.separator + getColumnChart();
ChartUtilities.saveChartAsJPEG(new File(path), chart, 1280, 800);
System.out.println("Graph located at:\t" + path);
}catch(IOException e){
System.err.println("A problem occurred while trying to creating the chart.");
}
}
/**
* Graph the orignalData against the generatedData on a timeseries graph. Also graphs a scatter plot of the errors between the originalData and generatedData
* @param originalData double array of the original data. Column1 = years, column2 = annual flow values
* @param fittedData double array of the fitted data during the same time period as the original data. Column1 = years, column2 = annual flow values
* @param methodType the name of the method used to generate and project the data to be used in the legend of the graph
* @throws IOException
*/
private void graphFittedData(double[][] originalData,
double[][] fittedData,
String methodType) throws IOException{
//Convert graph x = original data, y = fitted data
XYSeries series1 = new XYSeries("Regression of Data");
String[][] graphData = new String[originalData.length][4];
double max = 0;
for(int i=0; i < originalData.length; i++) {
series1.add(originalData[i][1], fittedData[i][1]);
graphData[i][0] = "-1";
graphData[i][1] = "-1";
graphData[i][2] = String.valueOf(originalData[i][1]);
graphData[i][3] = String.valueOf(fittedData[i][1]);
if(Double.compare(originalData[i][1], max) > 0){
max = originalData[i][1];
}
if(Double.compare(fittedData[i][1], max) > 0){
max = fittedData[i][1];
}
}
//Save info to graph 1-to-1 line of perfect simulation
max = 1.02*max;
if(graphData.length > 1){
graphData[0][0] = "0";//x
graphData[0][1] = "0";//y
graphData[1][0] = String.valueOf(max);//x
graphData[1][1] = String.valueOf(max);//y
}
//Save results for graphing with JSHighcharts
DoubleArray.writeXYseries(directory, graphData, getFittedGraphOutput().getName());
//Add first series to graph
XYPlot plot = new XYPlot();
XYDataset dataset1 = new XYSeriesCollection(series1);
XYItemRenderer currentRenderer = new XYLineAndShapeRenderer(false, true);
currentRenderer.setSeriesPaint(0, Color.black);
plot.setDataset(0, dataset1);
plot.setRenderer(0, currentRenderer);
//Add line of slope 1 to graph
XYSeries series2 = new XYSeries("One to one line, Don't show in legend");
series2.add(0,0);
series2.add(max, max);
XYDataset dataset2 = new XYSeriesCollection(series2);
XYItemRenderer currentRenderer2 = new XYLineAndShapeRenderer(true, false);
currentRenderer2.setSeriesPaint(0, Color.lightGray);
plot.setDataset(1, dataset2);
plot.setRenderer(1, currentRenderer2);
//Create the X Axis
ValueAxis xAxis = new NumberAxis("Original Data [acre-ft/yr]");
xAxis.setRange(0, max);
xAxis.setVerticalTickLabels(true);
plot.setDomainAxis(0, xAxis);
//Create the Y Axis
ValueAxis yAxis = new NumberAxis(methodType + " Data [acre-ft/yr]");
yAxis.setRange(0, max);
plot.setRangeAxis(0, yAxis);
//Set extra plot preferences
plot = Graphing.setAxisPreferences(plot);
//Create the chart with the plot
String graphTitle = "Data Correlation for " + database + " Station: " + stationId + "; " + stationName;
JFreeChart chart = new JFreeChart(graphTitle, Graphing.titleFont, plot, false);
try{
String path = directory + File.separator + getFittedDataGraph();
ChartUtilities.saveChartAsJPEG(new File(path), chart, 1280, 800);
System.out.println("Graph located at:\t" + path);
}catch(IOException e){
System.err.println("A problem occurred while trying to creating the chart.");
}
}
/**
* Graph the orignalData against the future predictedData on a timeseries graph.
* @param originalData double array of the original data. Column1 = years, column2 = annual flow values
* @param predictedData double array of the future predicted data. Column1 = years, column2 = annual flow values
* @param methodType the name of the method used to generate and project the data to be used in the legend of the graph
* @throws IOException
* @throws ParseException
*/
private void graphPredictedData(double[][] originalData,
double[][] predictedData,
String methodType) throws IOException, ParseException{
//Convert series into Dates
XYSeries series1 = new XYSeries("Original Data");
XYSeries series2 = new XYSeries(methodType + " warm up period");
XYSeries series3 = new XYSeries(methodType + " Predicted Data");
String[][] graphData = new String[originalData.length][3];
for(int i=0; i < originalData.length; i++) {
series1.add(originalData[i][0], originalData[i][1]);
//Save results for graphing with JSHighcharts
graphData[i][0] = String.valueOf(originalData[i][0]);
graphData[i][1] = String.valueOf(originalData[i][1]);
graphData[i][2] = String.valueOf(predictedData[i][1]);
}
for(int i=0; i < predictedData.length; i++) {
if(i<100){
//Keep the warm up series
series2.add(predictedData[i][0], predictedData[i][1]);
}else{
//Keep the final dataseries
series3.add(predictedData[i][0], predictedData[i][1]);
}
}
//Save results for graphing with JSHighcharts
DoubleArray.writeTimeSeries(directory, graphData, "Yearly", getProjectedGraphOutput().getName(), false);
//Add first series to graph
XYPlot plot = new XYPlot();
XYDataset dataset1 = new XYSeriesCollection(series1);
XYItemRenderer currentRenderer = new XYLineAndShapeRenderer(true, false);
currentRenderer.setSeriesPaint(0, Color.black);
plot.setDataset(0, dataset1);
plot.setRenderer(0, currentRenderer);
//Add second series to graph
XYDataset dataset2 = new XYSeriesCollection(series2);
XYItemRenderer currentRenderer2 = new XYLineAndShapeRenderer(true, false);
currentRenderer2.setSeriesPaint(0, Color.gray);
plot.setDataset(1, dataset2);
plot.setRenderer(1, currentRenderer2);
//Add third series to graph
XYDataset dataset3 = new XYSeriesCollection(series3);
XYItemRenderer currentRenderer3 = new XYLineAndShapeRenderer(true, false);
currentRenderer3.setSeriesPaint(0, Color.red);
plot.setDataset(2, dataset3);
plot.setRenderer(2, currentRenderer3);
//Create the X Axis
NumberAxis xAxis = new NumberAxis("Year");
xAxis.setRange(originalData[0][0], predictedData[predictedData.length - 1][0]/35);
DecimalFormat formatter = new DecimalFormat("#0");
xAxis.setNumberFormatOverride(formatter);
plot.setDomainAxis(0, xAxis);
//Create the Y Axis
ValueAxis yAxis = new NumberAxis("Annual Discharge [acre-ft/yr]");
plot.setRangeAxis(0, yAxis);
//Set extra plot preferences
plot = Graphing.setAxisPreferences(plot);
//Create the chart with the plot
String graphTitle = "Projected Data for " + database + " Station: " + stationId + "; " + stationName;
JFreeChart chart = new JFreeChart(graphTitle, Graphing.titleFont, plot, true);
//Set legend Font
LegendTitle legendTitle = chart.getLegend();
legendTitle.setItemFont(Graphing.masterFont);
try{
String path = directory + File.separator + getProjectedDataGraph();
ChartUtilities.saveChartAsJPEG(new File(path), chart, 1280, 800);
System.out.println("Graph located at:\t" + path);
}catch(IOException e){
System.err.println("A problem occurred while trying to creating the chart.");
}
}
/**
* Graphs the drought length verses the return period for each lambda (drought deficit = lambda * droughtLimit) value on a scatter plot
* @param originalData double array of the original data. Column1 = years, column2 = annual flow values
* @param predictedData double array of the future predicted data. Column1 = years, column2 = annual flow values
* @throws IOException
*/
private void graphReturnPeriod(double[][] originalData,
double[][] predictedData) throws IOException{
//Create xy scatter plot
XYPlot plot = new XYPlot();
//Add fist series to graph
double[] lambda = {0.0};//, 0.5, 0.75, 1.0};
Color[] colorMatrix2 = {Color.black, Color.darkGray, Color.gray, Color.lightGray};
ArrayList<ArrayList<Double>> graphDataX = new ArrayList<>();
ArrayList<ArrayList<Double>> graphDataY = new ArrayList<>();
int ctr = 0;
for(int i=0; i<lambda.length; i++){
//Create and populate the lambda series
XYSeries series2 = new XYSeries("Original Data: Lambda = " + lambda[i]);
ArrayList<Double> temp_originalX = new ArrayList<>();
ArrayList<Double> temp_originalY = new ArrayList<>();
for(int j=0; j < originalData.length; j++){
if(Double.compare(originalData[j][0], lambda[i]) == 0){
series2.add(originalData[j][2], originalData[j][1]);
temp_originalX.add(originalData[j][2]);
temp_originalY.add(originalData[j][1]);
}
}
graphDataX.add(temp_originalX);
graphDataY.add(temp_originalY);
//Add the new series to the dataset
XYDataset dataset2 = new XYSeriesCollection(series2);
XYItemRenderer currentRenderer2 = new XYLineAndShapeRenderer(true, true);
currentRenderer2.setSeriesPaint(0, colorMatrix2[i]);
plot.setDataset(ctr, dataset2);
plot.setRenderer(ctr, currentRenderer2);
ctr++;
}
//Add second series to graph
double[] lambda2 = {0.0, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0};
Color[] colorMatrix1 = {new Color(105, 0, 255), Color.blue, Color.cyan, Color.green, new Color(255, 135, 0), new Color(255, 0, 50), new Color(255, 0, 255, 100)};
//Colors in the color matrix above are: purple, blue, cyan, green, gold, red, pink
for(int i=0; i<lambda2.length; i++){
//Create and populate the lambda series
XYSeries series2 = new XYSeries("Simmulated Data: Lambda = " + lambda2[i]);
ArrayList<Double> temp_predictedX = new ArrayList<>();
ArrayList<Double> temp_predictedY = new ArrayList<>();
for(int j=0; j < predictedData.length; j++){
if(Double.compare(predictedData[j][0], lambda2[i]) == 0){
series2.add(predictedData[j][2], predictedData[j][1]);
temp_predictedX.add(predictedData[j][2]);
temp_predictedY.add(predictedData[j][1]);
}
}
graphDataX.add(temp_predictedX);
graphDataY.add(temp_predictedY);
//Add the new series to the dataset
XYDataset dataset2 = new XYSeriesCollection(series2);
XYItemRenderer currentRenderer2 = new XYLineAndShapeRenderer(true, true);
currentRenderer2.setSeriesPaint(0, colorMatrix1[i]);
plot.setDataset(ctr, dataset2);
plot.setRenderer(ctr, currentRenderer2);
ctr++;
}
//Save results for graphing with JSHighcharts
int maxSize = 0;
for(int i=0; i<graphDataX.size(); i++){
int size = graphDataX.get(i).size();
if(size > maxSize){
maxSize = size;
}
}
String[][] graphData = new String[maxSize][16];//16 = 8 * 2 columns for both x and y points
ctr = 0;
for(int j=0; j<8; j++){
ArrayList<Double> currentX = graphDataX.get(j);
ArrayList<Double> currentY = graphDataY.get(j);
for(int i=0; i<maxSize; i++){
try{
graphData[i][ctr] = String.valueOf(currentX.get(i));
graphData[i][ctr + 1] = String.valueOf(currentY.get(i));
}catch(IndexOutOfBoundsException e){
graphData[i][ctr] = "-1";
graphData[i][ctr + 1] = "-1";
}
}
ctr++;//Increase by 1 to move from x column to y column
ctr++;//Increase by 1 to move from y column to new x column
}
DoubleArray.writeXYseries(directory, graphData, getRecurrenceGraphOutput().getName());
//Create the X Axis
ValueAxis xAxis = new NumberAxis("Drought Length [years]");
xAxis.setRange(0, 11);
TickUnits unit1 = new TickUnits();
unit1.add(new NumberTickUnit(1, NumberFormat.getNumberInstance()));
xAxis.setStandardTickUnits(unit1);
plot.setDomainAxis(0, xAxis);
//Create the Y Axis
LogarithmicAxis yAxis = new LogarithmicAxis("Recurrence Interval [years]");
yAxis.setAllowNegativesFlag(true);
try{
double maxValue = Math.log10(DoubleMath.max(DoubleArray.getColumn(predictedData, 1)));
if(Double.compare(maxValue, Double.NEGATIVE_INFINITY) != 0 &&
Double.compare(maxValue, Double.POSITIVE_INFINITY) != 0 ){
maxValue = Math.ceil(maxValue);
yAxis.setRange(1, Math.pow(10, maxValue));
}
}catch(ArrayIndexOutOfBoundsException e){
System.err.print("No predicted data lambda values\n");
}
plot.setRangeAxis(0, yAxis);
//Add equation explaining the term lambda
XYTextAnnotation equation = new XYTextAnnotation(" Lambda = Drought Deficit / Drought Limit ", 9, yAxis.getUpperBound()*0.5);
equation.setFont(Graphing.masterFont);
equation.setBackgroundPaint(Color.white);
equation.setOutlinePaint(Color.black);
equation.setOutlineVisible(true);
plot.addAnnotation(equation);
//Set extra plot preferences
plot = Graphing.setAxisPreferences(plot);
//Create the chart with the plot
String graphTitle = "Drought Recurrence Intervals for " + database + " Station: " + stationId + "; " + stationName;
JFreeChart chart = new JFreeChart(graphTitle, Graphing.titleFont, plot, true);
//Set legend Font
LegendTitle legendTitle = chart.getLegend();
legendTitle.setItemFont(Graphing.masterFont);
try{
String path = directory + File.separator + getDroughtRecurrenceGraph();
ChartUtilities.saveChartAsJPEG(new File(path), chart, 1280, 800);
System.out.println("Graph located at:\t" + path);
}catch(IOException e){
System.err.println("A problem occurred while trying to creating the chart.");
}
}
/**
* Graph the AR(p) AIC and BIC verses the p order of the AR(p) model
* @param aic an array list of aic values corresponding to p=1, 2, etc.
* @param bic an array list of bic values corresponding to p=1, 2, etc.
*/
private void graphAR_AIC_BIC(ArrayList<Double> aic, ArrayList<Double> bic){
//Graph AIC and BIC data vs. the p parameter of the AR(p) model
XYSeries series1 = new XYSeries("AIC");
XYSeries series2 = new XYSeries("BIC");
for(int i=0; i < aic.size(); i++) {
series1.add(i+1, aic.get(i));
series2.add(i+1, bic.get(i));
}
XYPlot plot = new XYPlot();
//Add first series to graph
XYDataset dataset1 = new XYSeriesCollection(series1);
XYItemRenderer currentRenderer = new XYLineAndShapeRenderer(true, true);
currentRenderer.setSeriesPaint(0, Color.black);
plot.setDataset(0, dataset1);
plot.setRenderer(0, currentRenderer);
//Add second series to graph
XYDataset dataset2 = new XYSeriesCollection(series2);
XYItemRenderer currentRenderer2 = new XYLineAndShapeRenderer(true, true);
currentRenderer2.setSeriesPaint(0, Color.cyan);
plot.setDataset(1, dataset2);
plot.setRenderer(1, currentRenderer2);
//Create the X Axis
ValueAxis xAxis = new NumberAxis("Number of Model Parameters");
TickUnits unit1 = new TickUnits();
unit1.add(new NumberTickUnit(1, NumberFormat.getNumberInstance()));
xAxis.setStandardTickUnits(unit1);
xAxis.setRange(0.01, aic.size() + 0.99);
plot.setDomainAxis(0, xAxis);
//Create the Y Axis
ValueAxis yAxis = new NumberAxis("AIC/BIC Value");
double max = DoubleMath.max(aic);
if(max < DoubleMath.max(bic)){
max = DoubleMath.max(bic);
}
double min = DoubleMath.min(aic);
if(min > DoubleMath.min(bic)){
min = DoubleMath.min(bic);
}
yAxis.setRange(0.98*min, 1.02*max);
plot.setRangeAxis(0, yAxis);
//Create the legend inside of the graph
LegendTitle lt = new LegendTitle(plot);
lt.setItemFont(new Font("Dialog", Font.PLAIN, 12));
lt.setBackgroundPaint(new Color(255, 255, 255, 255));
lt.setFrame(new BlockBorder(Color.black));
lt.setPosition(RectangleEdge.RIGHT);
lt.setPosition(RectangleEdge.LEFT);
XYTitleAnnotation ta = new XYTitleAnnotation(1, 1, lt, RectangleAnchor.TOP_RIGHT);
plot.addAnnotation(ta);
//Set extra plot preferences
Graphing.setAxisPreferences(plot);
//Create the chart with the plot
JFreeChart chart = new JFreeChart("AR(p) Parameter Optimization", Graphing.titleFont, plot, false);
try{
String path = directory + File.separator + getOptimizedModel_ARgraph();
ChartUtilities.saveChartAsJPEG(new File(path), chart, 1280, 800);
System.out.println("Graph located at:\t" + path);
}catch(IOException e){
System.err.println("A problem occurred while trying to creating the chart.");
}
}
/**
* Graph the ARMA(p,q) AIC or BIC values verses the total number of ARMA model parameters (p+q)
* @param method the name of the method either AIC or BIC
* @param results a double[][] containing the points to be plotted
* @param graphNumber the index of the graph either 3 (AIC) or 4 (BIC)
*/
private void graphARMA_AIC_BIC(String method, double[][] results, int graphNumber){
//Add each point of the aic/bic to the graph
XYPlot plot = new XYPlot();
XYSeries series1 = new XYSeries(method + " Points");
for(int i=0; i < results.length; i++){
series1.add(results[i][0] + results[i][1], results[i][graphNumber - 1]);
}
//Determine what the optimal values of AIC/BIC are for each p+q combination
XYSeries series2 = new XYSeries(method + " Optimal Front");
ArrayList<Double> aicBIC = new ArrayList<>();
ArrayList<Double> pValues = new ArrayList<>();
ArrayList<Double> qValues = new ArrayList<>();
for(int i=2; i<=8; i++){
//For each "value"=p+q find all of the p+q combinations which add to this
//"value" and retrieve their corresponding AIC/BIC value
ArrayList<Double> reArrangedData = new ArrayList<>();
for(int j=0; j<results.length; j++){
if(results[j][0] + results[j][1] == i){
reArrangedData.add(results[j][graphNumber - 1]);
}
}
double currentMinimum = DoubleMath.min(reArrangedData);
series2.add(i, currentMinimum);
for(int j=0; j<results.length; j++){
if(Double.compare(currentMinimum,results[j][graphNumber - 1]) == 0){
aicBIC.add(results[j][graphNumber - 1]);
pValues.add(results[j][0]);
qValues.add(results[j][1]);
}
}
}
//Add first series to graph
XYDataset dataset1 = new XYSeriesCollection(series1);
XYItemRenderer currentRenderer = new XYLineAndShapeRenderer(false, true);
currentRenderer.setSeriesPaint(0, Color.black);
plot.setDataset(0, dataset1);
plot.setRenderer(0, currentRenderer);
//Add second series to graph
XYDataset dataset2 = new XYSeriesCollection(series2);
XYItemRenderer currentRenderer2 = new XYLineAndShapeRenderer(true, false);
currentRenderer2.setSeriesStroke(0,
new BasicStroke(
1.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND,
1.0f, new float[] {6.0f, 6.0f}, 0.0f
));
currentRenderer2.setSeriesPaint(0, Color.blue);
plot.setDataset(1, dataset2);
plot.setRenderer(1, currentRenderer2);
//Add highlight to best AIC/BIC value (lowest)
XYSeries series3 = new XYSeries("Error");
double minAICbic = DoubleMath.min(aicBIC);
String p = "", q = "";
for(int i=0; i<aicBIC.size(); i++){
if(Double.compare(aicBIC.get(i), minAICbic) == 0){
p = String.valueOf(pValues.get(i));
q = String.valueOf(qValues.get(i));
series3.add(pValues.get(i) + qValues.get(i), minAICbic);
break;
}
}
//Create label for optimal ARMA model
p = p.substring(0,p.indexOf("."));
q = q.substring(0,q.indexOf("."));
XYDataset dataset3 = new XYSeriesCollection(series3);
XYItemRenderer currentRenderer3 = new XYLineAndShapeRenderer(false, true);
currentRenderer3.setSeriesPaint(0, Color.black);
currentRenderer3.setSeriesVisibleInLegend(0, false);
//Add an outline around the point
CircleDrawer cd = new CircleDrawer(Color.black, new BasicStroke(1.0f), null);
double x = series3.getX(0).doubleValue();
double y = series3.getY(0).doubleValue();
XYAnnotation bestBid = new XYDrawableAnnotation(x, y, 11, 11, cd);
plot.addAnnotation(bestBid);
//Add an arrow pointing to the point with the year of that flood
final XYPointerAnnotation pointer = new XYPointerAnnotation("Optimal ARMA Model: p= " + p + " q= " + q, x, y, Math.PI - 0.3);
pointer.setBaseRadius(30.0);
pointer.setTipRadius(10.0);
pointer.setFont(Graphing.masterFont);
pointer.setPaint(Color.black);
pointer.setBackgroundPaint(Color.white);
pointer.setOutlinePaint(Color.black);
pointer.setTextAnchor(TextAnchor.CENTER_RIGHT);
plot.addAnnotation(pointer);
//Put the line data, renderer, and axis into plot
plot.setDataset(3, dataset3);
plot.setRenderer(3, currentRenderer3);
//Create the X Axis
ValueAxis xAxis = new NumberAxis("Number of Model Parameters");
TickUnits unit1 = new TickUnits();
unit1.add(new NumberTickUnit(1, NumberFormat.getNumberInstance()));
xAxis.setStandardTickUnits(unit1);
xAxis.setRange(0.01, 8.99);
plot.setDomainAxis(0, xAxis);
//Create the Y Axis
ValueAxis yAxis = new NumberAxis(method + " Value");
double max = DoubleMath.max(DoubleArray.getColumn(results, graphNumber - 1));
double min = DoubleMath.min(DoubleArray.getColumn(results, graphNumber - 1));
yAxis.setRange(0.8*min, 1.02*max);
plot.setRangeAxis(0, yAxis);
//Set extra plot preferences
plot = Graphing.setAxisPreferences(plot);
//Create the chart with the plot
JFreeChart chart = new JFreeChart("ARMA(p, q) " + method + " Parameter Optimization", Graphing.titleFont, plot, false);
try{
String path = directory + File.separator + getOptimizedModel_ARMAgraphs()[graphNumber-3];
ChartUtilities.saveChartAsJPEG(new File(path), chart, 1280, 800);
System.out.println("Graph located at:\t" + path);
}catch(IOException e){
System.err.println("A problem occurred while trying to creating the chart.");
}
}
/**
* Writes out the dynamically created summary table to be displayed to the user along with the flood graph
* @param dynamicSummary string[] array to be written as each line of the text file
* @throws IOException
*/
public void writeSummary(String[] dynamicSummary) throws IOException{
//Intialize the file writer
String path = directory + File.separator + getResult().getName();
FileWriter writer = new FileWriter(path, false);
PrintWriter print_line = new PrintWriter(writer);
//Write the summary to the file
for(int i=0; i < dynamicSummary.length; i++) {
print_line.printf("%s" + "\r\n", dynamicSummary[i]);
}
print_line.close();
writer.close();
System.out.println("Text File located at:\t" + path);
}
/**
* Writes out the error message, if any, for finding the file and then exits the program
* @param error string array to be written as each line of an error message
* @throws IOException
*/
public void writeError(ArrayList<String> error) throws IOException{
//Output data to text file
String errorContents = error.get(0);
for(int i=1; i<error.size(); i++){
errorContents = errorContents + "\n" + error.get(i);
}
throw new IOException("Error encountered. Please see the following message for details: \n" + errorContents);
}
/**
* Main run method for drought model
* @param storetResourceFile python driver.py resource file for storet data extraction
* @throws IOException
* @throws InterruptedException
* @throws Exception
*/
public void run() throws IOException, InterruptedException, Exception {
//If no date input, make it the maximum of available data
if(startDate == null || startDate.equalsIgnoreCase("")){
startDate = "1850-01-01";
}
if(endDate == null || endDate.equalsIgnoreCase("")){
// Pull current date for upper limit of data search
DateFormat desiredDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date currentDate = new Date();
endDate = desiredDateFormat.format(currentDate);
}
//Check if any flow data exists
WaterDataInterface waterLib = WaterData.getNewWaterDataInterface(database, userData);
String[][] sortableData = waterLib.extractFlowData_formatted(directory, orgId, stationId, startDate, endDate);
dataSource = waterLib.getDataSourceCitation();
//If the user wants the datasets (public and user) merged then retrieve the second dataset (user)
String[][] sortableData_user = new String[0][0];
if(mergeDatasets){
WaterDataInterface waterLibUser = WaterData.getNewWaterDataInterface("UserData", userData);
sortableData_user = waterLibUser.extractFlowData_formatted(directory, orgId, stationId, startDate, endDate);
}
//Sort the Data by date to remove duplicate date entries
String[][] sortedData = DoubleArray.removeDuplicateDates(sortableData);
String[][] sortedData_user = DoubleArray.removeDuplicateDates(sortableData_user);
//Merge the two datasets (if user data is empty nothing will be merged)
String[][] sortedData_combined = DoubleArray.mergeData(sortedData, sortedData_user, mergeMethod);
if(sortedData_combined.length == 0){
ArrayList<String> errorMessage = new ArrayList<>();
if(sortedData.length == 0){
errorMessage.add("There is no available flow data in the " + database + " database for station '" + stationId + "' and the specified date range.");
if(database.equalsIgnoreCase("CDWR")){
errorMessage.add("The CDWR database is sensitive to the begin date used, try specifying a later begin date");
}
}
if(sortedData_user.length == 0){
errorMessage.add("There is no available uploaded data for station '" + stationId + "' and the specified date range");
}
writeError(errorMessage);
}
//Perform drought analysis
String[] droughtInfo = null;
if(Double.compare(droughtLimit, 0) < 0){
//If no drought limit is provided (aka -1 is provided) then calculate the drought limit = average(annual flows)
droughtInfo = generalDroughtAnalysis(sortedData_combined);
}else{
//If a drought limit is provided (aka greater than or equal to zero) then use this as the drought limit
droughtInfo = generalDroughtAnalysis(sortedData_combined, droughtLimit);
}
len = String.valueOf(sortedData_combined.length);
start = String.valueOf(sortedData_combined[0][0]);
end = String.valueOf(sortedData_combined[sortedData_combined.length - 1][0]);
writeSummary(droughtInfo);
}
public static void main(String[] args) throws IOException, InterruptedException, Exception {
//Run Model
guiDrought_Model drought_Model = new guiDrought_Model();
drought_Model.run();
}
}