/// <summary>
/// starter for real calcs
/// </summary>
public CalcStartParameterSet(
[NotNull] Func <bool, string, ObservableCollection <ResultFileEntry>, bool>
reportFinishFuncForHouseAndSettlement,
[NotNull] Func <bool, string, string, bool> reportFinishFuncForHousehold,
[NotNull] Func <object, bool> openTabFunc, [CanBeNull] ILPGDispatcher dispatcher,
[NotNull] GeographicLocation geographicLocation,
[NotNull] TemperatureProfile temperatureProfile,
[NotNull] ICalcObject calcTarget,
EnergyIntensityType energyIntensity, [NotNull] Func <bool> reportCancelFunc, bool resumeSettlement,
[CanBeNull] DeviceSelection deviceSelection, LoadTypePriority loadTypePriority,
[CanBeNull] TransportationDeviceSet transportationDeviceSet, [CanBeNull] TravelRouteSet travelRouteSet,
[NotNull] List <CalcOption> calcOptions,
DateTime officialSimulationStartTime,
DateTime officialSimulationEndTime,
TimeSpan internalTimeResolution,
[NotNull] string csvCharacter,
int selectedRandomSeed,
TimeSpan externalTimeResolution, bool deleteDatFiles, bool writeExcelColumn, bool showSettlingPeriod,
int settlingDays, int affordanceRepetitionCount, [NotNull] CalculationProfiler calculationProfiler,
[CanBeNull] ChargingStationSet chargingStationSet,
[CanBeNull][ItemNotNull] List <string> loadTypesToProcess,
DeviceProfileHeaderMode deviceProfileHeaderMode,
bool ignorePreviousActivitiesWhenNeeded, string resultPath, bool transportationEnabled)
{
IgnorePreviousActivitiesWhenNeeded = ignorePreviousActivitiesWhenNeeded;
ResultPath = resultPath;
LoadTypesToProcess = loadTypesToProcess;
ExternalTimeResolution = externalTimeResolution;
DeleteDatFiles = deleteDatFiles;
WriteExcelColumn = writeExcelColumn;
ShowSettlingPeriod = showSettlingPeriod;
SettlingDays = settlingDays;
AffordanceRepetitionCount = affordanceRepetitionCount;
CalculationProfiler = calculationProfiler;
SelectedRandomSeed = selectedRandomSeed;
OfficialSimulationStartTime = officialSimulationStartTime;
OfficialSimulationEndTime = officialSimulationEndTime;
InternalTimeResolution = internalTimeResolution;
CsvCharacter = csvCharacter;
ReportFinishFuncForHouseAndSettlement = reportFinishFuncForHouseAndSettlement;
ReportFinishFuncForHousehold = reportFinishFuncForHousehold;
OpenTabFunc = openTabFunc;
Dispatcher = dispatcher;
GeographicLocation = geographicLocation;
TemperatureProfile = temperatureProfile;
CalcTarget = calcTarget;
EnergyIntensity = energyIntensity;
ReportCancelFunc = reportCancelFunc;
ResumeSettlement = resumeSettlement;
LPGVersion = Utili.GetCurrentAssemblyVersion();
DeviceSelection = deviceSelection;
LoadTypePriority = loadTypePriority;
TransportationDeviceSet = transportationDeviceSet;
TravelRouteSet = travelRouteSet;
CalcOptions = calcOptions;
ChargingStationSet = chargingStationSet;
DeviceProfileHeaderMode = deviceProfileHeaderMode;
CalculationStartTime = DateTime.Now;
TransportationEnabled = transportationEnabled;
}
public void MakePlotTest()
{
CleanTestBase.RunAutomatically(false);
var start = DateTime.Now;
//ChartLocalizer.ShouldTranslate = true;
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(2, GlobalConsts.CSVCharacter, configSetter: x =>
{
x.Enable(CalcOption.TotalsPerDevice);
x.Enable(CalcOption.HouseholdContents);
});
var simend = DateTime.Now;
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var aeupp = new DeviceTaggingSet(ccps, fft, cp);
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var rfe = cs.GetRfeByFilename("DeviceTaggingSet.Electricity.General.csv");
aeupp.MakePlot(rfe);
Logger.Info("finished picture");
//OxyCalculationSetup.CopyImage(resultFileEntries[0].FullFileName);
Logger.Info("Simulation Time:" + (simend - start));
Logger.Info("Chart Time:" + (DateTime.Now - simend));
var imagefiles = FileFinder.GetRecursiveFiles(di, "DeviceTaggingSet.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public void MakePlotTest()
{
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(1, GlobalConsts.CSVCharacter,
LoadTypePriority.Mandatory,
configSetter: x => x.Enable(CalcOption.TimeOfUsePlot));
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
fft.ReadExistingFilesFromSql();
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var tou = new TimeOfUse(ccps, fft, cp);
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var rfe = cs.GetRfeByFilename("TimeOfUseProfiles.Electricity.csv");
tou.MakePlot(rfe);
//OxyCalculationSetup.CopyImage(resultFileEntries[0].FullFileName);
var imagefiles = FileFinder.GetRecursiveFiles(di, "TimeOfUseProfiles.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public void RunChartGeneratorTests()
{
Config.ReallyMakeAllFilesIncludingBothSums = true;
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(1, GlobalConsts.CSVCharacter,
configSetter: x =>
{
x.ApplyOptionDefault(OutputFileDefault.All);
x.Disable(CalcOption.MakeGraphics);
x.Disable(CalcOption.MakePDF);
});
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccp = new ChartCreationParameters(144, 2000, 1000, false, GlobalConsts.CSVCharacter,
new DirectoryInfo(cs.DstDir));
using (var fft = cs.GetFileTracker())
{
ChartGeneratorManager cgm = new ChartGeneratorManager(cp, fft, ccp);
Logger.Info("Making picture");
cgm.Run(cs.DstDir);
}
Logger.Info("finished picture");
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public void MainHouseholdPlanTest()
{
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(1, GlobalConsts.CSVCharacter,
configSetter: x =>
{
x.ApplyOptionDefault(OutputFileDefault.OnlyDeviceProfiles);
//x.Enable(CalcOption.MakeGraphics);
x.Enable(CalcOption.HouseholdPlan);
}
);
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var hp = new HouseholdPlan(ccps, fft, cp);
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var rfe = cs.GetRfeByFilename("HouseholdPlan.Times.CHR02 Couple Both working, over 30.HH1.csv");
hp.MakePlot(rfe);
Logger.Info("finished picture");
//OxyCalculationSetup.CopyImage(resultFileEntries[0].FullFileName);
var imagefiles = FileFinder.GetRecursiveFiles(di, "HouseholdPlan.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public void MakePlotTest()
{
CleanTestBase.RunAutomatically(false);
//ChartLocalizer.ShouldTranslate = true;
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(2, GlobalConsts.CSVCharacter,
configSetter: x => x.Enable(CalcOption.ActivationFrequencies));
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
fft.ReadExistingFilesFromSql();
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var aeupp = new AffordanceTaggingSet(ccps, fft, cp);
Logger.Debug("Making picture");
var di = new DirectoryInfo(cs.DstDir);
ResultFileEntry rfe = cs.GetRfeByFilename("AffordanceTaggingSet.Wo bleibt die Zeit.HH1.csv");
aeupp.MakePlot(rfe);
Logger.Debug("finished picture");
//OxyCalculationSetup.CopyImage(resultFileEntries[0].FullFileName);
var imagefiles = FileFinder.GetRecursiveFiles(di, "AffordanceTaggingSet.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
Logger.Warning("Open threads for database: " + Connection.ConnectionCount);
Command.PrintOpenConnections();
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public void MakePlotTest()
{
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(2, GlobalConsts.CSVCharacter, LoadTypePriority.Mandatory,
configSetter: x =>
{
x.CSVCharacter = ";";
x.ApplyOptionDefault(OutputFileDefault.NoFiles);
x.Enable(CalcOption.DeviceProfileExternalEntireHouse);
x.Enable(CalcOption.HouseholdContents);
x.ExternalTimeResolution = "01:00:00";
x.SelectedEnergyIntensity = EnergyIntensityType.EnergySavingPreferMeasured;
x.EndDateString = "31.01.2012";
}, energyIntensity: EnergyIntensityType.EnergySavingPreferMeasured);
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var aeupp = new DeviceProfilesExternal(ccps, fft, cp);
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var rfe = cs.GetRfeByFilename("DeviceProfiles_3600s.Electricity.csv");
aeupp.MakePlot(rfe);
Logger.Info("finished picture");
var imagefiles = FileFinder.GetRecursiveFiles(di, "DeviceProfiles*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public void MakePlotTest()
{
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(2, GlobalConsts.CSVCharacter, LoadTypePriority.Mandatory,
configSetter: x =>
{
x.Enable(CalcOption.DeviceProfilesIndividualHouseholds);
x.Enable(CalcOption.HouseholdContents);
x.SelectedEnergyIntensity = EnergyIntensityType.EnergySavingPreferMeasured;
x.EndDateDateTime = new DateTime(2012, 12, 31);
}, energyIntensity: EnergyIntensityType.EnergySavingPreferMeasured);
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
fft.ReadExistingFilesFromSql();
DeviceProfiles.DaysToMake = 365;
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var calcParameters = new CalcParameterLogger(cs.Wd.SqlResultLoggingService).Load();
var aeupp = new DeviceProfiles(ccps, fft, cp, cs.Wd.SqlResultLoggingService, calcParameters);
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var rfe = cs.GetRfeByFilename("DeviceProfiles.Electricity.csv");
aeupp.MakePlot(rfe);
Logger.Info("finished picture");
var imagefiles = FileFinder.GetRecursiveFiles(di, "DeviceProfiles.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public void MakePlotTest()
{
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(1, GlobalConsts.CSVCharacter,
configSetter: x => x.Enable(CalcOption.ActivationFrequencies));
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
fft.ReadExistingFilesFromSql();
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var afpm = new ActivityPercentage(ccps, fft, cp);
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var rfe = cs.GetRfeByFilename("ActivityPercentage.HH1.csv");
afpm.MakePlot(rfe);
Logger.Info("finished picture");
//OxyCalculationSetup.CopyImage(resultFileEntries[0].FullFileName);
var imagefiles = FileFinder.GetRecursiveFiles(di, "ActivityPercentage.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(2);
}
Logger.Warning("Leftover connections: " + Connection.ConnectionCount);
cs.CleanUp();
//CleanTestBase.Run(true);
}
public void RunTest()
{
var cdfc = new CalculationDurationFlameChart();
var cp = CalculationProfiler.Read(@"C:\work\CalculationBenchmarks.ActionCarpetPlotTest\");
cdfc.Run(cp, @"e:\", "FlameChartTest");
}
public void MakePlotTestForHouse()
{
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(1, GlobalConsts.CSVCharacter,
LoadTypePriority.RecommendedForHouses,
configSetter: x =>
{
x.Enable(CalcOption.DeviceProfileExternalEntireHouse);
x.ExternalTimeResolution = "00:30:00";
x.CSVCharacter = ";";
}, useHouse: true);
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var aeupp = new DeviceProfilesExternal(ccps, fft, cp);
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var rfe = cs.GetRfeByFilename("DeviceProfiles_1800s.Electricity.csv");
aeupp.MakePlot(rfe);
Logger.Info("finished picture");
var imagefiles = FileFinder.GetRecursiveFiles(di, "DeviceProfiles*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
private static void RunTest([NotNull] Action <GeneralConfig> setOption, [NotNull] string name)
{
CleanTestBase.RunAutomatically(false);
using (var wd1 = new WorkingDir(Utili.GetCurrentMethodAndClass() + name))
{
Logger.Threshold = Severity.Error;
var path = wd1.WorkingDirectory;
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var sim = new Simulator(db.ConnectionString);
Config.IsInUnitTesting = true;
Config.ExtraUnitTestChecking = false;
sim.MyGeneralConfig.ApplyOptionDefault(OutputFileDefault.NoFiles);
sim.MyGeneralConfig.WriteExcelColumn = "False";
//if (setOption == null) { throw new LPGException("Action was null."); }
setOption(sim.MyGeneralConfig);
Logger.Info("Temperature:" + sim.MyGeneralConfig.SelectedTemperatureProfile);
Logger.Info("Geographic:" + sim.MyGeneralConfig.GeographicLocation);
sim.Should().NotBeNull();
var cmf = new CalcManagerFactory();
CalculationProfiler calculationProfiler = new CalculationProfiler();
CalcStartParameterSet csps = new CalcStartParameterSet(sim.GeographicLocations[0],
sim.TemperatureProfiles[0], sim.ModularHouseholds[0], EnergyIntensityType.Random,
false, null, LoadTypePriority.All, null, null, null,
sim.MyGeneralConfig.AllEnabledOptions(), new DateTime(2018, 1, 1), new DateTime(2018, 1, 2), new TimeSpan(0, 1, 0),
";", 5, new TimeSpan(0, 10, 0), false, false, false, 3, 3,
calculationProfiler, wd1.WorkingDirectory, false);
var cm = cmf.GetCalcManager(sim, csps, false);
public static void MakeChartsAndPDF(CalculationProfiler calculationProfiler, string resultPath)
{
Exception innerException = null;
var t = new Thread(() => {
try
{
SqlResultLoggingService srls = new SqlResultLoggingService(resultPath);
CalcParameterLogger cpl = new CalcParameterLogger(srls);
InputDataLogger idl = new InputDataLogger(Array.Empty <IDataSaverBase>());
var calcParameters = cpl.Load();
Logger.Info("Checking for charting parameters");
if (!calcParameters.IsSet(CalcOption.MakePDF) && !calcParameters.IsSet(CalcOption.MakeGraphics))
{
Logger.Info("No charts wanted");
return;
}
calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass() + " - Charting");
using (FileFactoryAndTracker fileFactoryAndTracker =
new FileFactoryAndTracker(resultPath, "Name", idl)) {
calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass() + " - Chart Generator RunAll");
ChartCreationParameters ccp = new ChartCreationParameters(144, 1600, 1000,
false, calcParameters.CSVCharacter, new DirectoryInfo(resultPath));
var cg = new ChartGeneratorManager(calculationProfiler, fileFactoryAndTracker, ccp);
cg.Run(resultPath);
calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass() + " - Chart Generator RunAll");
if (calcParameters.IsSet(CalcOption.MakePDF))
{
calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass() + " - PDF Creation");
Logger.ImportantInfo(
"Creating the PDF. This will take a really long time without any progress report...");
MigraPDFCreator mpc = new MigraPDFCreator(calculationProfiler);
mpc.MakeDocument(resultPath, "", false, false,
calcParameters.CSVCharacter, fileFactoryAndTracker);
calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass() + " - PDF Creation");
}
}
Logger.Info("Finished making the charts");
calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass() + " - Charting");
CalculationDurationFlameChart cdfc = new CalculationDurationFlameChart();
cdfc.Run(calculationProfiler, resultPath, "CalcManager");
}
catch (Exception ex)
{
innerException = ex;
Logger.Exception(ex);
}
});
t.SetApartmentState(ApartmentState.STA);
t.Start();
t.Join();
if (innerException != null)
{
Logger.Error("Exception during the PDF creation!");
Logger.Exception(innerException);
throw innerException;
}
}
public void MakePlotTest()
{
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(1, GlobalConsts.CSVCharacter,
configSetter: x => x.Enable(CalcOption.LocationsFile));
//cs.Wd.InputDataLogger.AddSaver(new HouseholdKeyLogger(cs.Wd.SqlResultLoggingService));
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
fft.ReadExistingFilesFromSql();
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var files = FileFinder.GetRecursiveFiles(di, "LocationStatistics.HH1.csv");
files.Count.Should().BeGreaterOrEqualTo(1);
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var locationStatistics = new LocationStatistics(ccps, fft, cp);
var rfe = cs.GetRfeByFilename("LocationStatistics.HH1.csv");
locationStatistics.MakePlot(rfe);
Logger.Info("finished picture");
// OxyCalculationSetup.CopyImage(resultFileEntries[0].FullFileName);
var imagefiles = FileFinder.GetRecursiveFiles(di, "LocationStatistics.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public CalcRepo(
[CanBeNull] IOnlineDeviceActivationProcessor odap = null,
[CanBeNull] Random rnd = null,
[CanBeNull] CalcParameters calcParameters = null,
[CanBeNull] IOnlineLoggingData onlineLoggingData = null,
[CanBeNull] NormalRandom normalRandom = null,
[CanBeNull] ILogFile lf = null,
[CanBeNull] SqlResultLoggingService srls = null,
[CanBeNull] IInputDataLogger inputDataLogger = null,
[CanBeNull] CalculationProfiler calculationProfiler = null,
[CanBeNull] FileFactoryAndTracker fft = null,
[CanBeNull] DateStampCreator dsc = null)
{
_dateStampCreator = dsc;
_fft = fft;
_odap = odap;
_rnd = rnd;
_calcParameters = calcParameters;
_onlineLoggingData = onlineLoggingData;
_normalRandom = normalRandom;
_lf = lf;
_srls = srls;
_inputDataLogger = inputDataLogger;
_calculationProfiler = calculationProfiler;
}
public MakeNRWChart(int dpi, int height, int width, [JetBrains.Annotations.NotNull] CalculationProfiler calculationProfiler)
{
_dpi = dpi;
_height = height;
_width = width;
_calculationProfiler = calculationProfiler;
}
public void GetCalcManagerHouseTest()
{
using (var wd = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var sim = new Simulator(db.ConnectionString);
sim.MyGeneralConfig.ApplyOptionDefault(OutputFileDefault.OnlyOverallSum);
//ConfigSetter.SetGlobalTimeParameters(sim.MyGeneralConfig);
sim.Should().NotBeNull();
var cmf = new CalcManagerFactory();
CalculationProfiler calculationProfiler = new CalculationProfiler();
CalcStartParameterSet csps = new CalcStartParameterSet(sim.GeographicLocations[0],
sim.TemperatureProfiles[0], sim.Houses[sim.Houses.MyItems.Count - 1], EnergyIntensityType.Random, false,
null, LoadTypePriority.RecommendedForHouses, null, null, null, sim.MyGeneralConfig.AllEnabledOptions(),
new DateTime(2015, 1, 15), new DateTime(2015, 1, 18), new TimeSpan(0, 1, 0), ";", -1, new TimeSpan(0, 1, 0), false, false, false, 3, 3,
calculationProfiler, wd.WorkingDirectory, false);
var cm = cmf.GetCalcManager(sim, csps, false);
cm.Run(ReportCancelFunc);
db.Cleanup();
}
wd.CleanUp();
}
}
public void MakePlotMonthlyTest()
{
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(1, GlobalConsts.CSVCharacter, enddate: new DateTime(2012, 3, 31),
configSetter: x => x.Enable(CalcOption.TotalsPerDevice));
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var aeupp = new DeviceSums(ccps, fft, cp);
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var rfe = cs.GetRfeByFilename("DeviceSums_Monthly.Electricity.csv");
aeupp.MakePlotMonthly(rfe, "monthly sums", di);
Logger.Info("finished picture");
var imagefiles = FileFinder.GetRecursiveFiles(di, "DeviceSums_Monthly.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public void MakePlotTest()
{
CleanTestBase.RunAutomatically(false);
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
cs.StartHousehold(1, GlobalConsts.CSVCharacter,
LoadTypePriority.Mandatory, null,
x => x.Enable(CalcOption.VariableLogFile));
using (FileFactoryAndTracker fft = new FileFactoryAndTracker(cs.DstDir, "1", cs.Wd.InputDataLogger))
{
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccps = new ChartCreationParameters(300, 4000,
2500, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
var aeupp = new VariableLogFileChart(ccps, fft, cp);
Logger.Info("Making picture");
var di = new DirectoryInfo(cs.DstDir);
var rfe = cs.GetRfeByFilename("Variablelogfile.HH1.csv");
aeupp.MakePlot(rfe);
Logger.Info("finished picture");
//OxyCalculationSetup.CopyImage(ffe);
var imagefiles = FileFinder.GetRecursiveFiles(di, "Variablelogfile.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
}
cs.CleanUp();
CleanTestBase.RunAutomatically(true);
}
public void GetCalcManagerModularHousehold03Test()
{
using (var wd = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
Config.IsInUnitTesting = true;
var sim = new Simulator(db.ConnectionString);
sim.MyGeneralConfig.ApplyOptionDefault(OutputFileDefault.ReasonableWithChartsAndPDF);
DeviceCategory light = null;
foreach (var deviceCategory in sim.DeviceCategories.MyItems)
{
deviceCategory.RefreshSubDevices();
if (deviceCategory.Name.Contains("Light"))
{
light = deviceCategory;
}
}
if (light != null)
{
Logger.Info(light.SubDevices.Count.ToString(CultureInfo.CurrentCulture));
}
sim.MyGeneralConfig.ApplyOptionDefault(OutputFileDefault.NoFiles);
sim.MyGeneralConfig.Enable(CalcOption.TotalsPerLoadtype);
sim.MyGeneralConfig.Enable(CalcOption.TotalsPerDevice);
sim.MyGeneralConfig.Enable(CalcOption.MakePDF);
sim.MyGeneralConfig.Enable(CalcOption.HouseholdContents);
sim.Should().NotBeNull();
var cmf = new CalcManagerFactory();
ModularHousehold chs3 = null;
foreach (var modularHousehold in sim.ModularHouseholds.MyItems)
{
if (modularHousehold.Name.StartsWith("CHS01", StringComparison.Ordinal))
{
chs3 = modularHousehold;
}
}
if (chs3 == null)
{
throw new LPGException("Could not find the household CHS01");
}
Logger.Info(chs3.ToString());
CalculationProfiler calculationProfiler = new CalculationProfiler();
CalcStartParameterSet csps = new CalcStartParameterSet(sim.GeographicLocations[0],
sim.TemperatureProfiles[0], chs3, EnergyIntensityType.Random, false,
null, LoadTypePriority.Mandatory, null, null, null, sim.MyGeneralConfig.AllEnabledOptions(),
new DateTime(2015, 1, 15), new DateTime(2015, 1, 18), new TimeSpan(0, 1, 0), ";", -1, new TimeSpan(0, 1, 0), false, false, false, 3, 3,
calculationProfiler, wd.WorkingDirectory, false);
var cm = cmf.GetCalcManager(sim, csps, false);
cm.Run(ReportCancelFunc);
cm.Dispose();
db.Cleanup();
}
wd.CleanUp();
}
}
public static void LaunchParallel([NotNull] ParallelJsonLauncherOptions options)
{
Logger.LogFileIndex = "JsonParallelCalculationStarter";
Logger.LogToFile = true;
CalculationProfiler calculationProfiler = new CalculationProfiler();
calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass());
var pl = new ParallelJsonLauncher();
pl.LaunchParallelInternal(options);
calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass());
}
public void TimeOffsetBugTest()
{
Config.AdjustTimesForSettlement = false;
CleanTestBase.RunAutomatically(false);
var start = DateTime.Now;
using (var wd1 = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
var path = wd1.WorkingDirectory;
Config.MakePDFCharts = false;
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var sim = new Simulator(db.ConnectionString);
var calcstart = DateTime.Now;
sim.MyGeneralConfig.StartDateUIString = "1.1.2015";
sim.MyGeneralConfig.EndDateUIString = "31.1.2015";
sim.MyGeneralConfig.InternalTimeResolution = "00:01:00";
sim.MyGeneralConfig.RandomSeed = 5;
sim.MyGeneralConfig.ApplyOptionDefault(OutputFileDefault.Reasonable);
sim.MyGeneralConfig.ShowSettlingPeriod = "false";
sim.MyGeneralConfig.CSVCharacter = ";";
sim.MyGeneralConfig.SelectedLoadTypePriority = LoadTypePriority.RecommendedForHouseholds;
SimIntegrityChecker.Run(sim);
sim.Should().NotBeNull();
var cmf = new CalcManagerFactory();
//CalcDevice.UseRanges = true;
var geoloc = sim.GeographicLocations.FindFirstByName("Chemnitz", FindMode.Partial);
if (geoloc == null)
{
throw new LPGException("Geoloc was null");
}
var chh =
sim.ModularHouseholds.It.First(x => x.Name.StartsWith("CHR09", StringComparison.Ordinal));
CalculationProfiler calculationProfiler = new CalculationProfiler();
CalcStartParameterSet csps = new CalcStartParameterSet(geoloc,
sim.TemperatureProfiles[0], chh, EnergyIntensityType.Random,
false, null,
sim.MyGeneralConfig.SelectedLoadTypePriority, null, null, null,
sim.MyGeneralConfig.AllEnabledOptions(), new DateTime(2015, 1, 1), new DateTime(2015, 1, 31),
new TimeSpan(0, 1, 0), ";", 5, new TimeSpan(0, 1, 0),
false, false, false, 3, 3,
calculationProfiler, wd1.WorkingDirectory, false);
var cm = cmf.GetCalcManager(sim, csps, false);
public void MakeNRWChartTest()
{
CleanTestBase.RunAutomatically(false);
using (var wd = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var sim = new Simulator(db.ConnectionString);
var versions = sim.CalculationOutcomes.It.Select(x => x.LPGVersion).Distinct().ToList();
versions.Sort();
var dstversion = versions.Last();
//ChartLocalizer.ShouldTranslate = false;
var se1 = new MakeNRWChart.SeriesEntry(0.1, "EnergyIntensivePreferMeasured",
"Energieintensive Gerätewahl", dstversion);
var se2 = new MakeNRWChart.SeriesEntry(-0.1, "EnergySavingPreferMeasured",
"Energiesparende Gerätewahl", dstversion);
//MakeNRWChart.SeriesEntry se3 = new MakeNRWChart.SeriesEntry(-0.1, "EnergyIntensive","EnergyIntensive Gerätewahl", dstversion);
//MakeNRWChart.SeriesEntry se4 = new MakeNRWChart.SeriesEntry(-0.1, "EnergySaving", "EnergySaving Gerätewahl", dstversion);
var seriesEntries = new List <MakeNRWChart.SeriesEntry>
{
se1,
se2
};
// seriesEntries.Add(se3);
// seriesEntries.Add(se4);
CalculationProfiler cp = new CalculationProfiler();
foreach (var version in versions)
{
var v = version;
var versionEntries =
sim.CalculationOutcomes.It.Where(x => x.LPGVersion == v).ToList();
if (versionEntries.Count == 0)
{
throw new LPGException("No Entries Found");
}
var mnc = new MakeNRWChart(150, 1000, 1600, cp);
var pngname = Path.Combine(wd.WorkingDirectory, "testchart." + version + ".png");
// string pdfname = Path.Combine(wd.WorkingDirectory, "testchart." + version + ".pdf");
mnc.MakeScatterChart(versionEntries, pngname, seriesEntries);
}
var imagefiles = FileFinder.GetRecursiveFiles(new DirectoryInfo(wd.WorkingDirectory),
"testchart.*.png");
imagefiles.Count.Should().BeGreaterOrEqualTo(1);
db.Cleanup();
}
wd.CleanUp();
}
CleanTestBase.RunAutomatically(true);
}
public void DumpHouseholdContentsToTextTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass())) {
using (var wd1 = new WorkingDir(Utili.GetCurrentMethodAndClass())) {
var sim = new Simulator(db.ConnectionString)
{
MyGeneralConfig =
{
StartDateUIString = "01.01.2015",
EndDateUIString = "02.01.2015",
InternalTimeResolution = "00:01:00",
ExternalTimeResolution = "00:15:00",
RandomSeed = 5
}
};
sim.MyGeneralConfig.ApplyOptionDefault(OutputFileDefault.NoFiles);
sim.MyGeneralConfig.Enable(CalcOption.TotalsPerDevice);
sim.MyGeneralConfig.CSVCharacter = ";";
//ConfigSetter.SetGlobalTimeParameters(sim.MyGeneralConfig);
sim.Should().NotBeNull();
SimIntegrityChecker.Run(sim);
CalcManagerFactory.DoIntegrityRun = false;
var cmf = new CalcManagerFactory();
var calculationProfiler = new CalculationProfiler();
var csps = new CalcStartParameterSet(sim.GeographicLocations[0], sim.TemperatureProfiles[0], sim.ModularHouseholds[0],
EnergyIntensityType.Random, false, null, LoadTypePriority.RecommendedForHouses, null, null, null,
sim.MyGeneralConfig.AllEnabledOptions(), new DateTime(2015, 1, 1), new DateTime(2015, 1, 2), new TimeSpan(0, 1, 0), ";", 5,
new TimeSpan(0, 15, 0), false, false, false, 3, 3, calculationProfiler, wd1.WorkingDirectory, false);
var cm = cmf.GetCalcManager(sim, csps, false);
//,, wd1.WorkingDirectory, sim.ModularHouseholds[0], false,
//sim.TemperatureProfiles[0], sim.GeographicLocations[0], EnergyIntensityType.Random, version,
//LoadTypePriority.RecommendedForHouses, null,null
var dls = new DayLightStatus(new BitArray(100));
if (cm.CalcObject == null)
{
throw new LPGException("xxx");
}
cm.CalcObject.Init(dls, 1);
CalcManager.ExitCalcFunction = true;
cm.CalcObject.DumpHouseholdContentsToText();
cm.Dispose();
db.Cleanup();
wd1.CleanUp();
}
}
}
public void Run()
{
using (var wd = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var sim = new Simulator(db.ConnectionString);
var calculationProfiler = new CalculationProfiler();
var csps = new CalcStartParameterSet(sim.GeographicLocations[0],
sim.TemperatureProfiles[0],
sim.ModularHouseholds[0],
EnergyIntensityType.EnergySaving,
false,
null,
LoadTypePriority.OptionalLoadtypes,
null,
null,
null,
new List <CalcOption>(),
new DateTime(2018, 1, 1),
new DateTime(2018, 1, 10),
new TimeSpan(0, 1, 0),
";",
1,
new TimeSpan(0, 1, 0),
false,
false,
false,
3,
3,
calculationProfiler, wd.WorkingDirectory, false);
var cmf = new CalcManagerFactory();
var cm = cmf.GetCalcManager(sim, csps, false);
cm.Run(null);
var mq = new Mock <ICalculationProfiler>();
wd.InputDataLogger.AddSaver(new ResultFileEntryLogger(wd.SqlResultLoggingService));
//FileFactoryAndTracker fft = new FileFactoryAndTracker(wd.WorkingDirectory,"objname",cm.Logfile.FileFactoryAndTracker);
//fft.RegisterHouseholdKey(Constants.GeneralHouseholdKey,"general");
//fft.RegisterHouseholdKey(Constants.GeneralHouseholdKey,"general");
var pcm = new PostProcessingManager(mq.Object, cm.CalcRepo.FileFactoryAndTracker);
//Debug.Assert(calcResult != null, nameof(calcResult) + " != null");
pcm.Run(wd.WorkingDirectory);
db.Cleanup();
}
wd.CleanUp();
}
}
//public const string TableName = "CalcStartParameterSet";
/// <summary>
/// starter for unit tests
/// </summary>
public CalcStartParameterSet(
[NotNull] GeographicLocation geographicLocation,
[NotNull] TemperatureProfile temperatureProfile,
[NotNull] ICalcObject calcTarget,
EnergyIntensityType energyIntensity,
bool resumeSettlement,
[CanBeNull] DeviceSelection deviceSelection,
LoadTypePriority loadTypePriority,
[CanBeNull] TransportationDeviceSet transportationDeviceSet, [CanBeNull] ChargingStationSet chargingStationSet,
[CanBeNull] TravelRouteSet travelRouteSet, [NotNull] List <CalcOption> calcOptions,
DateTime officialSimulationStartTime,
DateTime officialSimulationEndTime,
TimeSpan internalTimeResolution,
[NotNull] string csvCharacter,
int selectedRandomSeed,
TimeSpan externalTimeResolution, bool deleteDatFiles, bool writeExcelColumn, bool showSettlingPeriod,
int settlingDays, int affordanceRepetitionCount, [NotNull] CalculationProfiler calculationProfiler, string resultPath, bool transportationEnabled)
{
OfficialSimulationStartTime = officialSimulationStartTime;
OfficialSimulationEndTime = officialSimulationEndTime;
InternalTimeResolution = internalTimeResolution;
CsvCharacter = csvCharacter;
SelectedRandomSeed = selectedRandomSeed;
ExternalTimeResolution = externalTimeResolution;
DeleteDatFiles = deleteDatFiles;
WriteExcelColumn = writeExcelColumn;
ShowSettlingPeriod = showSettlingPeriod;
SettlingDays = settlingDays;
AffordanceRepetitionCount = affordanceRepetitionCount;
CalculationProfiler = calculationProfiler;
GeographicLocation = geographicLocation;
TemperatureProfile = temperatureProfile;
CalcTarget = calcTarget;
EnergyIntensity = energyIntensity;
ResumeSettlement = resumeSettlement;
LPGVersion = Utili.GetCurrentAssemblyVersion();
DeviceSelection = deviceSelection;
LoadTypePriority = loadTypePriority;
TransportationDeviceSet = transportationDeviceSet;
TravelRouteSet = travelRouteSet;
CalcOptions = calcOptions;
ChargingStationSet = chargingStationSet;
DeviceProfileHeaderMode = DeviceProfileHeaderMode.Standard;
ResultPath = resultPath;
CalculationStartTime = DateTime.Now;
TransportationEnabled = transportationEnabled;
}
public static CalcRepo Make([NotNull] CalcParameters calcParameters, [NotNull] IInputDataLogger idl,
[NotNull] string resultPath, [NotNull] string calcObjectName,
CalculationProfiler calculationProfiler)
{
DateStampCreator dsc = new DateStampCreator(calcParameters);
OnlineLoggingData old = new OnlineLoggingData(dsc, idl, calcParameters);
FileFactoryAndTracker fft = new FileFactoryAndTracker(resultPath, calcObjectName, idl);
LogFile lf = new LogFile(calcParameters, fft);
OnlineDeviceActivationProcessor odap = new OnlineDeviceActivationProcessor(old, calcParameters, fft);
Random rnd = new Random(calcParameters.ActualRandomSeed);
NormalRandom nr = new NormalRandom(0, 0.1, rnd);
SqlResultLoggingService srls = new SqlResultLoggingService(resultPath);
CalcRepo cr = new CalcRepo(odap, rnd, calcParameters, old, nr, lf, srls,
idl, calculationProfiler, fft, dsc);
return(cr);
}
private static void CalculateOneHousehold([NotNull] string path)
{
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
using var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass());
var sim = new Simulator(db.ConnectionString);
Config.IsInUnitTesting = true;
sim.MyGeneralConfig.ApplyOptionDefault(OutputFileDefault.Reasonable);
sim.MyGeneralConfig.Enable(CalcOption.DeviceProfilesIndividualHouseholds);
sim.MyGeneralConfig.ShowSettlingPeriodBool = true;
//ConfigSetter.SetGlobalTimeParameters(sim.MyGeneralConfig);
sim.Should().NotBeNull();
var cmf = new CalcManagerFactory();
CalculationProfiler calculationProfiler = new CalculationProfiler();
//todo: put in a full house with transportation
//var house = sim.Houses.CreateNewItem()
CalcStartParameterSet csps = new CalcStartParameterSet(sim.GeographicLocations[0],
sim.TemperatureProfiles[0], sim.ModularHouseholds[0],
EnergyIntensityType.Random, false,
null, LoadTypePriority.Mandatory, null, null, null, sim.MyGeneralConfig.AllEnabledOptions(),
new DateTime(2015, 1, 15),
new DateTime(2015, 1, 18),
new TimeSpan(0, 1, 0), ";",
5, new TimeSpan(0, 1, 0),
false, false, false, 3,
sim.MyGeneralConfig.RepetitionCount,
calculationProfiler, path, false);
var cm = cmf.GetCalcManager(sim, csps, false);
bool success = cm.Run(ReportCancelFunc);
if (!success)
{
throw new LPGException("Calculation failed");
}
db.Cleanup();
}
public static void StartHouse(int house)
{
CleanTestBase.RunAutomatically(false);
var start = DateTime.Now;
using (var wd1 = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
var path = wd1.WorkingDirectory;
Config.MakePDFCharts = false;
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var sim = new Simulator(db.ConnectionString);
var calcstart = DateTime.Now;
sim.MyGeneralConfig.StartDateUIString = "1.1.2015";
sim.MyGeneralConfig.EndDateUIString = "31.1.2015";
sim.MyGeneralConfig.InternalTimeResolution = "00:01:00";
sim.MyGeneralConfig.RandomSeed = 5;
sim.MyGeneralConfig.ApplyOptionDefault(OutputFileDefault.NoFiles);
sim.MyGeneralConfig.Enable(CalcOption.HouseSumProfilesFromDetailedDats);
sim.MyGeneralConfig.CSVCharacter = ";";
sim.MyGeneralConfig.SelectedLoadTypePriority = LoadTypePriority.All;
SimIntegrityChecker.Run(sim);
//CalcParameters
//CalcParametersFactory.SetGlobalTimeParameters(sim.MyGeneralConfig);
//ConfigSetter.SetGlobalTimeParameters(sim.MyGeneralConfig);
sim.Should().NotBeNull();
var cmf = new CalcManagerFactory();
//CalcDevice.UseRanges = true;
var geoloc = sim.GeographicLocations.FindFirstByName("Chemnitz", FindMode.Partial);
if (geoloc == null)
{
throw new LPGException("Geoloc was null");
}
var house1 =
sim.Houses.It[house];
CalculationProfiler calculationProfiler = new CalculationProfiler();
CalcStartParameterSet csps = new CalcStartParameterSet(geoloc,
sim.TemperatureProfiles[0], house1, EnergyIntensityType.Random, false,
null, LoadTypePriority.All, null, null, null, sim.MyGeneralConfig.AllEnabledOptions(),
new DateTime(2015, 1, 1), new DateTime(2015, 1, 31), new TimeSpan(0, 1, 0), ";", 5, new TimeSpan(0, 1, 0), false, false, false, 3, 3,
calculationProfiler, path, false);
var cm = cmf.GetCalcManager(sim, csps, false);
public void MakeDocumentTestFull()
{
var cs = new OxyCalculationSetup(Utili.GetCurrentMethodAndClass());
var name = cs.StartHousehold(1, GlobalConsts.CSVCharacter,
LoadTypePriority.All, null, x => x.ApplyOptionDefault(OutputFileDefault.All));
CalculationProfiler cp = new CalculationProfiler();
ChartCreationParameters ccp = new ChartCreationParameters(144, 1600, 1000, false, GlobalConsts.CSVCharacter, new DirectoryInfo(cs.DstDir));
using (FileFactoryAndTracker fft = cs.GetFileTracker())
{
var cg = new ChartGeneratorManager(cp, fft, ccp);
Logger.Info("Making picture");
cg.Run(cs.DstDir);
Logger.Info("finished picture");
MigraPDFCreator mpc = new MigraPDFCreator(cp);
mpc.MakeDocument(cs.DstDir, name + ".test", false, false, GlobalConsts.CSVCharacter, fft);
}
//cs.CleanUp(1);
}
