oms3.dsl.cosu.SummaryWriter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of oms Show documentation
Show all versions of oms Show documentation
Object Modeling System (OMS) is a pure Java object-oriented framework.
OMS v3.+ is a highly interoperable and lightweight modeling framework for component-based model and simulation development on multiple platforms.
/*
* $Id: SummaryWriter.java df8149919ce8 2015-05-08 [email protected] $
*
* This file is part of the Object Modeling System (OMS),
* 2007-2012, Olaf David and others, Colorado State University.
*
* OMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 2.1.
*
* OMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with OMS. If not, see .
*/
package oms3.dsl.cosu;
import oms3.dsl.*;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import oms3.dsl.cosu.Step.Data;
import ngmf.util.cosu.luca.ParameterData;
public class SummaryWriter {
File summaryFile;
String summaryFileName = "luca_summary.txt";
String fpath;
PrintWriter w = null;
private boolean wroteStepHeader = false;
private boolean openedFile = false;
ArrayList iData = new ArrayList();
int inxt = 0;
public void setFile(String name) {
this.summaryFileName = name;
checkFile();
}
public void setModelInfo(int rounds, int steps, String modelName, List params, Date calibStart, Date runStart, Date runEnd, String outName) {
this.fpath = outName;
checkFile();
if (w != null) {
w.println("# Rounds = " + rounds);
w.println("# Steps = " + steps);
w.println();
w.println("Input Information");
w.println("\tModel Executable: " + modelName);
for (Params p : params) {
String f = p.getFile();
w.println("\tParameter File Name = " + f);
List param = p.getParam();
for (Param prm : param) {
w.println("\t" + prm.getName() + " = " + prm.getValue().toString());
}
}
w.println();
w.format("Model Run Period : \t%tB %td,%tY - %tB %td,%tY\n", runStart, runStart, runStart, runEnd, runEnd, runEnd);
w.format("Calibration Period: \t%tB %td,%tY - %tB %td,%tY\n", calibStart, calibStart, calibStart, runEnd, runEnd, runEnd);
w.println();
w.println("\nOutput Information");
w.println("\tOutput Folder: " + this.fpath);
w.println();
}
}
public void checkFile() {
if (openedFile == false) {
if ((summaryFileName != null) && (fpath != null)) {
String fileName = fpath + "/" + summaryFileName;
System.out.println("Writing summary file to " + fileName);
summaryFile = new File(fileName);
if (w == null) {
try {
w = new PrintWriter(summaryFile);
} catch (IOException E) {
throw new RuntimeException(E);
}
openedFile = true;
w.println("************************************************");
w.println("* Luca Calibration Summary *");
w.println("************************************************\n");
}
}
}
}
public void writeInitialStep(int s, Step step, Data stepData, double origOF) {
checkFile();
if (w != null) {
w.println("-------------------------------");
w.println("Initial Setup for Step " + step.getName());
w.println("-------------------------------");
// Show parameters used in step
ParameterData[] paramData = stepData.paramData;
for (int i = 0; i < paramData.length; i++) {
ParameterData paramInstance = paramData[i];
int calibType = paramInstance.getCalibrationType();
String calibName = Param.ConvertStrategy(calibType);
w.println("\n>>> Parameter Name: " + paramInstance.getName());
w.println();
w.println(" " + calibName + " was used for calibration.");
w.println(" Lower Bound = " + paramInstance.getOriginalLowerBound() + "\t\t Actual Lower Bound " + paramInstance.getLowerBound());
w.println(" Upper Bound = " + paramInstance.getOriginalUpperBound() + "\t\t Actual Upper Bound " + paramInstance.getUpperBound());
w.println();
w.println(" Parameter Values:");
w.println("\t#\tinit value\t\tcalibrated?");
double[] pdata = paramInstance.getDataValue();
for (int k = 0; k < pdata.length; k++) {
iData.add(pdata[k]);
}
boolean[] calibrated = paramInstance.getCalibrationFlag();
if (pdata.length < 2) {
calibrated[0] = true;
}
int count = 0;
double sum = 0;
for (int j = 0; j < pdata.length; j++) {
w.format("\t" + (j) + "\t%f" + "\t\t" + calibrated[j] + "\n", pdata[j]);
if (calibrated[j]) {
sum += pdata[j];
count++;
}
}
w.println("\tMean\t" + sum / count);
w.println("\tInitial Parameter OF\t" + origOF);
w.flush();
}
// Show SCE control info in step
w.println();
w.println(">>> SCE Control Parameter Information");
w.println("\tNumber of complexes in the initial population: " + step.getInitComplexes());
w.println("\tNumber of points in each complex: " + step.getPointsPerComplex());
w.println("\tNumber of points in a sub-complex: " + step.getPointsPerSubcomplex());
w.println("\tNumber of evolution steps before shuffling: " + step.getEvolutions());
w.println("\tMininum number of complexes required: " + step.getMinComplexes());
w.println("\tMaximum number of model executions: " + step.getMaxExec());
w.println("\tShuffling loops in which the objective function value must change by given % before optimization is terminated: " + step.shufflingLoops);
w.println("\tPercentage for the objective function value: " + step.getOfPercentage() + "%");
w.println();
w.println(">>> Objective Function (OF) Information");
int numOF = step.ofs.size();
w.println("\tThe number of objective functions: " + numOF);
// Go through each objective function for step.
int ocount = 1;
for (ObjFunc ofs : step.ofs) {
// Get weight- assumes even across multiple OF's if not already set.
double weight = ofs.getWeight();
if (Double.isNaN(weight)) {
weight = 1.0 / numOF;
}
w.println("\t-- OF #" + ocount + " with weight = " + weight);
String direction = "MINIMIZED";
if (ofs.of.positiveDirection()) {
direction = "MAXIMIZED";
}
w.println("\t\tThe objective function is: " + direction);
w.println("\t\tObjective Function Type: " + ofs.getMethod());
w.println("\t\tTime Step: " + ofs.getTimestep());
w.println("\t\tPeriod: " + ofs.getPeriodStartName(step.getStartMonth()) + " to " + ofs.getPeriodEndName(step.getStartMonth()));
w.println("\t\tSimulated Variable: " + ofs.getSimulated().getColumn());
w.println("\t\tObserved Variable: " + ofs.getObserved().getColumn());
if (ofs.getSubDivideString() != null) {
w.println("\t\tSubdivide info: \n\t\t\t" + ofs.getSubDivideString());
}
if (!ofs.getSubDivideValue().isEmpty()) {
w.print("\t\tSubdivide File Values: ");
for (Integer SD : ofs.getSubDivideValue()) {
w.print(" " + SD);
}
}
w.println();
w.println();
ocount++;
}
w.println();
w.flush();
}
}
public void writeStepHeader() {
checkFile();
if (wroteStepHeader == false) { // only write once.
if (w != null) {
w.println("********************************************");
w.println(" Calibrated Parameter Values");
w.println("********************************************");
}
}
wroteStepHeader = true;
}
public void writeStep(int r, int s, Step step, Data stepData, double finalOF, int numIterations) {
checkFile();
if (w != null) {
writeStepHeader();
w.println();
w.println();
w.println("-------------------------------");
w.println("Round " + (r + 1) + " Step " + step.getName());
w.println("-------------------------------\n");
w.println("Objective Function Values for round " + (r + 1) + " = " + finalOF);
ParameterData[] paramData = stepData.paramData;
for (int i = 0; i < paramData.length; i++) {
ParameterData paramInstance = paramData[i];
w.println(">>> Parameter Name: " + paramInstance.getName());
w.println();
w.println("Lower Bound = " + paramInstance.getOriginalLowerBound());
w.println("Upper Bound = " + paramInstance.getOriginalUpperBound());
w.println();
w.println("Number of iterations in Step = " + numIterations);
w.println("Parameter Values:");
// w.println("\t#\tinit value\t\tRound " + r + " data");
w.println("\t#\t\tRound " + r + " data");
double[] pdata = paramInstance.getDataValue();
boolean[] calibrated = paramInstance.getCalibrationFlag();
int calibrationCount = 0;
double sum = 0;
for (int j = 0; j < pdata.length; j++) {
// w.format("\t" + (j + 1) + "\t%f\t\t%f\n", iData.get(inxt), pdata[j]);
w.format("\t" + (j) + "\t\t%f\n", pdata[j]);
inxt++;
if (inxt >= iData.size()) {
inxt = 0;
}
if (calibrated[j]) {
sum += pdata[j];
calibrationCount++;
}
}
w.println("\tMean\t\t\t" + (sum / calibrationCount));
w.flush();
}
w.flush();
}
}
public void close() {
if (w != null) {
w.println("************************************************");
w.println("* DONE.");
w.println("************************************************\n");
w.close();
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy