public Task OnSecond(DateTime time, DateTime starTime, ReadingData data, ReadingData minorData, ReadingData majorData)
{
return(Task.Run(() =>
{
LastReading = data;
LastBuildingInterval = isMajor ? majorData : minorData;
}));
}
public static List <Reading> getReadings()
{
string jsonResponse = Request.get("/tables/TreeSurvey" + "?" + zumoApiVersion);
ReadingData readings = JsonUtility.FromJson <ReadingData>("{\"response\" : " + jsonResponse + "}");
return(readings.response);
}
public WorkshopWebService()
{
ReadingData = new ReadingData(UserConnection ?? SystemUserConnection);
UpdatingData = new UpdatingData(UserConnection ?? SystemUserConnection);
InsertingData = new InsertingData(UserConnection ?? SystemUserConnection);
DeletingData = new DeletingData(UserConnection ?? SystemUserConnection);
Timer = new Stopwatch();
}
public Task <ReadingData> GetMinorReading(DateTime intervalStarted)
{
return(Task.Run(() =>
{
OnConnectionStatus(true);
return ReadingData.Average(minor.Select(x => x.Item2).ToList());
}));
}
public void Add(DateTime time, ReadingData data)
{
history.AddLast(new Tuple <DateTime, ReadingData>(time, data));
if (history.Count > 0 && history.First.Value.Item1 < time - maxAge)
{
history.RemoveFirst();
}
}
public Task OnMajor(DateTime time, DateTime starTime, ReadingData data)
{
return(Task.Run(() =>
{
if (isMajor)
{
LastInterval = data;
}
}));
}
public Task OnMajor(DateTime time, DateTime starTime, ReadingData data)
{
return(Task.Run(() =>
{
lock (LogFileLock)
{
StreamWriter.WriteLineAsync(ToCsv(data, starTime, true)).Wait();
StreamWriter.Flush();
}
}));
}
public Task OnSecond(DateTime time, DateTime starTime, ReadingData data, ReadingData minorData, ReadingData majorData)
{
return(Task.Run(() =>
{
double value = data.GetValue(displayItem);
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
LineValues.Add(new Tuple <DateTime, double>(starTime, value));
});
}));
}
public Task OnSecond(DateTime time, DateTime starTime, ReadingData data, ReadingData minorData, ReadingData majorData)
{
return(Task.Run(() =>
{
SendMessageToAll(string.Format(TcpMessages.OnSecondResponse, JsonConvert.SerializeObject(new TcpWrapperOnSecond()
{
Second = data,
Minor = minorData,
Major = majorData
})));
}));
}
public Task OnMajor(DateTime time, DateTime starTime, ReadingData data)
{
return(Task.Run(() =>
{
MajorReadings.Enqueue(new Tuple <DateTime, ReadingData>(starTime, data));
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
majorIntervalHistory.Add(starTime, data);
majorGraphViewModel.OnBarReading();
});
}));
}
public Task <ReadingData> GetSecondReading()
{
return(Task.Run(() =>
{
ReadingData reading = new ReadingData();
lock (deviceLock)
{
logger.Trace("Performing seconds reading from NTI XL2 on port {0}", portName);
if (!DeviceAction((serialPort, token) =>
{
token.ThrowIfCancellationRequested();
// Initiate first measurement
this.WriteLine(serialPort, NTIXL2Commands.InitiateMeasurement);
if (token.IsCancellationRequested)
{
return;
}
// ask for leq
this.WriteLine(serialPort, NTIXL2Commands.Measurement + " LAEQ LAFMAX LAFMIN LZFMAX LZFMIN LCEQ");
if (token.IsCancellationRequested)
{
return;
}
// getting LEQ
reading.LAeq = NTIXL2Utilities.ParseMeasurement(ReadToDB(serialPort));
reading.LAMax = NTIXL2Utilities.ParseMeasurement(ReadToDB(serialPort));
reading.LAMin = NTIXL2Utilities.ParseMeasurement(ReadToDB(serialPort));
reading.LZMax = NTIXL2Utilities.ParseMeasurement(ReadToDB(serialPort));
reading.LZMin = NTIXL2Utilities.ParseMeasurement(ReadToDB(serialPort));
reading.LCeq = NTIXL2Utilities.ParseMeasurement(ReadToDB(serialPort));
// Getting EQ
this.WriteLine(serialPort, NTIXL2Commands.Octive);
reading.LAeqOctaveBandOneThird = NTIXL2Utilities.ParseOctive(ReadToDB(serialPort));
previousReadings.AddLast(new Tuple <DateTime, ReadingData>(DateTime.Now, reading));
logger.Trace("LAeq response {0} from NTI LX2 port {1}.", reading.LAeq, portName);
}))
{
return null;
}
}
// Null reading
if (reading.LAeq < 0)
{
return null;
}
return reading;
}));
}
protected void AddReading(ReadingData data)
{
if (string.IsNullOrEmpty(data.Name))
{
data.Name = ReadingName;
}
FeatureDescriptor descriptor = GetFeatureDescriptor();
var newReading = new Reading {
FeatureName = descriptor.Name, FeatureGroup = descriptor.Group, Data = data
};
ReadingPublisher.PublishReading(newReading);
}
public Task <ReadingData> GetSecondReading()
{
return(Task.Run(() =>
{
OnConnectionStatus(true);
var newReading = new ReadingData()
{
LAeq = newRandom((int)this.lastReading.LZMin),
LCeq = newRandom((int)this.lastReading.LCeq),
LAMax = newRandom((int)this.lastReading.LAMax),
LAMin = newRandom((int)this.lastReading.LAMin),
LZMax = newRandom((int)this.lastReading.LZMax),
LZMin = newRandom((int)this.lastReading.LZMin)
};
foreach (var band in typeof(ReadingData.OctaveBandOneThird).GetProperties()
.Where(x => x.PropertyType == typeof(double)))
{
band.SetValue(newReading.LAeqOctaveBandOneThird, newRandom((double)band.GetValue(lastReading.LAeqOctaveBandOneThird)));
}
foreach (var band in typeof(ReadingData.OctaveBandOneOne).GetProperties()
.Where(x => x.PropertyType == typeof(double)))
{
band.SetValue(newReading.LAeqOctaveBandOneOne, newRandom((double)band.GetValue(lastReading.LAeqOctaveBandOneOne)));
}
//newReading.LAeqOctaveBandOneThird.Hz1000 = 75.0;
//newReading.LAeqOctaveBandOneOne.Hz1000 = 75.0;
lock (minor)
{
minor.Add(new Tuple <DateTime, ReadingData>(DateTime.Now, newReading));
minor.RemoveAll(x => x.Item1 < DateTime.Now - minorInterval);
}
lock (major)
{
major.Add(new Tuple <DateTime, ReadingData>(DateTime.Now, newReading));
major.RemoveAll(x => x.Item1 < DateTime.Now - majorInterval);
}
lastReading = newReading;
return newReading;
}));
}
public Task Close()
{
return(Task.Run(() =>
{
ReadingData reading = new ReadingData();
lock (deviceLock)
{
logger.Trace("Telling NTI XL2 on port {0} to stop the measurements.", portName);
DeviceAction((serialPort, token) =>
{
token.ThrowIfCancellationRequested();
// Initiate first measurement
this.WriteLine(serialPort, NTIXL2Commands.Stop);
});
}
performClose();
}));
}
public Task <ReadingData> GetMinorReading(DateTime intervalStarted)
{
return(Task.Run(() =>
{
RemoveOldReadings();
var reading = new ReadingData();
lock (previousReadings)
{
var minorReadings = previousReadings.Where(x => x.Item1 >= intervalStarted).ToList();
if (!minorReadings.Any())
{
return null;
}
reading = ReadingData.Average(minorReadings.Select(x => x.Item2).ToList());
}
return reading;
}));
}
public Task OnSecond(DateTime time, DateTime starTime, ReadingData data, ReadingData minorData, ReadingData majorData)
{
return(Task.Run(() =>
{
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
readingHistory.Add(starTime, data);
minorGraphViewModel.OnLineReading();
// Add data for the octave bar
OctaveValues.Clear();
if (minorData != null)
{
foreach (var obp in DecibelHelper.GetOneOneOctaveBand())
{
OctaveValues.Add(new OctaveBandGraphValue(obp.Display, minorData.GetValue("1-1-" + obp.Method), obp.LimitAjust, settings.MinorDBLimit));
}
}
});
}));
}
public Task OnSecond(DateTime time, ReadingData second, ReadingData minor, ReadingData major)
{
return(Task.Run(() =>
{
try
{
DateTime mesurementSpanStart = time - TimeSpan.FromSeconds(1);
logger.Trace("Triggered second reading \"{0}\".", second.LAeq);
lock (this.listeners)
{
foreach (var listener in this.listeners)
{
listener.OnSecond(time, mesurementSpanStart, second, minor, major);
}
}
}
catch (Exception exp)
{
logger.Error(exp, "Failed on second reading");
}
}));
}
internal void SetValue(double value, DateTime timeStamp, bool save)
{
// Set the current value
Current.SetValue(value, timeStamp);
if (save)
{
// Save the reading
using (var weatherArchiveData = new WeatherArchiveData(timeStamp.Year))
{
var reading = new ReadingData
{
DeviceId = _ownerDevice.Id,
Type = (int)ValueType,
Value = value,
ReadTime = timeStamp
};
weatherArchiveData.Readings.Add(reading);
weatherArchiveData.SaveChanges();
}
}
}
public Task OnSecond(DateTime time, DateTime starTime, ReadingData data, ReadingData minorData, ReadingData majorData)
{
return(Task.Run(() =>
{
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
OctaveValues.Clear();
if ((building ? minorData : data) == null)
{
return;
}
if (band == OctaveBand.OneOne)
{
foreach (var obp in DecibelHelper.GetOneOneOctaveBand())
{
OctaveValues.Add(new OctaveBandGraphValue(obp.Display, (building ? minorData : data).GetValue("1-1-" + obp.Method), obp.LimitAjust, _settings.MinorDBLimit));
}
}
else
{
foreach (var obp in DecibelHelper.GetOneThirdOctaveBand())
{
OctaveValues.Add(new OctaveBandGraphValue(obp.Display,
(building ? minorData : data).GetValue("1-3-" + obp.Method), obp.LimitAjust,
_settings.MinorDBLimit));
}
}
});
}));
}
internal override void Aggregate(ReadingData other)
{
Value += (int)other.GetValue();
}
public Task OnMajor(DateTime time, DateTime starTime, ReadingData data)
{
return(Task.FromResult <object>(null));
}
public void Add(ReadingData data)
{
AddReading(data);
}
public override void Aggregate(ReadingData other)
{
Value += (double)other.GetValue();
}
private async void WriteReading(bool major, DateTime time, ReadingData data)
{
var readingGuid = Guid.NewGuid();
try
{
// Ensure the inital create have finished
if (initalCreate != null)
{
lock (initalCreateLock)
{
if (initalCreate != null)
{
Task.WaitAll(initalCreate);
initalCreate = null;
}
}
}
var reading = new Reading()
{
Id = readingGuid,
Project = this.Id,
Major = major ? (byte)1 : (byte)0,
Time = time,
LAeq = data.LAeq,
LAMax = data.LAMax,
LAMin = data.LAMin,
LZMax = data.LZMax,
LZMin = data.LZMin,
// 1/3
Hz6_3 = data.LAeqOctaveBandOneThird.Hz6_3,
Hz8 = data.LAeqOctaveBandOneThird.Hz8,
Hz10 = data.LAeqOctaveBandOneThird.Hz10,
Hz12_5 = data.LAeqOctaveBandOneThird.Hz12_5,
Hz16 = data.LAeqOctaveBandOneThird.Hz16,
Hz20 = data.LAeqOctaveBandOneThird.Hz20,
Hz25 = data.LAeqOctaveBandOneThird.Hz25,
Hz31_5 = data.LAeqOctaveBandOneThird.Hz31_5,
Hz40 = data.LAeqOctaveBandOneThird.Hz40,
Hz50 = data.LAeqOctaveBandOneThird.Hz50,
Hz63 = data.LAeqOctaveBandOneThird.Hz63,
Hz80 = data.LAeqOctaveBandOneThird.Hz80,
Hz100 = data.LAeqOctaveBandOneThird.Hz100,
Hz125 = data.LAeqOctaveBandOneThird.Hz125,
Hz160 = data.LAeqOctaveBandOneThird.Hz160,
Hz200 = data.LAeqOctaveBandOneThird.Hz200,
Hz250 = data.LAeqOctaveBandOneThird.Hz250,
Hz315 = data.LAeqOctaveBandOneThird.Hz315,
Hz400 = data.LAeqOctaveBandOneThird.Hz400,
Hz500 = data.LAeqOctaveBandOneThird.Hz500,
Hz630 = data.LAeqOctaveBandOneThird.Hz630,
Hz800 = data.LAeqOctaveBandOneThird.Hz800,
Hz1000 = data.LAeqOctaveBandOneThird.Hz1000,
Hz1250 = data.LAeqOctaveBandOneThird.Hz1250,
Hz1600 = data.LAeqOctaveBandOneThird.Hz1600,
Hz2000 = data.LAeqOctaveBandOneThird.Hz2000,
Hz2500 = data.LAeqOctaveBandOneThird.Hz2500,
Hz3150 = data.LAeqOctaveBandOneThird.Hz3150,
Hz4000 = data.LAeqOctaveBandOneThird.Hz4000,
Hz5000 = data.LAeqOctaveBandOneThird.Hz5000,
Hz6300 = data.LAeqOctaveBandOneThird.Hz6300,
Hz8000 = data.LAeqOctaveBandOneThird.Hz8000,
Hz10000 = data.LAeqOctaveBandOneThird.Hz10000,
Hz12500 = data.LAeqOctaveBandOneThird.Hz12500,
Hz16000 = data.LAeqOctaveBandOneThird.Hz16000,
Hz20000 = data.LAeqOctaveBandOneThird.Hz20000,
// 1/1
OOHz16 = data.LAeqOctaveBandOneOne.Hz16,
OOHz31_5 = data.LAeqOctaveBandOneOne.Hz31_5,
OOHz63 = data.LAeqOctaveBandOneOne.Hz63,
OOHz125 = data.LAeqOctaveBandOneOne.Hz125,
OOHz250 = data.LAeqOctaveBandOneOne.Hz250,
OOHz500 = data.LAeqOctaveBandOneOne.Hz500,
OOHz1000 = data.LAeqOctaveBandOneOne.Hz1000,
OOHz2000 = data.LAeqOctaveBandOneOne.Hz2000,
OOHz4000 = data.LAeqOctaveBandOneOne.Hz4000,
OOHz8000 = data.LAeqOctaveBandOneOne.Hz8000,
OOHz16000 = data.LAeqOctaveBandOneOne.Hz16000
};
using (var audioViewEntities = new AudioViewEntities())
{
audioViewEntities.Readings.Add(reading);
await audioViewEntities.SaveChangesAsync();
}
if (isServerDown && OnSQLServerStatusChanged != null)
{
OnSQLServerStatusChanged(false);
}
isServerDown = false;
// Reading ok, try to load offline files
await UploadLocalFiles();
}
catch (Exception exp)
{
logger.Debug(exp, "Got database exception, starting to write offline for \"{0}\".", this.Settings.ProjectName);
WriteOfline(major, time, data, readingGuid);
if (!isServerDown && OnSQLServerStatusChanged != null)
{
OnSQLServerStatusChanged(true);
}
isServerDown = true;
}
}
private string ToCsv(ReadingData d, DateTime time, bool major)
{
StringBuilder b = new StringBuilder();
b.Append(major ? "1" : "0"); b.Append(s);
b.Append(time.ToString("o")); b.Append(s);
b.Append(d.LAeq); b.Append(s);
b.Append(d.LAMax); b.Append(s);
b.Append(d.LAMin); b.Append(s);
b.Append(d.LZMax); b.Append(s);
// One one
b.Append(d.LAeqOctaveBandOneOne.Hz16); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz31_5); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz63); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz125); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz250); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz500); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz1000); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz2000); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz4000); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz8000); b.Append(s);
b.Append(d.LAeqOctaveBandOneOne.Hz16000); b.Append(s);
// One Third
b.Append(d.LAeqOctaveBandOneThird.Hz6_3); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz8); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz10); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz12_5); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz16); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz20); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz25); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz31_5); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz40); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz50); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz63); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz80); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz100); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz125); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz160); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz200); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz250); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz315); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz400); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz500); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz630); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz800); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz1000); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz1250); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz1600); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz2000); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz2500); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz3150); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz4000); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz5000); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz6300); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz8000); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz10000); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz12500); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz16000); b.Append(s);
b.Append(d.LAeqOctaveBandOneThird.Hz20000); b.Append(s);
return(b.ToString());
}
public Task OnSecond(DateTime time, DateTime starTime, ReadingData data, ReadingData minorData, ReadingData majorData)
{
return(Task.FromResult <object>(null));
}
private Task StartRemoveReader()
{
return(Task.Run(async() =>
{
while (run)
{
try
{
TcpClient client = new TcpClient(ip, port);
try
{
OnConnectionStatus(true);
using (StreamReader reader = new StreamReader(client.GetStream(), Encoding.UTF8))
{
CancellationTokenSource token = new CancellationTokenSource();
token.CancelAfter(new TimeSpan(0, 0, 15)); // If no message after 15 sek = disconnected
string line;
while ((line = await reader.ReadLineAsync().WithCancellation(token.Token).ConfigureAwait(false)) != null)
{
if (this.engine == null)
{
continue;
}
if (line.StartsWith(TCPServerListener.TcpMessages.OnMinorResponse.Replace("{0}", "")))
{
var json =
line.Substring(
TCPServerListener.TcpMessages.OnMinorResponse.Replace("{0}", "").Length);
this.lastMinorReading = JsonConvert.DeserializeObject <ReadingData>(json);
// TODO: Fix the next interval time
this.engine.OnMinorInterval(DateTime.Now, DateTime.Now);
}
else if (
line.StartsWith(TCPServerListener.TcpMessages.OnMajorResponse.Replace("{0}", "")))
{
var json =
line.Substring(
TCPServerListener.TcpMessages.OnMajorResponse.Replace("{0}", "")
.Length);
this.lastMajorReading = JsonConvert.DeserializeObject <ReadingData>(json);
// TODO: Fix the next interval time
this.engine.OnMajorInterval(DateTime.Now, DateTime.Now);
}
else if (
line.StartsWith(TCPServerListener.TcpMessages.OnSecondResponse.Replace("{0}", "")))
{
var json =
line.Substring(
TCPServerListener.TcpMessages.OnSecondResponse.Replace("{0}", "")
.Length);
var wrapper = JsonConvert.DeserializeObject <TcpWrapperOnSecond>(json);
this.lastSecondReading = wrapper.Second;
this.engine.OnSecond(DateTime.Now, wrapper.Second, wrapper.Minor, wrapper.Major);
}
token.CancelAfter(new TimeSpan(0, 0, 15));
// If no message after 15 sek = disconnected
}
}
}
catch (Exception exp)
{
OnConnectionStatus(false);
logger.Warn(exp, "Connection to remote device {0}:{1} lost, trying to reconnect.", ip, port);
// Try and close it just to be sure.
try
{
client.Close();
}
catch
{
}
client = new TcpClient(ip, port);
}
}
catch (Exception exp)
{
logger.Error(exp, "Unable to make connection to remote server {0}:{1}.", ip, port);
}
}
OnConnectionStatus(false);
}));
}
public async Task <IActionResult> PostMeterReading([FromBody] ReadingData meterReading)
{
if (meterReading == null)
{
return(BadRequest("Invalid arguments"));
}
if (meterReading.readingValue == default(int))
{
return(BadRequest($"Field {nameof(meterReading.readingValue)} is required"));
}
if (meterReading.readingValue < 0)
{
return(BadRequest($"New value must be > 0"));
}
string meterSn = null;
switch (meterReading.readingType)
{
case "house":
meterSn = await _context.Meter
.Where(i => i.HouseId.ToString() == meterReading.readingIdentifier)
.Select(i => i.SerialNumber)
.FirstOrDefaultAsync();
break;
case "meter":
meterSn = await _context.Meter
.Where(i => i.SerialNumber.ToString() == meterReading.readingIdentifier)
.Select(i => i.SerialNumber)
.FirstOrDefaultAsync();
break;
default:
return(BadRequest($"Invalid argument {meterReading.readingType}"));
}
if (String.IsNullOrEmpty(meterSn))
{
return(BadRequest("Meter not found"));
}
var beforeValue = await _context.MeterReading
.Where(i => i.MeterSerialNumber == meterSn)
.OrderByDescending(i => i.Value)
.Select(i => i.Value)
.FirstOrDefaultAsync();
if (beforeValue > meterReading.readingValue)
{
return(BadRequest($"New value: {nameof(meterReading.readingValue)} less then before value: {beforeValue}"));
}
var reading = new MeterReading {
MeterSerialNumber = meterSn,
ReadingDateTime = DateTime.UtcNow,
Value = meterReading.readingValue
};
await _context.MeterReading.AddAsync(reading);
await _context.SaveChangesAsync();
return(Ok());
}
public virtual void Aggregate(ReadingData other)
{
}
internal abstract void Aggregate(ReadingData other);
public Task OnMajor(DateTime time, DateTime starTime, ReadingData data)
{
throw new NotImplementedException();
}
internal override void Aggregate(ReadingData other)
{
Value += (int)other.GetValue();
}
internal abstract void Aggregate(ReadingData other);
