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 OnlineDeviceActivationProcessorArrayTest()
{
var rnd = new Random(1);
var nr = new NormalRandom(0, 1, rnd);
using (var wd = new WorkingDir(Utili.GetCurrentMethodAndClass())) {
wd.InputDataLogger.AddSaver(new ColumnEntryLogger(wd.SqlResultLoggingService));
wd.InputDataLogger.AddSaver(new ResultFileEntryLogger(wd.SqlResultLoggingService));
wd.InputDataLogger.AddSaver(new HouseholdKeyLogger(wd.SqlResultLoggingService));
var calcParameters = CalcParametersFactory.MakeGoodDefaults().EnableShowSettlingPeriod();
//calcParameters.Enable(CalcOption.ActionsLogfile);
calcParameters.Enable(CalcOption.DeviceProfilesIndividualHouseholds);
calcParameters.Enable(CalcOption.DetailedDatFiles);
using (var fft = new FileFactoryAndTracker(wd.WorkingDirectory, "hh1", wd.InputDataLogger)) {
//SqlResultLoggingService srls = new SqlResultLoggingService(Path.Combine(wd.WorkingDirectory, "results.sqlite"));
var dsc = new DateStampCreator(calcParameters);
using (IOnlineLoggingData old = new OnlineLoggingData(dsc, wd.InputDataLogger, calcParameters)) {
var hhkey = new HouseholdKey("HH1");
fft.RegisterHousehold(Constants.GeneralHouseholdKey, "generalhousehold", HouseholdKeyType.General, "Description", null, null);
fft.RegisterHousehold(hhkey, "hh1", HouseholdKeyType.Household, "Description", null, null);
var odap = new OnlineDeviceActivationProcessor(old, calcParameters, fft);
var deviceGuid = "devguid".ToStrGuid();
var locationGuid = "locationGuid".ToStrGuid();
var loadtypeGuid = "ltguid".ToStrGuid();
var cdd = new CalcDeviceDto("devicename", "devcatguid".ToStrGuid(), hhkey, OefcDeviceType.Device, "devcatname", "",
deviceGuid, locationGuid, "loc");
var key = new OefcKey(cdd, loadtypeGuid);
var clt = new CalcLoadType("lt1", "W", "kWh", 1, true, loadtypeGuid);
odap.RegisterDevice(clt.ConvertToDto(), cdd);
double[] stepValues = { 1.0, 0 };
var valueList = new List <double>(stepValues);
var cp = new CalcProfile("myCalcProfile", Guid.NewGuid().ToStrGuid(), valueList, ProfileType.Absolute, "synthetic");
var ts1 = new TimeStep(1, 0, false);
var cdl = new CalcDeviceLoad("", 1, clt, 0, 0);
var sv = StepValues.MakeStepValues(cp, 10, RandomValueProfile.MakeStepValues(cp.StepValues.Count, nr, 0), cdl);
odap.AddNewStateMachine(ts1, clt.ConvertToDto(), "name1", "p1", key, cdd, sv);
double[] resultValues = { 0, 10.0, 0, 0, 0, 0, 0, 0, 0, 0 };
for (var i = 0; i < 10; i++)
{
var ts = new TimeStep(i, 0, true);
var filerows = odap.ProcessOneTimestep(ts);
filerows.Count.Should().Be(1);
filerows[0].EnergyEntries.Count.Should().Be(1);
Logger.Info(filerows[0].EnergyEntries[0].ToString(CultureInfo.CurrentCulture));
resultValues[i].Should().Be(filerows[0].EnergyEntries[0]);
foreach (var fileRow in filerows)
{
fileRow.Save(odap.BinaryOutStreams[fileRow.LoadType]);
}
}
}
}
Logger.Info(wd.WorkingDirectory);
wd.CleanUp();
}
}
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 RegisterDeviceActivationTest()
{
using (WorkingDir wd = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
wd.InputDataLogger.AddSaver(new HouseholdKeyLogger(wd.SqlResultLoggingService));
wd.InputDataLogger.AddSaver(new DeviceActivationEntryLogger(wd.SqlResultLoggingService));
wd.InputDataLogger.AddSaver(new ResultFileEntryLogger(wd.SqlResultLoggingService));
CalcParameters cp = CalcParametersFactory.MakeGoodDefaults().EnableShowSettlingPeriod();
using (var fft = new FileFactoryAndTracker(wd.WorkingDirectory, "hhname", wd.InputDataLogger))
{
var key = new HouseholdKey(" hh1");
fft.HouseholdRegistry.RegisterHousehold(key, "hh key", HouseholdKeyType.Household, wd.InputDataLogger, "desc", null, null);
fft.HouseholdRegistry.RegisterHousehold(Constants.GeneralHouseholdKey, "general", HouseholdKeyType.General, wd.InputDataLogger, "desc", null, null);
DateStampCreator dsc = new DateStampCreator(cp);
using OnlineLoggingData old = new OnlineLoggingData(dsc, wd.InputDataLogger, cp);
fft.HouseholdRegistry.RegisterHousehold(key, "hh key", HouseholdKeyType.Household, wd.InputDataLogger, "desc", null, null);
CalcLoadTypeDto clt = new CalcLoadTypeDto("lt", "unitofpower", "unitofsum", 1, true, "guid".ToStrGuid());
TimeStep ts = new TimeStep(1, 1, true);
CalcDeviceDto cdd = new CalcDeviceDto("devname", "".ToStrGuid(), key,
OefcDeviceType.Device, "devcatname", "", Guid.NewGuid().ToStrGuid(), "locguid".ToStrGuid(), "locname");
DeviceActivationEntry aeue = new DeviceActivationEntry("affname", clt, 1, "activatorname", 1, ts, cdd);
old.RegisterDeviceActivation(aeue);
old.FinalSaveToDatabase();
}
wd.CleanUp();
}
}
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(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 LogFile([NotNull] CalcParameters calcParameters,
FileFactoryAndTracker fft,
bool writeToConsole = false
)
{
if (calcParameters.IsSet(CalcOption.ThoughtsLogfile))
{
if (writeToConsole)
{
_thoughtsLogFile = new ConsoleThoughts();
}
else
{
_thoughtsLogFile = new ThoughtsLogFile(fft, calcParameters);
}
}
if (calcParameters.IsSet(CalcOption.DesiresLogfile))
{
_desiresLogfile = new DesiresLogFile(fft, calcParameters);
}
if (calcParameters.IsSet(CalcOption.EnergyStorageFile))
{
_energyStorageLogfile = new EnergyStorageLogfile(calcParameters, fft);
}
//_transportationLogFile = new TransportationLogFile(_fft,_calcParameters);
}
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,
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 AffordanceEnergyUse([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.AffordanceEnergyUse },
"Affordance Energy Use", FileProcessingResult.ShouldCreateFiles)
{
}
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 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);
//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(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 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);
}
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 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 void PickRandomAffordanceFromEquallyAttractiveOnesTest()
{
using (var wd = new WorkingDir(Utili.GetCurrentMethodAndClass())) {
CalcParameters calcParameters = CalcParametersFactory.MakeGoodDefaults();
calcParameters.AffordanceRepetitionCount = 0;
wd.InputDataLogger.AddSaver(new HouseholdKeyLogger(wd.SqlResultLoggingService));
wd.InputDataLogger.AddSaver(new ResultFileEntryLogger(wd.SqlResultLoggingService));
using (var fft = new FileFactoryAndTracker(wd.WorkingDirectory, "blub", wd.InputDataLogger)) {
fft.RegisterHousehold(Constants.GeneralHouseholdKey, "general", HouseholdKeyType.General, "desc", null, null);
//SqlResultLoggingService srls = new SqlResultLoggingService(wd.WorkingDirectory);
//DateStampCreator dsc = new DateStampCreator(calcParameters);
Random rnd = new Random();
//OnlineLoggingData old = new OnlineLoggingData(dsc, wd.InputDataLogger, calcParameters);
using (var lf = new LogFile(calcParameters, fft)) {
CalcProfile cp = new CalcProfile("cp1", Guid.NewGuid().ToStrGuid(), TimeSpan.FromMinutes(1), ProfileType.Absolute, "bla");
CalcVariableRepository crv = new CalcVariableRepository();
BitArray isBusy = new BitArray(calcParameters.InternalTimesteps, false);
using CalcRepo calcRepo = new CalcRepo(lf: lf, calcParameters: calcParameters, rnd: rnd);
CalcAffordance aff1 = new CalcAffordance("aff1", cp, null, false, new List <CalcDesire>(), 10, 20, PermittedGender.All, true,
1, LPGColors.AliceBlue, null, false, false, null, null, ActionAfterInterruption.GoBackToOld, "", 900, false, "",
Guid.NewGuid().ToStrGuid(), crv, new List <CalcAffordance.DeviceEnergyProfileTuple>(), isBusy, BodilyActivityLevel.Low,
calcRepo);
CalcAffordance aff2 = new CalcAffordance("aff2", cp, null, false, new List <CalcDesire>(), 10, 20, PermittedGender.All, true,
1, LPGColors.AliceBlue, null, false, false, null, null, ActionAfterInterruption.GoBackToOld, "", 100, false, "",
Guid.NewGuid().ToStrGuid(), crv, new List <CalcAffordance.DeviceEnergyProfileTuple>(), isBusy, BodilyActivityLevel.Low,
calcRepo);
List <ICalcAffordanceBase> affs = new List <ICalcAffordanceBase> {
aff1,
aff2
};
int aff1C = 0;
int aff2C = 0;
BitArray isSick = new BitArray(calcParameters.InternalTimesteps);
BitArray isOnVacation = new BitArray(calcParameters.InternalTimesteps);
CalcPersonDto calcPerson = CalcPersonDto.MakeExamplePerson();
CalcPerson cperson = new CalcPerson(calcPerson, null, isSick, isOnVacation, calcRepo);
TimeStep ts = new TimeStep(1, 0, true);
for (int i = 0; i < 1000; i++)
{
ICalcAffordanceBase cab = cperson.PickRandomAffordanceFromEquallyAttractiveOnes(affs, ts, null, new HouseholdKey("bla"));
if (cab == aff1)
{
aff1C++;
}
if (cab == aff2)
{
aff2C++;
}
}
aff1C.Should().BeApproximatelyWithinPercent(900, 0.1);
Logger.Info("Number of selections for 90%:" + aff1C + ", 10%:" + aff2C);
}
}
wd.CleanUp();
}
}
public DurationCurve([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.DurationCurveSums },
"Duration Curve", FileProcessingResult.ShouldCreateFiles
)
{
}
public DesiresLogFile([NotNull] FileFactoryAndTracker fft, [NotNull] CalcParameters calcParameters)
{
_fft = fft;
_calcParameters = calcParameters;
_desireFiles = new Dictionary <string, StreamWriter>();
_writeDesiresHeader = new Dictionary <string, bool>();
_dsc = new DateStampCreator(calcParameters);
}
public LocationStatistics([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.LocationStatistic },
"Location Statistics", FileProcessingResult.ShouldCreateFiles
)
{
}
public ActivityFrequenciesPerMinute([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.ActivationFrequencies },
"Activity Frequencies per Minute ", FileProcessingResult.ShouldCreateFiles
)
{
}
public EnergyStorageLogfile([NotNull] CalcParameters calcParameters, [NotNull] FileFactoryAndTracker fft)
{
_fft = fft;
_calcParameters = calcParameters;
_dsc = new DateStampCreator(calcParameters);
_writeHeader = true;
//_makeLogFile = _calcParameters.IsSet(CalcOption.EnergyStorageFile)
}
public HouseholdPlan([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.HouseholdPlanTime },
"Household Plan Results", FileProcessingResult.ShouldCreateFiles
)
{
}
public DeviceProfilesExternal([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.DeviceProfileCSVExternal },
"Device Profiles Externals", FileProcessingResult.ShouldCreateFiles
)
{
}
public VariableLogFileChart([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.VariableLogfile },
"Variable Logfile", FileProcessingResult.ShouldCreateFiles
)
{
}
public ExecutedActionsOverviewCount([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.ExecutedActionsOverview },
"Executed Actions Overview Count", FileProcessingResult.ShouldCreateFiles
)
{
}
protected ChartBaseFileStep([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft, [JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler,
[JetBrains.Annotations.NotNull] List <ResultFileID> validResultFileIds, [JetBrains.Annotations.NotNull] string stepName,
FileProcessingResult shouldHaveProducedFiles) : base(parameters, stepName, shouldHaveProducedFiles, fft)
{
_calculationProfiler = calculationProfiler;
ResultFileIDs = validResultFileIds;
}
public TimeOfUse([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.TimeOfUseEnergy, ResultFileID.TimeOfUse },
"Activity Percentages", FileProcessingResult.ShouldCreateFiles
)
{
}
public CriticalThresholdViolations([JetBrains.Annotations.NotNull] ChartCreationParameters parameters,
[JetBrains.Annotations.NotNull] FileFactoryAndTracker fft,
[JetBrains.Annotations.NotNull] ICalculationProfiler calculationProfiler) : base(parameters, fft,
calculationProfiler, new List <ResultFileID>() { ResultFileID.CriticalThresholdViolations },
"Critical Threshold Violations", FileProcessingResult.ShouldCreateFiles
)
{
}
