public void RunSequence(string outFile, List<int> ns, List<double> ps, List<double> alphas, int repeatCount)
{
var m = new Measurements();
var sw = new Stopwatch();
foreach (var alpha in alphas)
{
foreach (var n in ns)
{
for (var x = 0; x < repeatCount; x++)
{
WriteLine(alpha + "a " + 0 + "p " + n);
// create or reset stuff
var sgt = new DataStructures.SGTree<int>(alpha);
var SGTNodes = new List<DataStructures.SGTNode<int>>(n);
for(var i = 1; i < n; i++)
{
SGTNodes.Add(new DataStructures.SGTNode<int>(i));
}
sw.Reset();
sw.Start();
sgt.insertFirst(0);
sw.Stop();
m.Add(n, 0, alpha, sw.ElapsedTicks);
}
}
}
m.WriteToFile(outFile);
}
/// <summary>
/// Creates an instance of <see cref="MeasurementUserControl"/> class.
/// </summary>
/// <param name="deviceID">ID of the device to filter measurements.</param>
public MeasurementUserControl(int deviceID)
{
InitializeComponent();
m_dataContext = new Measurements(deviceID, 17);
m_dataContext.PropertyChanged += new PropertyChangedEventHandler(ViewModel_PropertyChanged);
this.DataContext = m_dataContext;
}
public void ComputeDistance_CoordinateCoordinate_CallsIDistanceCalculatorWithCorrectParameters()
{
Coordinate c1 = new Coordinate(10.1, 20.1);
Coordinate c2 = new Coordinate(10.2, 20.2);
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
Measurements target = new Measurements(calculatorM.Object);
double distance = target.ComputeDistance(c1, c2);
calculatorM.Verify(calc => calc.CalculateDistance(c1, c2), Times.Once());
}
public void ComputeArea_IPolygon_ReturnsAreaOfSimplePolygonCalculatedByIDimensionsCalculator()
{
Polygon polygon = new Polygon(new CoordinateList());
Random generator = new Random();
double expectedArea = generator.Next(100);
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
calculatorM.Setup(calc => calc.CalculateArea(polygon.ExteriorRing)).Returns(expectedArea);
Measurements target = new Measurements(calculatorM.Object);
double area = target.ComputeArea(polygon);
Assert.Equal(expectedArea, area);
}
/// <summary>
/// Метод добавления в коллекцию измерений
/// </summary>
/// <param name="Cur">Ток</param>
public void AddInCollection(double Cur)
{
TextBlockMessageFromServer = " Статус: " + "Идет измерение...";
//Годность
bool valid;
Device b = SelectedDeviceInComboBox as Device;
var Umin = context.GetUmin(b);
var Umax = context.GetUmax(b);
var Unom = context.GetUnom(b);
//Отклонение от номинального значения
var Deviat = Math.Abs(Umax - Umin) / 2;
double Uizm = 0;
//Добавление в коллекцию Oscs и определение наибольшего напряжения
for (int q = 0; q < 1000; q++)
{
double temp = 0;
temp = masVoltageFromServer[q];
if (temp > Uizm)
{
Uizm = temp;
}
Oscs.Add(new Osc()
{
U = masVoltageFromServer[q], T = masVoltageFromServer[q + 1000]
});
}
//Вызов метода построения осциллограмм
LoadData(CounterAmountMeasurement);
//Обновить график
PlotModel.InvalidatePlot(true);
//Вывод измеренного напряжения
TextBlockOfVoltage = Uizm.ToString() + " B";
valid = (Math.Abs(Unom - Uizm) <= Deviat);
//Создание нового экземпляра измерения
var measure = new Measurement {
device = b, NumberSupressor = Convert.ToInt32(TextBoxNumberOfSupressor), Date = DateTime.Now, Fio = TextBlockOfSurnameInMainWindow, Voltage = Uizm, Valid = valid, Current = Cur
};
//Добавление в коллекцию
Measurements.Add(measure);
//В БД
context.AddMeasurementsInDb(measure);
//Сохранение изменений
context.SaveDb();
}
private static void SampleFour()
{
var data = new HistoricalWeatherData();
data["Chicago", new DateTime(1970, 6, 6)] = new Measurements
{
HiTemp = 75,
LoTemp = 58,
AirPressure = 30.2
};
var item = data["Chicago", new DateTime(1970, 6, 6)];
Console.WriteLine(item.HiTemp);
item = data["Chicago", new DateTime(1970, 6, 6, 12, 30, 2)];
Console.WriteLine(item.LoTemp);
data["Chicago", new DateTime(1970, 6, 6)] = new Measurements
{
HiTemp = 85,
LoTemp = 38,
AirPressure = 30.2
};
item = data["Chicago", new DateTime(1970, 6, 6)];
Console.WriteLine(item.HiTemp);
item = data["Chicago", new DateTime(1970, 6, 6, 12, 30, 2)];
Console.WriteLine(item.LoTemp);
try
{
item = data["New York", new DateTime(1980, 5, 12)];
Console.WriteLine("Didn't get expected exception");
}
catch (ArgumentOutOfRangeException)
{
}
try
{
item = data["Chicago", new DateTime(1980, 5, 12)];
Console.WriteLine("Didn't get expected exception");
}
catch (ArgumentOutOfRangeException)
{
}
}
public static string MeasureMedian(List<int> ns, int numberMin, int numberMax, int repeatCount)
{
var random = new Random(DateTime.Now.Millisecond);
var sw = new Stopwatch();
var measurements = new Measurements(ns.Count);
foreach (var n in ns)
{
var currentMeasurement = measurements.Add(n);
for (var i = 0; i < repeatCount; i++)
{
var l1 = new List<int>(n);
var middle = n/2;
for(var x = 0; x < n; x++)
l1.Add(random.Next(numberMin, numberMax));
var l2 = new List<int>(l1);
var l3 = new List<int>(l1);
sw.Start();
var mom = l1.Mom(middle, Comparer<int>.Default);
sw.Stop();
var t1 = sw.Elapsed.Ticks;
sw.Reset();
sw.Start();
var momRandom = l2.MomRandom(middle, Comparer<int>.Default);
sw.Stop();
var t2 = sw.Elapsed.Ticks;
sw.Reset();
sw.Start();
var quickSelect = l3.QuickSelect(middle, Comparer<int>.Default);
sw.Stop();
var t3 = sw.Elapsed.Ticks;
sw.Reset();
currentMeasurement.sum(t1, t2, t3);
}
}
measurements.UpdateStats();
return measurements.ToString();
}
public bool IsIngedientAvailable(Ingredient i, ProductDetails p, int numberOfPersons = 1)
{
if (numberOfPersons < 1)
{
numberOfPersons = 1;
}
bool productHasSameMeasurementClass = p.ProductQuantities.Any(pq => Measurements.GetMeasurementClassForEUnitQuantityType(pq.MeasurementType) == Measurements.GetMeasurementClassForEUnitQuantityType(i.UnitQuantityType));
if (!productHasSameMeasurementClass || p.MeasurementAmounts == null)
{
return(false);
}
var totalAmountOfProduct = p.MeasurementAmounts.GetTotalAmount(i.UnitQuantityType);
return(totalAmountOfProduct >= i.UnitQuantity * numberOfPersons);
}
public void ComputeArea_IMultiPolygon_ReturnsSumOfPolygonAreas()
{
Random generator = new Random();
Polygon polygon = new Polygon(new CoordinateList());
double polygonArea = generator.Next(100);
MultiPolygon multipolygon = new MultiPolygon(new Polygon[] { polygon, polygon });
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
calculatorM.Setup(calc => calc.CalculateArea(polygon.ExteriorRing)).Returns(() => polygonArea);
Measurements target = new Measurements(calculatorM.Object);
double area = target.ComputeArea(multipolygon);
Assert.Equal(2 * polygonArea, area);
}
public void CalculateGravity(Planet planet1, Planet planet2, GameTime gameTime)
{
Vector2 distanceVector = Measurements.GetDistanceVector(planet1, planet2);
float distanceSqared = distanceVector.LengthSquared();
if (distanceSqared == 0)
return;
float acceleration = GravityConstantKilometerTonns * GameGlobals.SimulationSpeedMuliplicator / distanceSqared * (float)gameTime.ElapsedGameTime.TotalSeconds;
distanceVector.Normalize();
distanceVector *= acceleration;
planet1.Direction += distanceVector * planet2.Mass;
planet2.Direction -= distanceVector * planet1.Mass;
}
private static void TestItems(out Installation installation1, out Installation installation2,
out Measurements measurements1, out Measurements measurements2, out Address address1,
out Address address2)
{
var value1 = new Value("PM1", 13.61);
var value2 = new Value("PM25", 19.76);
var value3 = new Value("PM10", 29.29);
var value4 = new Value("PM25", 30.30);
address1 = new Address("Poland", "Kraków", "Mikołajska");
address2 = new Address("Poland", "Warszawa", "Some random street");
measurements1 = new Measurements(new Current(
"2020-04-08T07:31:50.230Z", "2020-04-08T08:31:50.230Z",
new List <Value> {
value1, value2
},
new List <Index>
{
new Index("AIRLY_CAQI", 37.52, "LOW", "Air is quite good.",
"Don't miss this day! The clean air calls!", "#D1CF1E")
},
new List <Standard> {
new Standard("WHO", "PM25", 25.0, 79.05)
}));
measurements2 = new Measurements(new Current(
"2020-04-08T07:31:50.230Z", "2020-04-08T08:31:50.230Z",
new List <Value> {
value3, value4
},
new List <Index>
{
new Index("AIRLY_CAQI", 37.52, "LOW", "Air is quite good.",
"Don't miss this day! The clean air calls!", "#D1CF1E")
},
new List <Standard> {
new Standard("WHO", "PM25", 25.0, 79.05)
}));
installation1 = new Installation(8077, new Location(50.062006, 19.940984),
address1);
installation2 = new Installation(8078, new Location(59.062006, 29.940984),
address2);
}
public void TestB()
{
Map map = new Map();
map.Init(3, 3);
map.cells [1, 1] = 1; //all the rest are zero.
Measurement m = new Measurement(1, 0, -1);
Measurements ma = new Measurements();
ma.Init(1);
ma.m.Add(m);
List <Vector2> moves = new List <Vector2>();
moves.Add(Vector2.zero);
Test(map, ma, moves, 1, 2);
}
public void Run(string outFile, List <int> ns, List <double> ps, List <double> alphas, int repeatCount)
{
var m = new Measurements();
var random = new Random(DateTime.Now.Millisecond);
var sw = new Stopwatch();
foreach (var alpha in alphas)
{
foreach (var p in ps)
{
foreach (var n in ns)
{
for (var x = 0; x < repeatCount; x++)
{
WriteLine(alpha + "a " + p + "p " + n);
// create or reset stuff
var sgt = new DataStructures.SGTree <int>(alpha);
var SGTNodes = new List <DataStructures.SGTNode <int> >(n);
sw.Reset();
sw.Start();
var prev = sgt.insertFirst(0);
SGTNodes.Add(prev);
for (var i = 0; i < n; i++)
{
// sequential probability
if (random.Next(0, 100) / 100.0 < p)
{
prev = sgt.insertAfter(prev, i);
SGTNodes.Add(prev);
}
else
{
var at = random.Next(0, i);
prev = sgt.insertAfter(SGTNodes[at], i);
SGTNodes.Add(prev);
}
}
sw.Stop();
m.Add(n, p, alpha, sw.ElapsedTicks);
}
}
}
}
m.WriteToFile(outFile);
}
public void Run(string outFile, List<int> ns, List<double> ps, List<double> alphas, int repeatCount)
{
var m = new Measurements();
var random = new Random(DateTime.Now.Millisecond);
var sw = new Stopwatch();
foreach (var alpha in alphas)
{
foreach(var p in ps)
{
foreach (var n in ns)
{
for(var x = 0; x < repeatCount; x++)
{
WriteLine(alpha + "a " + p + "p " + n);
// create or reset stuff
var sgt = new DataStructures.SGTree<int>(alpha);
var SGTNodes = new List<DataStructures.SGTNode<int>>(n);
sw.Reset();
sw.Start();
var prev = sgt.insertFirst(0);
SGTNodes.Add(prev);
for (var i = 0; i < n; i++)
{
// sequential probability
if (random.Next(0, 100) / 100.0 < p)
{
prev = sgt.insertAfter(prev, i);
SGTNodes.Add(prev);
}
else
{
var at = random.Next(0, i);
prev = sgt.insertAfter(SGTNodes[at], i);
SGTNodes.Add(prev);
}
}
sw.Stop();
m.Add(n, p, alpha, sw.ElapsedTicks);
}
}
}
}
m.WriteToFile(outFile);
}
public ReconstitutedColdKitViewModel(DataStoreItem item) : base(item)
{
InsertQCAnalysisCommand = new RelayCommand(CreatQCAnalysis);
AddQCMeasurementCommand = new RelayCommand(AddQCMeasurement);
if ((Item as ReconstitutedColdKit).QCAnalysis != null)
{
QCExists = true;
}
if ((Item as ReconstitutedColdKit).QCAnalysis != null)
{
foreach (RadiochemicalPurityMeasurement m in ((Item as ReconstitutedColdKit).QCAnalysis.Measurements))
{
Measurements.Add(m);
}
}
}
public void Draw(CommandLink ctrl, PushButtonState state, PaintEventArgs e)
{
var m = new Measurements(ctrl, state, e.Graphics);
e.Graphics.Clear(ctrl.Parent.BackColor);
var gp = new GraphicsPath();
gp.AddRoundedRectPath(m.client, new Size(rndRectRadius, rndRectRadius));
e.Graphics.FillPath(m.dp.Fill, gp);
e.Graphics.DrawPath(m.dp.Line, gp);
e.Graphics.DrawImage(m.img, m.imgRect);
TextRenderer.DrawText(e.Graphics, ctrl.Text, largeFont, m.txtRect, m.dp.Text, m.tff);
if (m.noteRect.Size != SizeF.Empty)
{
TextRenderer.DrawText(e.Graphics, ctrl.NoteText, smallFont, m.noteRect, m.dp.Text, m.tff);
}
}
private void LoadDataFiles()
{
if (!Directory.Exists(SourceFolder))
{
throw new DirectoryNotFoundException($"Directory not found: {SourceFolder}");
}
var files = Directory.GetFiles(SourceFolder);
foreach (var file in files)
{
var measurement = new Measurement();
measurement.Init(file);
Measurements.Add(measurement);
}
}
public async Task download_for_some_installations_when_some_data_is_out_of_date()
{
// Arrange
const short numberOfDays = 1;
var downloadedData = new Measurements();
var installationIds = new List <short>();
var startDate = DateTime.UtcNow.AddHours(-(2 * _minNumberOfMeasurements));
for (int i = 0; i < _installationIds.Count; i++)
{
_context.AddMeasurementsToDatabase(
_installationIds[i], startDate, numberOfDays, _minNumberOfMeasurements);
if (i % 2 == 0)
{
_context.AddMeasurementsToDatabase(
_installationIds[i],
startDate.AddHours(_minNumberOfMeasurements),
numberOfDays,
_minNumberOfMeasurements);
}
else
{
_downloaderMock.Setup(x => x.DownloadAirQualityData(_installationIds[i]))
.ReturnsAsync(downloadedData);
}
}
var programController = new ProgramController(
unitOfWork: _unitOfWork,
installationIds: _installationIds,
airlyMeasurementsDownloader: _downloaderMock.Object,
minNumberOfMeasurements: _minNumberOfMeasurements);
// Act
var newMeasurementsList
= await programController.DownloadAllAirQualityData();
// Assert
_downloaderMock.Verify(
x => x.DownloadAirQualityData(It.IsAny <short>()),
Times.Exactly((int)Math.Ceiling((double)_installationIds.Count / 2)));
}
public async Task <IActionResult> UpdateCustomer([FromBody] Measurements measurements)
{
try
{
if (measurements != null && measurements.UserId != Guid.Empty && measurements.UserId != null)
{
var customerProfile = await MeasurementsHandler.UpsertMeasurements(measurements);
return(Ok(customerProfile));
}
return(StatusCode(404));
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
return(StatusCode(505, ex.Message));
}
}
public void ComputeLength_LineString_RetursSumOfSegmentsLengths()
{
Random generator = new Random();
double segment1Length = generator.Next(100);
double segment2Length = generator.Next(100);
double sum = segment1Length + segment2Length;
LineString linestring = new LineString(new Coordinate[] { new Coordinate(10.1, 20.1), new Coordinate(10.2, 20.2), new Coordinate(10.3, 20.3) });
Mock <IDimensionsCalculator> calculatorM = new Mock <IDimensionsCalculator>();
calculatorM.Setup(calc => calc.CalculateDistance(linestring.Coordinates[0], linestring.Coordinates[1])).Returns(segment1Length);
calculatorM.Setup(calc => calc.CalculateDistance(linestring.Coordinates[1], linestring.Coordinates[2])).Returns(segment2Length);
Measurements target = new Measurements(calculatorM.Object);
double length = target.ComputeLength(linestring);
Assert.Equal(sum, length);
}
public void ComputeArea_IMultiPolygon_ReturnsSumOfPolygonAreas()
{
Random generator = new Random();
Polygon polygon = new Polygon(new CoordinateList());
double polygonArea = generator.Next(100);
MultiPolygon multipolygon = new MultiPolygon(new Polygon[] { polygon, polygon });
Mock <IDimensionsCalculator> calculatorM = new Mock <IDimensionsCalculator>();
calculatorM.Setup(calc => calc.CalculateArea(polygon.ExteriorRing)).Returns(() => polygonArea);
Measurements target = new Measurements(calculatorM.Object);
double area = target.ComputeArea(multipolygon);
Assert.Equal(2 * polygonArea, area);
}
protected override Measurements MeasureOverride(Size availableSize)
{
elementMap.Clear();
var ms = new Measurements();
foreach (var element in Elements)
{
var elementMs = element.Measure(availableSize);
foreach (var measurement in elementMs)
{
measurement.Flexible = Flexible;
elementMap[measurement] = element;
ms.Add(measurement);
}
if (elementMs.Count > 0)
{
elementMs[^ 1].PagebreakPenalty = double.PositiveInfinity;
public void clearAllTables()
{
Groups.RemoveRange(Groups);
AnswersByPhone.RemoveRange(AnswersByPhone);
//Rooms.RemoveRange(Rooms);
//Teachers.RemoveRange(Teachers);
MeasureInstructionsData.RemoveRange(MeasureInstructionsData);
OneMeasuresEvalData.RemoveRange(OneMeasuresEvalData);
OneMeasuresByGroupId.RemoveRange(OneMeasuresByGroupId);
MeasurementsByGroupId.RemoveRange(MeasurementsByGroupId);
Measurements.RemoveRange(Measurements);
ActiveExperiments.RemoveRange(ActiveExperiments);
Experiments.RemoveRange(Experiments);
Activities.RemoveRange(Activities);
ActivityLogs.RemoveRange(ActivityLogs);
//Students.RemoveRange(Students);
SaveChanges();
}
public PagedResult <KeyValuePair <DateTime, IList <ReadingViewModel> > > GetReadingsPaged(ReadingsQuery query)
{
var datesPaged = Readings.Where(r => r.Measurement.Id == query.MeasurementId &&
(query.FromTime == null || r.ReadingTime >= query.FromTime) &&
(query.ToTime == null || r.ReadingTime <= query.ToTime) &&
(query.NewerThan == null || r.ReadingTime > query.NewerThan))
.OrderByIf(r => r.ReadingTime, () => query.Ascending)
.Select(r => r.ReadingTime)
.Distinct()
.GetPaged(query.Page, query.PageSize);
var dates = datesPaged.Results;
// Make sure readings get SensorRole and Calculator loaded automatically
// It's practically caching them for grouping query
var measurement = Measurements.Include(m => m.SensorRoles)
.Include(m => m.Calculators)
.FirstOrDefault(m => m.Id == query.MeasurementId);
var grouped = Readings.Where(r =>
(r.Measurement.Id == query.MeasurementId) &&
(dates == null || dates.Contains(r.ReadingTime))
)
.OrderByIf(r => r.ReadingTime, () => query.Ascending)
.ToList()
.AsQueryable()
.ProjectTo <ReadingViewModel>()
.GroupBy(r => r.ReadingTime)
.Select(g => new KeyValuePair <DateTime, IList <ReadingViewModel> > (
g.Key,
g.OrderBy(r => r.Name).ToList()
))
.ToList();
var result = new PagedResult <KeyValuePair <DateTime, IList <ReadingViewModel> > >();
result.CurrentPage = datesPaged.CurrentPage;
result.PageCount = datesPaged.PageCount;
result.PageSize = datesPaged.PageSize;
result.RowCount = datesPaged.RowCount;
result.Results = grouped;
return(result);
}
public void _020_HandlesLessThenMinimum()
{
var m = new Measurements(10);
var mock = new Mock <EcoFriendly>(MockBehavior.Strict, null, m, null)
{
CallBase = true
};
mock.SetupGet(p => p.MinimumDataPoints).Returns(10);
mock.Setup(p => p.Get()).CallBase();
m.BufferSeconds = mock.Object.MinimumDataPoints;
for (int i = 0; i < mock.Object.MinimumDataPoints - 1; i++)
{
m.AddData(10, 0, 0, 10, 0, 0);
}
mock.Object.Get().Should().Be((-1, -1, -1), "there are no or not enough samples");
}
public MainPage(string pathForFiles)
{
InitializeComponent();
MasterBehavior = MasterBehavior.Popover;
easeMeasurements = new EaseMeasurements();
easeMeasurements.RetrieveMeasurments();
measurements = new Measurements(easeMeasurements);
measurements.RetrieveMeasurments();
PatternPage page = new PatternPage(pathForFiles, measurements)
{
BindingContext = ((MenuPage)Master).MenuItems[0]
};
menuPages.Add(MenuItemType.Pattern, new NavigationPage(page));
Detail = menuPages[MenuItemType.Pattern];
}
public void TestFindMeasurementById(int id)
{
Measurements m = measurementDao.FindMeasurementById(id);
if (m != null)
{
Console.WriteLine($"FindMeasurementById({id}) -> Station: {m.Station,5} " +
$"| Airtemperature: {m.Airtemperature,-10} | " +
$"Airpressure: {m.Airpressure,5} | " +
$"Rainfall: {m.Rainfall,-10} | " +
$"Humidity: {m.Humidity,-10} | " +
$"WindSpeed: {m.WindSpeed,5} | " +
$"WindDirection: {m.WindDirection,-10} | " +
$"Timestamp: {m.Timestamp,-10}");
}
else
{
Console.WriteLine($"FindAllMeasurementsById({id}) -> null");
}
}
public Page(int startingIndex, int length)
{
this.startingIndex = startingIndex;
this.length = length;
lastAccess = DateTime.Now;
// This stays as random stuff:
var generator = new Random();
for (int i = 0; i < length; i++)
{
var m = new Measurements
{
HiTemp = generator.Next(50, 95),
LoTemp = generator.Next(12, 49),
AirPressure = 28.0 + generator.NextDouble() * 4
};
pageData.Add(m);
}
}
public void _030_Test2()
{
var m = new Measurements(10);
ChargingStateMachine state = new();
var mock = new Mock <EcoFriendly>(MockBehavior.Strict, null, m, state)
{
CallBase = true
};
mock.SetupGet(p => p.MinimumDataPoints).Returns(10);
mock.Setup(p => p.Get()).CallBase();
m.BufferSeconds = mock.Object.MinimumDataPoints;
for (int i = 0; i < mock.Object.MinimumDataPoints; i++)
{
m.AddData(-12.0, 0.62, 0.40, 0, 0, 0);
}
mock.Object.Get().Should().Be((10.83f, 0, 0));
}
protected void doFit(Measurements hi, Measurements med, Measurements low)
{
double[] voltageX = { Vhi.setting, Vmed.setting, Vlow.setting };
double[] voltageY = { Vhi.average, Vmed.average, Vlow.average };
Tuple <double, double> fitParams = Fit.Line(voltageX, voltageY);
gain = fitParams.Item2;
offset = fitParams.Item1;
gainInt = (UInt16)(fitParams.Item2 * 32768);
// offsetInt is a 12-bit 2's compliment integer.
// The sign needs to be reversed for it to be applied correctly.
if (offset >= 0)
{
offsetInt = (UInt16)(fitParams.Item1 * 50);
}
else
{
offsetInt = (UInt16)(4096 - fitParams.Item1 * 50);
}
}
public void ComputeArea_IPolygon_ReturnsAreaOfPolygonWithoutHolesCalculatedByIDimensionsCalculator()
{
Random generator = new Random();
Polygon polygon = new Polygon(new CoordinateList());
polygon.InteriorRings.Add(new CoordinateList());
double exteriorArea = generator.Next(100) + 10;
double interiorArea = generator.Next(10);
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
calculatorM.Setup(calc => calc.CalculateArea(polygon.ExteriorRing)).Returns(exteriorArea);
calculatorM.Setup(calc => calc.CalculateArea(polygon.InteriorRings[0])).Returns(interiorArea);
Measurements target = new Measurements(calculatorM.Object);
double area = target.ComputeArea(polygon);
Assert.Equal(exteriorArea - interiorArea, area);
}
public void ShouldReturnVmItems2()
{
var value1 = new Value("PM1", 13.61);
var value2 = new Value("PM25", 19.76);
var measurements1 = new Measurements(new Current(
"2020-04-08T07:31:50.230Z", "2020-04-08T08:31:50.230Z",
new List <Value> {
value1, value2
},
new List <Index>
{
new Index("AIRLY_CAQI", 37.52, "LOW", "Air is quite good.",
"Don't miss this day! The clean air calls!", "#D1CF1E")
},
new List <Standard> {
new Standard("WHO", "PM25", 25.0, 79.05)
}));
var address1 = new Address("Poland", "Kraków", "Mikołajska");
var installation1 = new Installation(8077, new Location(50.062006, 19.940984),
address1);
HomeModel.FetchVmItems.Apply(i => (measurements1, installation1))
.Apply(location => new List <Installation> {
installation1
})
(new Location(50.062006, 19.940984))
.Match(error => Assert.Fail("Should not return error"), tuple =>
{
var(errors, measurementVmItems) = tuple;
//then
Assert.IsEmpty(errors);
Assert.AreEqual(1, measurementVmItems.Count);
Assert.AreEqual(installation1, measurementVmItems.First().Installation);
Assert.AreEqual(measurements1, measurementVmItems.First().Measurements);
Assert.AreEqual(address1.city, measurementVmItems.First().City);
Assert.AreEqual(address1.country, measurementVmItems.First().Country);
Assert.AreEqual(address1.street, measurementVmItems.First().Street);
});
}
public void Run()
{
var filter = new UKF(1, 1);
n = 1;
q = 0.05;
r = 0.3;
N = 100;
Q = Matrix.Build.Diagonal(n, n, q * q); //covariance of process
NotifyChanged("Q");
R = Matrix.Build.Dense(1, 1, r * r); //covariance of measurement
f = new FEquation(); //nonlinear state equations
h = new HEquation(); //measurement equation
x = q * Matrix.Build.Random(1, 1); //s + q * Matrix.Build.Random(1, 1); //initial state with noise
P = Matrix.Build.Diagonal(n, n, 1); //initial state covariance
var xV = Matrix.Build.Dense(n, N, 0); //Estimate
var zV = Matrix.Build.Dense(1, N, 0); //measurement
for (int k = 1; k < N; k++)
{
Matrix <double> z = ProcessBuilder.SineWave(k, r);
//measurments
Matrix <double>[] x_and_P = filter.Update(f, x, P, h, z, Q, R); //ukf
x = x_and_P[0];
P = x_and_P[1];
Measurements.Add(new Measurement()
{
Value = z[0, 0], Time = TimeSpan.FromSeconds(k)
});
Estimates.Add(new Measurement()
{
Value = x_and_P[0][0, 0], Time = TimeSpan.FromSeconds(k), Variance = x_and_P[1][0, 0]
});
}
}
private static void ObserverThread()
{
try
{
var device = new USBM();
if (!device.OpenDevice())
{
throw new Exception("Could not open device.");
}
while (true)
{
var volts = device.GetMeasuredValue();
if (volts == 0.0f)
{
throw new Exception("Value read from device was zero. This indicates the device may not be working. Restarting to try to recover.");
}
var ppmPerVolt = 197.5f; // Experimentally determined - looks perfectly linear.
var ppm = (int)(volts * ppmPerVolt);
Measurements.Inc();
Volts.Set(volts);
Ppm.Set(ppm);
Console.WriteLine($"{volts:#00.000} V\t\t{ppm} PPM");
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
catch (Exception ex)
{
// Oh no! This is fatal error.
Console.WriteLine(ex.ToString());
Console.WriteLine("Will restart after sleeping for a while.");
Thread.Sleep(TimeSpan.FromSeconds(30));
Process.GetCurrentProcess().Kill();
}
}
/// <summary>
/// Проверить, подходит ли данное устройство для места учёта и управления - покрывает ли оно
/// те измерения и управляющиее воздействия, которые необходимы на месте учёта.
/// На данный момент сделано допущение, что устройство покрывает более или столько же измерений,
/// или управляющих воздействий, сколько требуется на месте учёта и управления.
/// </summary>
/// <param name="mcz">Место учёта и управления.</param>
/// <returns>True, если подходит.</returns>
public bool IsSuitableForMCZ(MeasurementAndControlZone mcz)
{
try
{
var measurementsResult = mcz.Measurements != null && mcz.Measurements.Any()
? Measurements != null && Measurements.Any() && mcz.Measurements.All(m => Measurements.Contains(m)) // Устройство подхдит, если содержит все измерения места
: true; // Если нет измерений на месте, то устройство автоматически подходит
var controlsResult = mcz.Controls != null && mcz.Controls.Any()
? Controls != null && Controls.Any() && mcz.Controls.All(c => Controls.Contains(c)) // Устройство подхдит, если поддерживает все управляющие воздействия места
: true; // Если воздействий на месте не требуется, то устройство автоматически подходит
return(measurementsResult && controlsResult);
}
catch (Exception ex)
{
Console.WriteLine("IsSuitableForMCZ failed! {0}", ex.Message);
return(false);
}
}
public void Measure()
{
var boxSize = Variable(PageVariables.BoxSize);
// In order to add the measurements in the correct order
// we save them temporarily in an array
Measurement[] measurements = new Measurement[Elements.Count];
Parallel.ForEach(Elements, (e, _, i) =>
{
e.Document = this;
measurements[i] = e.Measure(boxSize);
});
Measurements.AddRange(measurements);
foreach (var element in PageItems)
{
element.Document = this;
}
}
public void ShouldDeserializeMeasurement()
{
var json = Responses.MeasurementsJsonResponseShorter;
var result = TestUtilities.GetValueFromEither(Network.DeserializeMeasurements(json));
var expected = new Measurements(new Current(
"2020-04-08T07:31:50.230Z", "2020-04-08T08:31:50.230Z",
new List <Value> {
new Value("PM1", 13.61), new Value("PM25", 19.76)
},
new List <Index>
{
new Index("AIRLY_CAQI", 37.52, "LOW", "Air is quite good.",
"Don't miss this day! The clean air calls!", "#D1CF1E")
},
new List <Standard> {
new Standard("WHO", "PM25", 25.0, 79.05)
}));
Assert.AreEqual(expected, result);
}
public void Measure()
{
PageSize = Variables["page"]["size"].GetValue <Size>();
PageMargin = Variables["page"]["margin"].GetValue <Thickness>();
PageBoxSize = new Size(PageSize.Width - PageMargin.Width, PageSize.Height - PageMargin.Height);
foreach (var element in Elements.AsParallel())
{
element.Document = this;
var elementSize = PageBoxSize;
elementSize.Height -= element.Margin.Height;
elementSize.Width -= element.Margin.Width;
Measurements.AddInternal(element.Measure(elementSize));
}
foreach (var element in PageItems)
{
element.Document = this;
}
}
public void ComputeDistance_PointMultiLineString_ReturnsNaNIfPointIsEmpty()
{
Point point = new Point(Coordinate.Empty);
LineString linestring = new LineString(new Coordinate[] { new Coordinate(10.1, 20.1), new Coordinate(10.2, 20.2), new Coordinate(10.3, 20.3) });
MultiLineString multilinestring = new MultiLineString(new LineString[] { linestring, linestring });
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
Measurements target = new Measurements(calculatorM.Object);
double distance = target.ComputeDistance(point, multilinestring);
Assert.True(double.IsNaN(distance));
}
public void ComputeDistance_PointPoint_ReturnsNaNIfPoint2IsEmpty()
{
Point p1 = new Point(new Coordinate(10.1, 20.1));
Point p2 = new Point(Coordinate.Empty);
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
Measurements target = new Measurements(calculatorM.Object);
double distance = target.ComputeDistance(p1, p2);
Assert.True(double.IsNaN(distance));
}
public void ComputeDistance_PointPoint_CallsIDistanceCalculatorWithCorrectParameters()
{
Point p1 = new Point(new Coordinate(10.1, 20.1));
Point p2 = new Point(new Coordinate(10.2, 20.2));
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
Measurements target = new Measurements(calculatorM.Object);
double distance = target.ComputeDistance(p1, p2);
calculatorM.Verify(calc => calc.CalculateDistance(p1.Position, p2.Position), Times.Once());
}
//-------------------------------------------------------------------------------------------------//
protected override bool ExecuteStarting()
{
const string STRLOG_MethodName = "ExecuteStarting";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
string logMessage;
//
// Get the time now to determine how long execution actually takes
//
DateTime startDateTime = DateTime.Now;
//
// Calculate execution completion time
//
int executionTimeRemaining = 0;
executionTimeRemaining += this.executionTimes.start;
executionTimeRemaining += this.executionTimes.run;
executionTimeRemaining += this.executionTimes.stop;
executionTimeRemaining += this.executionTimes.finalise;
this.executionCompletionTime = DateTime.Now + TimeSpan.FromSeconds(executionTimeRemaining);
Logfile.Write(
String.Format(STRLOG_ExecutionTimeRemaining_arg, executionTimeRemaining));
//
// Create the data structure for storing the measurements
//
this.measurements = new Measurements();
//
// Initialise state machine
//
this.lastError = null;
int increaseSyncFieldCount = 0;
double currentSpeed = 0;
int measurementCount = 0;
Measurement[] measurementArray = new Measurement[this.configParameters.simpleMovingAverage + 1];
int synchronismRetries = 3;
States state = States.CheckStatus;
//
// State machine loop
//
while (state != States.Done)
{
bool status = false;
double value = 0;
string units = String.Empty;
Trace.WriteLine("state: " + state.ToString());
switch (state)
{
case States.CheckStatus:
//
// Check machine status before continuing
//
if ((success = this.CheckStatus()) == true)
{
state = States.EnableDCDrive;
}
else
{
// this.lastError already updated
}
break;
case States.EnableDCDrive:
//
// Enable the DC drive
//
if ((success = this.plc.EnableDCDrive(true)) == true)
{
state = States.StartDCDrive;
}
else
{
this.lastError = this.plc.LastError;
}
break;
case States.StartDCDrive:
//
// Start the DC drive
//
int speed = this.configParameters.speed;
if ((success = this.dcDrive.StartSpeedMode(speed)) == true)
{
currentSpeed = this.dcDrive.SpeedSetpoint;
state = States.CheckDCDriveStatus;
}
else
{
this.lastError = this.dcDrive.LastError;
}
break;
case States.CheckDCDriveStatus:
//
// Check the DC drive status
//
if ((success = this.plc.GetDCDriveStatus(ref status)) == true && status == true)
{
state = States.EnableSyncField;
}
else
{
this.lastError = this.plc.LastError;
}
break;
case States.EnableSyncField:
//
// Enable the sync field
//
if ((success = this.plc.EnableSyncField(true)) == true)
{
state = States.IncreaseSyncField;
}
else
{
this.lastError = this.plc.LastError;
}
break;
case States.IncreaseSyncField:
//
// Check if maximum sync field incease count has been reached - should not happen
//
if ((success = (++increaseSyncFieldCount < this.configParameters.maxSyncFieldIncreases)) == true)
{
//
// Increase the sync. machine field by one increment
//
if ((success = (this.plc.IncreaseSyncField(ref status) == true && status == true)) == true)
{
state = States.CheckSyncFieldCurrent;
}
else
{
this.lastError = STRLOG_UnableToIncreaseFieldCurrent + this.plc.LastError;
}
}
else
{
this.lastError = STRERR_MaxSyncFieldIncreasesReached + increaseSyncFieldCount.ToString();
}
break;
case States.CheckSyncFieldCurrent:
//
// Get the sync field current
//
if ((success = this.plc.GetSyncFieldCurrent(ref value, ref units)) == true)
{
Logfile.Write(String.Format(STRLOG_FieldCurrentValueUnits_Fmt, value, units));
//
// Check if the maximum field current has been reached
//
if ((success = (value < this.configParameters.maxFieldCurrent)) == true)
{
state = States.TakeMeasurementsForVoltages;
}
else
{
//
// Maximum field current has been reached
//
this.lastError = STRERR_MaxFieldCurrentReached + value.ToString();
}
}
else
{
this.lastError = this.plc.LastError;
}
break;
case States.TakeMeasurementsForVoltages:
//
// Take measurements, only need one
//
if ((success = this.TakeMeasurements(state, ref measurementArray[0])) == true)
{
state = States.CheckSyncMainsVoltages;
}
else
{
// this.lastError already updated
}
break;
case States.CheckSyncMainsVoltages:
//
// Check if the sync voltage is at or above the mains voltage
//
if (measurementArray[0].syncVoltage < measurementArray[0].mainsVoltage)
{
//
// Required sync voltage not reached yet
//
state = States.IncreaseSyncField;
}
else
{
//
// Required sync voltage has been reached, all done here
//
logMessage = STRLOG_SyncVoltageAboveMainsVoltage;
Logfile.Write(logMessage);
Trace.WriteLine(logMessage);
state = States.EnableSyncCheck;
}
break;
case States.EnableSyncCheck:
//
// Enable the sync check
//
if ((success = this.plc.EnableSyncCheck(true)) == true)
{
state = States.TakeMeasurementsForSynchronism;
}
else
{
this.lastError = this.plc.LastError;
}
break;
case States.TakeMeasurementsForSynchronism:
//
// Take measurements
//
if ((success = this.TakeMeasurements(state, ref measurementArray[measurementCount])) == true)
{
//
// Check if the synchronism window is open
//
if (measurementArray[measurementCount].syncMainsPhase > this.configParameters.phaseSynchronismLow &&
measurementArray[measurementCount].syncMainsPhase < this.configParameters.phaseSynchronismHigh)
{
//
// Try to synchronise to mains
//
measurementCount = 0;
state = States.TrySynchronism;
}
else
{
//
// Check if there are enough measurements to get an average phase change
//
if (++measurementCount >= this.configParameters.simpleMovingAverage + 1)
{
measurementCount = 0;
state = States.CheckSpeedForSynchronism;
}
else
{
//
// Wait before taking measurements again
//
this.WaitDelay(1);
}
}
}
else
{
// this.lastError already updated
}
break;
case States.CheckSpeedForSynchronism:
//
// Calculate the average phase change from the measurements
//
double syncMainsPhaseChange = 0;
for (int i = 0; i < this.configParameters.simpleMovingAverage; i++)
{
double currentPhase = measurementArray[i + 1].syncMainsPhase;
double previousPhase = measurementArray[i].syncMainsPhase;
double phaseDifference = PhaseDifference(previousPhase, currentPhase);
syncMainsPhaseChange += phaseDifference;
//Trace.WriteLine(string.Format("i: {0} - curr: {1:f01} - prev: {2:f01} - diff: {3:f01}", i, currentPhase, previousPhase, phaseDifference));
}
syncMainsPhaseChange /= this.configParameters.simpleMovingAverage;
Trace.WriteLine("syncMainsPhaseChange: " + syncMainsPhaseChange.ToString("f0"));
//
// Compare the average phase change with the limits and adjust the speed if necessary
//
if (syncMainsPhaseChange < this.configParameters.phaseChangeLimitLow)
{
//
// Phase change is too low, need to increase the speed
//
currentSpeed += 0.5;
}
else if (syncMainsPhaseChange > this.configParameters.phaseChangeLimitHigh)
{
//
// Phase change is too high, need to decrease the speed
//
currentSpeed -= 0.5;
}
else
{
//
// No change in speed required
//
state = States.TakeMeasurementsForSynchronism;
break;
}
//
// Check if the current speed is out of range
//
if ((success = currentSpeed <= this.configParameters.speed + this.configParameters.speedTrimHigh) == false)
{
this.lastError = STRERR_MaxSpeedTrimReached + currentSpeed.ToString();
}
else if ((success = currentSpeed >= this.configParameters.speed - this.configParameters.speedTrimLow) == false)
{
this.lastError = STRERR_MinSpeedTrimReached + currentSpeed.ToString();
}
else
{
//
// Change the DC drive speed
//
if ((success = this.dcDrive.ChangeSpeed(currentSpeed)) == true)
{
state = States.TakeMeasurementsForSynchronism;
}
else
{
this.lastError = this.dcDrive.LastError;
}
}
break;
case States.TrySynchronism:
//
// Get synchronism status
//
if ((success = this.plc.GetSynchronismStatus(ref status)) == true)
{
if (status == true)
{
//
// We are now in synchronism, attempt to close the contactor
//
if ((success = this.plc.CloseContactorA(ref status)) == true)
{
if (status == true)
{
//
// Synchronism successful
//
state = States.InSynchronism;
}
else
{
//
// Retry synchronism
//
if (--synchronismRetries > 0)
{
state = States.TakeMeasurementsForSynchronism;
}
else
{
this.lastError = STRERR_SynchronismFailed;
success = false;
}
}
}
else
{
this.lastError = this.plc.LastError;
}
}
else
{
//
// Not in synchronism yet - wait a very short time before taking measurements
//
Thread.Sleep(200);
state = States.TakeMeasurementsForSynchronism;
}
}
else
{
this.lastError = this.plc.LastError;
}
break;
case States.InSynchronism:
//
// We are now in synchronism - set the torque limits
//
if ((success = this.dcDrive.SetMaxTorqueLimit(DCDrive.DEFAULT_Motor1TorqueMaxLimit_Synchronism)) == true)
{
if ((success = this.dcDrive.SetMinTorqueLimit(DCDrive.DEFAULT_Motor1TorqueMinLimit_Synchronism)) == true)
{
//
// Load up the machine by making it drive harder
//
if ((success = this.dcDrive.ChangeSpeed(this.configParameters.speedSynchronism, false)) == true)
{
this.WaitDelay(5);
state = States.Done;
}
else
{
this.lastError = this.dcDrive.LastError;
}
}
else
{
this.lastError = this.dcDrive.LastError;
}
}
else
{
this.lastError = this.dcDrive.LastError;
}
break;
}
//
// Check if any errors occurred
//
if (success == false)
{
if (this.lastError != null)
{
Logfile.WriteError(this.lastError);
}
state = States.Done;
}
}
//
// Determine how long execution actually took
//
TimeSpan timeSpan = DateTime.Now - startDateTime;
double totalTime = timeSpan.TotalSeconds;
logMessage = String.Format(STRLOG_ExecuteTime_Fmt, totalTime);
Trace.WriteLine(logMessage);
logMessage += Logfile.STRLOG_Spacer + STRLOG_Success + success.ToString();
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
//-------------------------------------------------------------------------------------------------//
public DriverMachine_Sync(XmlNode xmlNodeEquipmentConfig, Specification specification)
: base(xmlNodeEquipmentConfig, specification)
{
const string STRLOG_MethodName = "DriverMachine_Sync";
Logfile.WriteCalled(null, STRLOG_MethodName);
//
// Initialise local variables
//
this.measurements = null;
try
{
//
// Get parameters for this driver
//
XmlNode xmlNodeConfiguration = XmlUtilities.GetXmlNode(xmlNodeEquipmentConfig, Consts.STRXML_configuration, false);
XmlNode xmlNodeSynchronisation = XmlUtilities.GetXmlNode(xmlNodeConfiguration, Consts.STRXML_synchronisation, false);
//
// Execution time
//
XmlNode xmlNode = XmlUtilities.GetXmlNode(xmlNodeSynchronisation, Consts.STRXML_executionTimes);
this.executionTimes.initialise = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_initialise);
this.executionTimes.start = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_start);
this.executionTimes.run = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_run);
this.executionTimes.stop = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_stop);
this.executionTimes.finalise = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_finalise);
Logfile.Write(String.Format(STRLOG_ExecuteTimes_Fmt, this.executionTimes.initialise,
this.executionTimes.start, this.executionTimes.run,
this.executionTimes.stop, this.executionTimes.finalise
));
//
// Speed and speed trim
//
this.configParameters.speed = XmlUtilities.GetIntValue(xmlNodeSynchronisation, Consts.STRXML_speed);
xmlNode = XmlUtilities.GetXmlNode(xmlNodeSynchronisation, Consts.STRXML_speedTrim);
this.configParameters.speedTrimLow = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_low);
this.configParameters.speedTrimHigh = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_high);
Logfile.Write(STRLOG_Speed + this.configParameters.speed.ToString() +
Logfile.STRLOG_Spacer + STRLOG_SpeedTrimLow + this.configParameters.speedTrimLow.ToString() +
Logfile.STRLOG_Spacer + STRLOG_SpeedTrimHigh + this.configParameters.speedTrimHigh.ToString());
//
// Maximum field current, sync field increases and measurements
//
this.configParameters.maxFieldCurrent = XmlUtilities.GetRealValue(xmlNodeSynchronisation, Consts.STRXML_maxFieldCurrent);
this.configParameters.maxSyncFieldIncreases = XmlUtilities.GetIntValue(xmlNodeSynchronisation, Consts.STRXML_maxSyncFieldIncreases);
this.configParameters.maxMeasurements = XmlUtilities.GetIntValue(xmlNodeSynchronisation, Consts.STRXML_maxMeasurements);
Logfile.Write(STRLOG_MaxFieldCurrent + this.configParameters.maxFieldCurrent.ToString() +
Logfile.STRLOG_Spacer + STRLOG_MaxSyncFieldIncreases + this.configParameters.maxSyncFieldIncreases.ToString() +
Logfile.STRLOG_Spacer + STRLOG_MaxMeasurements + this.configParameters.maxMeasurements.ToString());
//
// Speed adjustment for phase change between measurements
//
this.configParameters.simpleMovingAverage = XmlUtilities.GetIntValue(xmlNodeSynchronisation, Consts.STRXML_simpleMovingAverage);
xmlNode = XmlUtilities.GetXmlNode(xmlNodeSynchronisation, Consts.STRXML_phaseChangeLimit);
this.configParameters.phaseChangeLimitLow = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_low);
this.configParameters.phaseChangeLimitHigh = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_high);
Logfile.Write(STRLOG_SimpleMovingAverage + this.configParameters.simpleMovingAverage.ToString() +
Logfile.STRLOG_Spacer + STRLOG_PhaseChangeLimitLow + this.configParameters.phaseChangeLimitLow.ToString() +
Logfile.STRLOG_Spacer + STRLOG_PhaseChangeLimitHigh + this.configParameters.phaseChangeLimitHigh.ToString());
//
// Phase window to try synchronism
//
xmlNode = XmlUtilities.GetXmlNode(xmlNodeSynchronisation, Consts.STRXML_phaseSynchronism);
this.configParameters.phaseSynchronismLow = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_low);
this.configParameters.phaseSynchronismHigh = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_high);
Logfile.Write(STRLOG_PhaseSynchronismLow + this.configParameters.phaseSynchronismLow.ToString() +
Logfile.STRLOG_Spacer + STRLOG_PhaseSynchronismHigh + this.configParameters.phaseSynchronismHigh.ToString());
//
// Speed for synchronism
//
this.configParameters.speedSynchronism = XmlUtilities.GetIntValue(xmlNodeSynchronisation, Consts.STRXML_speedSynchronism);
Logfile.Write(STRLOG_SpeedSynchronism + this.configParameters.speedSynchronism.ToString());
//
// Torque range
//
xmlNode = XmlUtilities.GetXmlNode(xmlNodeSynchronisation, Consts.STRXML_torque);
this.configParameters.torqueMin = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_min);
this.configParameters.torqueMax = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_max);
this.configParameters.torqueStep = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_step);
Logfile.Write(STRLOG_MinTorque + this.configParameters.torqueMin.ToString() +
Logfile.STRLOG_Spacer + STRLOG_MaxTorque + this.configParameters.torqueMax.ToString() +
Logfile.STRLOG_Spacer + STRLOG_TorqueStep + this.configParameters.torqueStep.ToString());
//
// Power factor to increase or decrease sync field
//
xmlNode = XmlUtilities.GetXmlNode(xmlNodeSynchronisation, Consts.STRXML_powerFactor);
this.configParameters.powerFactorLow = XmlUtilities.GetRealValue(xmlNode, Consts.STRXML_low);
this.configParameters.powerFactorHigh = XmlUtilities.GetRealValue(xmlNode, Consts.STRXML_high);
Logfile.Write(STRLOG_PowerFactorLow + this.configParameters.powerFactorLow.ToString() +
Logfile.STRLOG_Spacer + STRLOG_PowerFactorHigh + this.configParameters.powerFactorHigh.ToString());
//
// Load the XML measurements template and check that all required XML nodes exist
//
this.xmlNodeMeasurementsTemplate = XmlUtilities.GetXmlNode(xmlNodeSynchronisation, Consts.STRXML_measurements);
//
// Check that all required XML nodes exist
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_count, true);
//
// Field current
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_fieldCurrent, true);
XmlNode xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_fieldCurrent);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
//
// Sync voltage
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_syncVoltage, true);
xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_syncVoltage);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
//
// Sync frequency
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_syncFrequency, true);
xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_syncFrequency);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
//
// Torque set point
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_torqueSetpoint, true);
xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_torqueSetpoint);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
//
// Power factor
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_powerFactor, true);
//
// Real power
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_realPower, true);
xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_realPower);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
//
// Reactive power
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_reactivePower, true);
xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_reactivePower);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
//
// Phase current
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_phaseCurrent, true);
xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_phaseCurrent);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
}
catch (Exception ex)
{
//
// Log the message and throw the exception back to the caller
//
Logfile.WriteError(ex.Message);
throw;
}
Logfile.WriteCompleted(null, STRLOG_MethodName);
}
//-------------------------------------------------------------------------------------------------//
protected override bool ExecuteRunning()
{
const string STRLOG_MethodName = "ExecuteRunning";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
string logMessage;
//
// Get the time now to determine how long execution actually takes
//
DateTime startDateTime = DateTime.Now;
//
// Calculate execution completion time
//
int executionTimeRemaining = 0;
executionTimeRemaining += this.executionTimes.run;
executionTimeRemaining += this.executionTimes.stop;
executionTimeRemaining += this.executionTimes.finalise;
this.executionCompletionTime = DateTime.Now + TimeSpan.FromSeconds(executionTimeRemaining);
Logfile.Write(
String.Format(STRLOG_ExecutionTimeRemaining_arg, executionTimeRemaining));
//
// Create the data structure for storing the measurements
//
this.measurements = new Measurements();
//
// Initialise state machine
//
this.lastError = null;
int torque = this.configParameters.torqueMin;
int measurementCount = 0;
Measurement[] measurementArray = new Measurement[this.configParameters.simpleMovingAverage];
Measurement measurementAverage = new Measurement();
States state = States.CheckStatus;
//
// State machine loop
//
while (state != States.Done)
{
bool status = false;
string units = String.Empty;
Trace.WriteLine("state: " + state.ToString());
switch (state)
{
case States.CheckStatus:
//
// Check machine status before continuing
//
if ((success = this.CheckStatus()) == true)
{
state = States.TakeMeasurementsForIncreasedSyncField;
}
else
{
// this.lastError already updated
}
break;
case States.TakeMeasurementsForIncreasedTorque:
case States.TakeMeasurementsForIncreasedSyncField:
case States.TakeMeasurementsForDecreasedTorque:
case States.TakeMeasurementsForDecreasedSyncField:
//
// Wait before taking measurements
//
this.WaitDelay(1);
//
// Take measurements
//
if ((success = this.TakeMeasurements(state, ref measurementArray[measurementCount])) == true)
{
//
// Check if there are enough measurements to get an average of the power factor
//
if (++measurementCount >= this.configParameters.simpleMovingAverage)
{
//
// Average the measurements
//
measurementAverage = new Measurement();
for (int i = 0; i < this.configParameters.simpleMovingAverage; i++)
{
measurementAverage.fieldCurrent += measurementArray[i].fieldCurrent;
measurementAverage.syncVoltage += measurementArray[i].syncVoltage;
measurementAverage.syncFrequency += measurementArray[i].syncFrequency;
measurementAverage.torqueSetpoint += measurementArray[i].torqueSetpoint;
measurementAverage.realPower += measurementArray[i].realPower;
measurementAverage.reactivePower += measurementArray[i].reactivePower;
measurementAverage.phaseCurrent += measurementArray[i].phaseCurrent;
if (measurementArray[i].powerFactor < 0)
{
measurementArray[i].powerFactor += 2;
}
measurementAverage.powerFactor += measurementArray[i].powerFactor;
}
measurementAverage.fieldCurrent /= this.configParameters.simpleMovingAverage;
measurementAverage.syncVoltage /= this.configParameters.simpleMovingAverage;
measurementAverage.syncFrequency /= this.configParameters.simpleMovingAverage;
measurementAverage.torqueSetpoint /= this.configParameters.simpleMovingAverage;
measurementAverage.powerFactor /= this.configParameters.simpleMovingAverage;
measurementAverage.realPower /= this.configParameters.simpleMovingAverage;
measurementAverage.reactivePower /= this.configParameters.simpleMovingAverage;
measurementAverage.phaseCurrent /= this.configParameters.simpleMovingAverage;
//
// Add the averaged measurement to the list
//
this.measurements.valueList.Add(measurementAverage);
measurementCount = 0;
//
// Determine next state
//
switch (state)
{
case States.TakeMeasurementsForIncreasedTorque:
state = States.CheckPowerFactorForIncreasedTorque;
break;
case States.TakeMeasurementsForIncreasedSyncField:
state = States.IncreaseTorque;
break;
case States.TakeMeasurementsForDecreasedTorque:
state = (torque > this.configParameters.torqueMin) ? States.CheckPowerFactorForDecreasedTorque : States.Done;
break;
case States.TakeMeasurementsForDecreasedSyncField:
state = States.DecreaseTorque;
break;
}
}
else
{
//
// Take another measurement
//
}
}
else
{
// this.lastError already updated
}
break;
case States.IncreaseTorque:
//
// Check if the desired maximum torque has been reached
//
if (torque < this.configParameters.torqueMax)
{
//
// Increase the torque by one step
//
torque += this.configParameters.torqueStep;
logMessage = STRLOG_TorqueSetpoint + torque.ToString();
Logfile.Write(logMessage);
Trace.WriteLine(logMessage);
//
// Change the DC drive torque maximum limit setpoint
//
if ((success = (this.dcDrive.SetMaxTorqueLimit(torque))) == true)
{
//
// Wait for increased torque to settle
//
this.WaitDelay(3);
state = States.TakeMeasurementsForIncreasedTorque;
}
else
{
this.lastError = this.dcDrive.LastError;
}
}
else
{
//
// Maximum torque has been reached, all done here
//
Logfile.Write(STRLOG_MaxTorqueReached + this.configParameters.torqueMax.ToString());
state = States.DecreaseTorque;
}
break;
case States.CheckPowerFactorForIncreasedTorque:
//
// Check if the average power factor is too high
//
Trace.WriteLine(string.Format("Average PowerFactor: {0:f03}", measurementAverage.powerFactor));
if (measurementAverage.powerFactor > this.configParameters.powerFactorHigh)
{
//
// Need to increase the field current to decrease the power factor
//
state = States.IncreaseSyncFieldForIncreasedTorque;
}
else
{
state = States.IncreaseTorque;
}
break;
case States.IncreaseSyncFieldForIncreasedTorque:
//
// Increase the sync. machine field by one increment
//
if ((success = (this.plc.IncreaseSyncField(ref status) == true && status == true)) == true)
{
//
// Wait for increased sync field to settle
//
this.WaitDelay(3);
state = States.TakeMeasurementsForIncreasedSyncField;
}
else
{
//
// Unable to increase field current because of machine limitations, not an error
//
logMessage = STRLOG_UnableToIncreaseFieldCurrent;
Logfile.Write(logMessage);
Trace.WriteLine(logMessage);
success = true;
state = States.IncreaseTorque;
}
break;
case States.DecreaseTorque:
//
// Check if the desired minimum torque has been reached
//
if (torque > this.configParameters.torqueMin)
{
//
// Decrease the torque by one step
//
torque -= this.configParameters.torqueStep;
logMessage = STRLOG_TorqueSetpoint + torque.ToString();
Logfile.Write(logMessage);
Trace.WriteLine(logMessage);
//
// Change the DC drive torque maximum limit setpoint
//
if ((success = (this.dcDrive.SetMaxTorqueLimit(torque))) == true)
{
state = States.TakeMeasurementsForDecreasedTorque;
}
else
{
this.lastError = this.dcDrive.LastError;
}
}
else
{
//
// Minimum torque has been reached, all done here
//
Logfile.Write(STRLOG_MinTorqueReached + this.configParameters.torqueMax.ToString());
state = States.Done;
}
break;
case States.CheckPowerFactorForDecreasedTorque:
//
// Check if the average power factor is too high
//
Trace.WriteLine(string.Format("Average PowerFactor: {0:f03}", measurementAverage.powerFactor));
if (measurementAverage.powerFactor < this.configParameters.powerFactorLow)
{
//
// Need to decrease the field current to increase the power factor
//
state = States.DecreaseSyncFieldForDecreasedTorque;
}
else
{
state = States.DecreaseTorque;
}
break;
case States.DecreaseSyncFieldForDecreasedTorque:
//
// Decrease the sync. machine field by one increment
//
if ((success = (this.plc.DecreaseSyncField(ref status) == true && status == true)) == true)
{
state = States.TakeMeasurementsForDecreasedSyncField;
}
else
{
this.lastError = STRLOG_UnableToDecreaseFieldCurrent + this.plc.LastError;
}
break;
}
//
// Check if any errors occurred
//
if (success == false)
{
if (this.lastError != null)
{
Logfile.WriteError(this.lastError);
}
state = States.Done;
}
}
//
// Determine how long execution actually took
//
TimeSpan timeSpan = DateTime.Now - startDateTime;
double totalTime = timeSpan.TotalSeconds;
logMessage = String.Format(STRLOG_ExecuteTime_Fmt, totalTime);
Trace.WriteLine(logMessage);
logMessage += Logfile.STRLOG_Spacer + STRLOG_Success + success.ToString();
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
// Creates and sets the data context once the user control has loaded.
private void MeasurementPager_Loaded(object sender, RoutedEventArgs e)
{
if (!DesignerProperties.GetIsInDesignMode(this))
{
m_dataContext = new Measurements(false);
m_dataContext.PropertyChanged += ViewModel_PropertyChanged;
m_dataContext.FilterExpression = FilterExpression;
m_dataContext.ItemsPerPage = ItemsPerPage;
m_dataContext.Load();
RootPanel.DataContext = m_dataContext;
}
}
//-------------------------------------------------------------------------------------------------//
public DriverMachine_SCVF(XmlNode xmlNodeEquipmentConfig, Specification specification)
: base(xmlNodeEquipmentConfig, specification)
{
const string STRLOG_MethodName = "DriverMachine_SCVF";
Logfile.WriteCalled(null, STRLOG_MethodName);
//
// Initialise local variables
//
this.measurements = null;
try
{
//
// Get parameters for this driver
//
XmlNode xmlNodeConfiguration = XmlUtilities.GetXmlNode(xmlNodeEquipmentConfig, Consts.STRXML_configuration, false);
XmlNode xmlNodeShortCircuitVaryField = XmlUtilities.GetXmlNode(xmlNodeConfiguration, Consts.STRXML_shortCircuitVaryField, false);
//
// Execution times
//
XmlNode xmlNode = XmlUtilities.GetXmlNode(xmlNodeShortCircuitVaryField, Consts.STRXML_executionTimes);
this.executionTimes.initialise = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_initialise);
this.executionTimes.start = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_start);
this.executionTimes.run = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_run);
this.executionTimes.stop = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_stop);
this.executionTimes.finalise = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_finalise);
Logfile.Write(String.Format(STRLOG_ExecuteTimes_Fmt, this.executionTimes.initialise,
this.executionTimes.start, this.executionTimes.run,
this.executionTimes.stop, this.executionTimes.finalise
));
//
// Speed
//
this.configParameters.speed = XmlUtilities.GetIntValue(xmlNodeShortCircuitVaryField, Consts.STRXML_speed);
Logfile.Write(STRLOG_Speed + this.configParameters.speed.ToString());
//
// Maximum field current, sync field increases and stator current
//
this.configParameters.maxFieldCurrent = XmlUtilities.GetRealValue(xmlNodeShortCircuitVaryField, Consts.STRXML_maxFieldCurrent);
this.configParameters.maxSyncFieldIncreases = XmlUtilities.GetIntValue(xmlNodeShortCircuitVaryField, Consts.STRXML_maxSyncFieldIncreases);
this.configParameters.maxStatorCurrent = XmlUtilities.GetRealValue(xmlNodeShortCircuitVaryField, Consts.STRXML_maxStatorCurrent);
Logfile.Write(STRLOG_MaxFieldCurrent + this.configParameters.maxFieldCurrent.ToString() +
Logfile.STRLOG_Spacer + STRLOG_MaxSyncFieldIncreases + this.configParameters.maxSyncFieldIncreases.ToString() +
Logfile.STRLOG_Spacer + STRLOG_MaxStatorCurrent + this.configParameters.maxStatorCurrent.ToString());
//
// Load the XML measurements template and check that all required XML nodes exist
//
this.xmlNodeMeasurementsTemplate = XmlUtilities.GetXmlNode(xmlNodeShortCircuitVaryField, Consts.STRXML_measurements);
//
// Check that all required XML nodes exist
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_count, true);
//
// Field current
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_fieldCurrent, true);
XmlNode xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_fieldCurrent);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
//
// Speed
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_speed, true);
xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_speed);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
//
// Stator current
//
XmlUtilities.GetXmlValue(this.xmlNodeMeasurementsTemplate, Consts.STRXML_statorCurrent, true);
xmlNodeParam = XmlUtilities.GetXmlNode(this.xmlNodeMeasurementsTemplate, Consts.STRXML_statorCurrent);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_units, true);
XmlUtilities.GetXmlValue(xmlNodeParam, Consts.STRXMLPARAM_format, false);
}
catch (Exception ex)
{
//
// Log the message and throw the exception back to the caller
//
Logfile.WriteError(ex.Message);
throw;
}
Logfile.WriteCompleted(null, STRLOG_MethodName);
}
//private void BtnExport_Click(object sender, EventArgs e)
//{
// Settings.Default.Save();
// if (m_meta == null)
// {
// MessageBox.Show("Please download the metadata first.");
// return;
// }
// if (m_selectedMeasurements == null || m_selectedMeasurements.Count == 0)
// {
// MessageBox.Show("There are no measurements to extract");
// return;
// }
// DateTime startTime = dateStartTime.Value;
// DateTime stopTime = dateStopTime.Value;
// if (startTime > stopTime)
// {
// MessageBox.Show("Start and Stop times are invalid");
// return;
// }
// TimeSpan interval = Resolutions.GetInterval((string)cmbResolution.SelectedItem);
// HistorianClientOptions clientOptions = new HistorianClientOptions();
// clientOptions.DefaultDatabase = Settings.Default.HistorianInstanceName;
// clientOptions.NetworkPort = Settings.Default.HistorianStreamingPort;
// clientOptions.ServerNameOrIp = Settings.Default.ServerIP;
// using (HistorianClient client = new HistorianClient(clientOptions))
// {
// KeySeekFilterBase<HistorianKey> timeFilter;
// if (interval.Ticks != 0)
// timeFilter = TimestampFilter.CreateFromIntervalData<HistorianKey>(startTime, stopTime, interval, new TimeSpan(TimeSpan.TicksPerMillisecond));
// else
// timeFilter = TimestampFilter.CreateFromRange<HistorianKey>(startTime, stopTime);
// var points = m_selectedMeasurements.Select((x) => (ulong)x.PointID).ToArray();
// var pointFilter = PointIDFilter.CreateFromList<HistorianKey>(points);
// var database = client.GetDefaultDatabase();
// var frames = database.GetFrames(timeFilter, pointFilter).RoundToTolerance(1);
// using (var csvStream = new StreamWriter("C:\\temp\\file.csv"))
// {
// //csvStream.AutoFlush = false;
// csvStream.Write("Timestamp,");
// foreach (var signal in m_selectedMeasurements)
// {
// csvStream.Write(signal.Description);
// csvStream.Write(',');
// }
// csvStream.WriteLine();
// foreach (var frame in frames)
// {
// csvStream.Write(frame.Key.ToString("MM/dd/yyyy hh:mm:ss.fffffff"));
// csvStream.Write(',');
// foreach (var signal in m_selectedMeasurements)
// {
// HistorianValueStruct value;
// if (frame.Value.Points.TryGetValue((ulong)signal.PointID, out value))
// {
// csvStream.Write(value.AsSingle);
// }
// csvStream.Write(',');
// }
// csvStream.WriteLine();
// }
// csvStream.Flush();
// }
// database.Disconnect();
// }
//}
//private void BtnExport_Click(object sender, EventArgs e)
//{
// Settings.Default.Save();
// if (m_meta == null)
// {
// MessageBox.Show("Please download the metadata first.");
// return;
// }
// if (m_selectedMeasurements == null || m_selectedMeasurements.Count == 0)
// {
// MessageBox.Show("There are no measurements to extract");
// return;
// }
// DateTime startTime = dateStartTime.Value;
// DateTime stopTime = dateStopTime.Value;
// if (startTime > stopTime)
// {
// MessageBox.Show("Start and Stop times are invalid");
// return;
// }
// TimeSpan interval = Resolutions.GetInterval((string)cmbResolution.SelectedItem);
// HistorianClientOptions clientOptions = new HistorianClientOptions();
// clientOptions.DefaultDatabase = Settings.Default.HistorianInstanceName;
// clientOptions.NetworkPort = Settings.Default.HistorianStreamingPort;
// clientOptions.ServerNameOrIp = Settings.Default.ServerIP;
// using (HistorianClient client = new HistorianClient(clientOptions))
// {
// KeySeekFilterBase<HistorianKey> timeFilter;
// if (interval.Ticks != 0)
// timeFilter = TimestampFilter.CreateFromIntervalData<HistorianKey>(startTime, stopTime, interval, new TimeSpan(TimeSpan.TicksPerMillisecond));
// else
// timeFilter = TimestampFilter.CreateFromRange<HistorianKey>(startTime, stopTime);
// var points = m_selectedMeasurements.Select((x) => (ulong)x.PointID).ToArray();
// var pointFilter = PointIDFilter.CreateFromList<HistorianKey>(points);
// var database = client.GetDefaultDatabase();
// using (var frameReader = database.GetPointStream(timeFilter, pointFilter).GetFrameReader())
// using (var csvStream = new StreamWriter("C:\\temp\\file.csv"))
// {
// var ultraStream = new UltraStreamWriter(csvStream);
// //csvStream.AutoFlush = false;
// csvStream.Write("Timestamp,");
// foreach (var signal in m_selectedMeasurements)
// {
// csvStream.Write(signal.Description);
// csvStream.Write(',');
// }
// csvStream.WriteLine();
// while (frameReader.Read())
// {
// csvStream.Write(frameReader.FrameTime.ToString("MM/dd/yyyy hh:mm:ss.fffffff"));
// csvStream.Write(',');
// foreach (var signal in m_selectedMeasurements)
// {
// HistorianValueStruct value;
// if (frameReader.Frame.TryGetValue((ulong)signal.PointID, out value))
// {
// ultraStream.Write(value.AsSingle);
// //csvStream.Write(value.AsSingle);
// }
// //csvStream.Write(',');
// ultraStream.Write(',');
// }
// ultraStream.Flush();
// csvStream.WriteLine();
// }
// csvStream.Flush();
// }
// database.Disconnect();
// }
//}
//private void BtnExport_Click(object sender, EventArgs e)
//{
// Settings.Default.Save();
// if (m_meta == null)
// {
// MessageBox.Show("Please download the metadata first.");
// return;
// }
// if (m_selectedMeasurements == null || m_selectedMeasurements.Count == 0)
// {
// MessageBox.Show("There are no measurements to extract");
// return;
// }
// DateTime startTime = dateStartTime.Value;
// DateTime stopTime = dateStopTime.Value;
// if (startTime > stopTime)
// {
// MessageBox.Show("Start and Stop times are invalid");
// return;
// }
// TimeSpan interval = Resolutions.GetInterval((string)cmbResolution.SelectedItem);
// HistorianClientOptions clientOptions = new HistorianClientOptions();
// clientOptions.DefaultDatabase = Settings.Default.HistorianInstanceName;
// clientOptions.NetworkPort = Settings.Default.HistorianStreamingPort;
// clientOptions.ServerNameOrIp = Settings.Default.ServerIP;
// using (HistorianClient client = new HistorianClient(clientOptions))
// {
// m_readIndex = 0;
// m_fillMeasurements.Clear();
// m_measurementsInOrder.Clear();
// foreach (var signal in m_selectedMeasurements)
// {
// var m = new Measurements();
// m_fillMeasurements.Add((ulong)signal.PointID, m);
// m_measurementsInOrder.Add(m);
// }
// KeySeekFilterBase<HistorianKey> timeFilter;
// if (interval.Ticks != 0)
// timeFilter = TimestampFilter.CreateFromIntervalData<HistorianKey>(startTime, stopTime, interval, new TimeSpan(TimeSpan.TicksPerMillisecond));
// else
// timeFilter = TimestampFilter.CreateFromRange<HistorianKey>(startTime, stopTime);
// var points = m_selectedMeasurements.Select((x) => (ulong)x.PointID).ToArray();
// var pointFilter = PointIDFilter.CreateFromList<HistorianKey>(points);
// var database = client.GetDefaultDatabase();
// using (var fillAdapter = database.GetPointStream(timeFilter, pointFilter).GetFillAdapter())
// using (var csvStream = new StreamWriter("C:\\temp\\file.csv"))
// {
// var ultraStream = new UltraStreamWriter(csvStream);
// //csvStream.AutoFlush = false;
// csvStream.Write("Timestamp,");
// foreach (var signal in m_selectedMeasurements)
// {
// csvStream.Write(signal.Description);
// csvStream.Write(',');
// }
// csvStream.WriteLine();
// m_readIndex++;
// while (fillAdapter.Fill(FillData))
// {
// csvStream.Write(fillAdapter.FrameTime.ToString("MM/dd/yyyy hh:mm:ss.fffffff"));
// csvStream.Write(',');
// foreach (var signal in m_measurementsInOrder)
// {
// if (signal.ReadNumber == m_readIndex)
// {
// ultraStream.Write(signal.Value);
// }
// ultraStream.Write(',');
// }
// ultraStream.Flush();
// csvStream.WriteLine();
// m_readIndex++;
// }
// csvStream.Flush();
// }
// database.Disconnect();
// }
//}
private void BtnExport_Click(object sender, EventArgs e)
{
Settings.Default.Save();
if (m_meta == null)
{
MessageBox.Show("Please download the metadata first.");
return;
}
if (m_selectedMeasurements == null || m_selectedMeasurements.Count == 0)
{
MessageBox.Show("There are no measurements to extract");
return;
}
DateTime startTime = dateStartTime.Value;
DateTime stopTime = dateStopTime.Value;
if (startTime > stopTime)
{
MessageBox.Show("Start and Stop times are invalid");
return;
}
BtnExport.Tag = BtnExport.Text;
BtnExport.Text = "Exporting...";
BtnExport.Enabled = false;
Cursor.Current = Cursors.WaitCursor;
Application.DoEvents();
TimeSpan interval = Resolutions.GetInterval((string)cmbResolution.SelectedItem);
Thread workerThread = new Thread(start =>
{
long processingStartTime = DateTime.UtcNow.Ticks;
using (HistorianClient client = new HistorianClient(TxtServerIP.Text,int.Parse(TxtHistorianPort.Text)))
{
m_readIndex = 0;
m_fillMeasurements.Clear();
m_measurementsInOrder.Clear();
foreach (var signal in m_selectedMeasurements)
{
var m = new Measurements();
m_fillMeasurements.Add((ulong)signal.PointID, m);
m_measurementsInOrder.Add(m);
}
SeekFilterBase<HistorianKey> timeFilter;
if (interval.Ticks != 0)
timeFilter = TimestampSeekFilter.CreateFromIntervalData<HistorianKey>(startTime, stopTime, interval, new TimeSpan(TimeSpan.TicksPerMillisecond));
else
timeFilter = TimestampSeekFilter.CreateFromRange<HistorianKey>(startTime, stopTime);
var points = m_selectedMeasurements.Select((x) => (ulong)x.PointID).ToArray();
var pointFilter = PointIdMatchFilter.CreateFromList<HistorianKey, HistorianValue>(points);
using (var database = client.GetDatabase<HistorianKey, HistorianValue>(TxtHistorianInstance.Text))
{
string fileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "Export.csv");
using (var fillAdapter = database.GetPointStream(timeFilter, pointFilter).GetFillAdapter())
using (var csvStream = new StreamWriter(fileName))
{
var ultraStream = new UltraStreamWriter(csvStream);
//csvStream.AutoFlush = false;
csvStream.Write("Timestamp,");
foreach (var signal in m_selectedMeasurements)
{
csvStream.Write(signal.Description);
csvStream.Write(',');
}
csvStream.WriteLine();
m_readIndex++;
while (fillAdapter.Fill(FillData))
{
csvStream.Write(fillAdapter.FrameTime.ToString("MM/dd/yyyy hh:mm:ss.fffffff"));
csvStream.Write(',');
foreach (var signal in m_measurementsInOrder)
{
if (signal.ReadNumber == m_readIndex)
{
ultraStream.Write(signal.Value);
}
ultraStream.Write(',');
}
ultraStream.Flush();
csvStream.WriteLine();
m_readIndex++;
}
csvStream.Flush();
}
}
}
Ticks runtime = DateTime.UtcNow.Ticks - processingStartTime;
BeginInvoke(new Action<Ticks>(r => MessageBox.Show(r.ToElapsedTimeString(2), "Processing Time", MessageBoxButtons.OK, MessageBoxIcon.Information)), runtime);
BeginInvoke(new Action(RestoreExportButton));
});
workerThread.Start();
}
public void Constructor_SetsCalculatorObject()
{
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
Measurements target = new Measurements(calculatorM.Object);
Assert.Same(calculatorM.Object, target.DimensionsCalculator);
}
//-------------------------------------------------------------------------------------------------//
public bool TakeMeasurement(ref Measurements measurement)
{
const string STRLOG_MethodName = "TakeMeasurement";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
this.lastError = null;
bool success = false;
try
{
// Wait before taking the measurement
acDrive.WaitDelay(this.measurementDelay);
//
// Take the measurement
//
measurement.voltageMut = this.powerMeter.ReadVoltagePhaseToPhaseMut();
measurement.currentMut = this.powerMeter.ReadCurrentThreePhaseMut();
measurement.powerFactorMut = this.powerMeter.ReadPowerFactorAverageMut();
measurement.voltageVsd = this.powerMeter.ReadVoltagePhaseToPhaseVsd();
measurement.currentVsd = this.powerMeter.ReadCurrentThreePhaseVsd();
measurement.powerFactorVsd = this.powerMeter.ReadPowerFactorAverageVsd();
measurement.speed = this.acDrive.ReadDriveSpeed();
measurement.torque = this.acDrive.ReadDriveTorque();
success = true;
}
catch (Exception ex)
{
this.lastError = ex.Message;
Logfile.WriteError(ex.Message);
}
string logMessage = STRLOG_Success + success.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
public void ComputeLength_MultiLineString_RetursSumOfLineStringsLengths()
{
Random generator = new Random();
double segment1Length = generator.Next(100);
double segment2Length = generator.Next(100);
double sum = 2 * (segment1Length + segment2Length);
LineString linestring = new LineString(new Coordinate[] { new Coordinate(10.1, 20.1), new Coordinate(10.2, 20.2), new Coordinate(10.3, 20.3) });
MultiLineString multilinestring = new MultiLineString(new LineString[] { linestring, linestring });
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
calculatorM.Setup(calc => calc.CalculateDistance(linestring.Coordinates[0], linestring.Coordinates[1])).Returns(segment1Length);
calculatorM.Setup(calc => calc.CalculateDistance(linestring.Coordinates[1], linestring.Coordinates[2])).Returns(segment2Length);
Measurements target = new Measurements(calculatorM.Object);
double length = target.ComputeLength(multilinestring);
Assert.Equal(sum, length);
}
public void ComputeLength_MultiLineString_RetursZeroForMultiLineStringWithoutMembers()
{
MultiLineString multilinestring = new MultiLineString();
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
Measurements target = new Measurements(calculatorM.Object);
double length = target.ComputeLength(multilinestring);
Assert.Equal(0, length);
}
public async Task<Measurements> GetMeasurementsAsync(string databaseName, ShowMeasurements command = null)
{
ThrowIfDisposed();
Ensure.That(databaseName, nameof(databaseName)).IsNotNullOrWhiteSpace();
var result = new Measurements();
var json = await GetMeasurementsJsonAsync(databaseName, command).ForAwait();
var data = Requester.JsonSerializer.Deserialize<InfluxDbResponse>(json);
if (data?.Results == null || !data.Results.Any())
return result;
foreach (var serie in data.Results.SelectMany(r => r.Series))
result.AddRange(serie.Values.Select(value => value.First.ToObject<string>()).ToArray());
return result;
}
//-------------------------------------------------------------------------------------------------//
protected override bool ExecuteRunning()
{
const string STRLOG_MethodName = "ExecuteRunning";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
string logMessage;
//
// Get the time now to determine how long execution actually takes
//
DateTime startDateTime = DateTime.Now;
//
// Calculate execution completion time
//
int executionTimeRemaining = 0;
executionTimeRemaining += this.executionTimes.run;
executionTimeRemaining += this.executionTimes.stop;
executionTimeRemaining += this.executionTimes.finalise;
this.executionCompletionTime = DateTime.Now + TimeSpan.FromSeconds(executionTimeRemaining);
Logfile.Write(
String.Format(STRLOG_ExecutionTimeRemaining_arg, executionTimeRemaining));
//
// Create the data structure for storing the measurements
//
this.measurements = new Measurements();
//
// Initialise state machine
//
int increaseSyncFieldCount = 0;
States state = States.CheckStatus;
//
// State machine loop
//
while (state != States.Done)
{
bool status = false;
double value = 0;
string units = String.Empty;
Trace.WriteLine("state: " + state.ToString());
switch (state)
{
case States.CheckStatus:
//
// Check machine status before continuing
//
if ((success = this.CheckStatus()) == true)
{
state = States.IncreaseSyncField;
}
else
{
// this.lastError already updated
}
break;
case States.IncreaseSyncField:
//
// Increase the sync. machine field by one increment
//
if ((success = this.plc.IncreaseSyncField(ref status)) == true)
{
//
// Check if the sync field current was increased successfully
//
if (status == false)
{
//
// Unable to increase field current any further, this is not an error
//
logMessage = STRLOG_UnableToIncreaseFieldCurrent;
Logfile.Write(logMessage);
Trace.WriteLine(logMessage);
}
else
{
state = States.CheckStatorCurrent;
}
}
else
{
this.lastError = this.plc.LastError;
}
break;
case States.CheckStatorCurrent:
//
// Get stator phase current and store
//
if ((success = this.plc.PowerMeter.GetPhaseCurrent(ref value, ref units)) == true)
{
logMessage = String.Format(STRLOG_StatorCurrentValueUnits_Fmt, value, units);
Logfile.Write(logMessage);
Trace.WriteLine(logMessage);
}
//
// Check if the maximum stator current has been reached
//
if (value < this.configParameters.maxStatorCurrent)
{
state = States.CheckSyncFieldCurrent;
}
else
{
//
// Maximum stator current has been reached, all done here
//
logMessage = STRLOG_MaxStatorCurrentReached + this.configParameters.maxStatorCurrent.ToString();
Logfile.Write(logMessage);
Trace.WriteLine(logMessage);
state = States.Done;
}
break;
case States.CheckSyncFieldCurrent:
//
// Get the sync field current
//
if ((success = this.plc.GetSyncFieldCurrent(ref value, ref units)) == true)
{
Logfile.Write(String.Format(STRLOG_FieldCurrentValueUnits_Fmt, value, units));
//
// Check if the maximum field current has been reached
//
if (value < this.configParameters.maxFieldCurrent)
{
state = States.CheckMaxSyncFieldCount;
}
else
{
//
// Maximum field current has been reached, all done here
//
logMessage = STRLOG_MaxFieldCurrentReached + this.configParameters.maxFieldCurrent.ToString();
Logfile.Write(logMessage);
Trace.WriteLine(logMessage);
state = States.Done;
}
}
else
{
this.lastError = this.plc.LastError;
}
break;
case States.CheckMaxSyncFieldCount:
//
// Check if maximum sync field incease count has been reached - should not happen
//
if ((success = (increaseSyncFieldCount++ < this.configParameters.maxSyncFieldIncreases)) == true)
{
Trace.WriteLine("increaseSyncFieldCount: " + increaseSyncFieldCount.ToString());
state = States.TakeMeasurements;
}
else
{
this.lastError = STRERR_MaxSyncFieldIncreasesReached + increaseSyncFieldCount.ToString();
}
break;
case States.TakeMeasurements:
//
// Wait a moment before taking the measurements
//
this.WaitDelay(1);
//
// Take measurements
//
if ((success = this.TakeMeasurements()) == true)
{
state = States.CheckStatus;
}
else
{
// this.lastError already updated
}
break;
}
//
// Check if any errors occurred
//
if (success == false)
{
if (this.lastError != null)
{
Logfile.WriteError(this.lastError);
}
state = States.Done;
}
}
//
// Determine how long execution actually took
//
TimeSpan timeSpan = DateTime.Now - startDateTime;
double totalTime = timeSpan.TotalSeconds;
logMessage = String.Format(STRLOG_ExecuteTime_Fmt, totalTime);
Trace.WriteLine(logMessage);
logMessage += Logfile.STRLOG_Spacer + STRLOG_Success + success.ToString();
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
// Creates and sets the data context once the user control has loaded.
private void MeasurementPager_Loaded(object sender, RoutedEventArgs e)
{
if (!DesignerProperties.GetIsInDesignMode(this))
{
m_dataContext = new Measurements(false);
m_dataContext.PropertyChanged += ViewModel_PropertyChanged;
m_dataContext.FilterExpression = FilterExpression;
m_dataContext.ItemsPerPage = ItemsPerPage;
m_dataContext.SearchCategories = AdvancedSearch.Categories;
m_dataContext.LoadSettings();
m_dataContext.Load();
RootPanel.DataContext = m_dataContext;
Application.Current.Exit += Application_Exit;
}
}
//-------------------------------------------------------------------------------------------------//
protected override bool ExecuteRunning()
{
const string STRLOG_MethodName = "ExecuteRunning";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
string logMessage;
//
// Get the time now to determine how long execution actually takes
//
DateTime startDateTime = DateTime.Now;
//
// Calculate execution completion time
//
int executionTimeRemaining = 0;
executionTimeRemaining += this.executionTimes.run;
executionTimeRemaining += this.executionTimes.stop;
executionTimeRemaining += this.executionTimes.finalise;
this.executionCompletionTime = DateTime.Now + TimeSpan.FromSeconds(executionTimeRemaining);
Logfile.Write(
String.Format(STRLOG_ExecutionTimeRemaining_arg, executionTimeRemaining));
//
// Create the data structure for storing the measurements
//
this.measurements = new Measurements();
//
// Initialise state machine
//
int speed = this.configParameters.speedMin;
States state = States.CheckStatus;
//
// State machine loop
//
while (state != States.Done)
{
Trace.WriteLine("state: " + state.ToString());
switch (state)
{
case States.CheckStatus:
//
// Check machine status before continuing
//
if ((success = this.CheckStatus()) == true)
{
state = States.TakeMeasurements;
}
else
{
// this.lastError already updated
}
break;
case States.TakeMeasurements:
//
// Wait a moment before taking the measurements
//
this.WaitDelay(1);
//
// Take measurements
//
if ((success = this.TakeMeasurements()) == true)
{
state = States.IncreaseSpeed;
}
else
{
// this.lastError already updated
}
break;
case States.IncreaseSpeed:
//
// Check if the desired maximum speed has been reached
//
if (speed < this.configParameters.speedMax)
{
//
// Increase the speed by one step
//
speed += this.configParameters.speedStep;
logMessage = STRLOG_Speed + speed.ToString();
Logfile.Write(logMessage);
Trace.WriteLine(logMessage);
//
// Change the DC drive speed
//
if ((success = this.dcDrive.ChangeSpeed(speed)) == true)
{
state = States.CheckStatus;
}
else
{
this.lastError = this.dcDrive.LastError;
}
}
else
{
//
// Maximum speed has been reached, all done here
//
Logfile.Write(STRLOG_MaxSpeedReached + this.configParameters.speedMax.ToString());
state = States.Done;
}
break;
}
//
// Check if any errors occurred
//
if (success == false)
{
if (this.lastError != null)
{
Logfile.WriteError(this.lastError);
}
state = States.Done;
}
}
//
// Determine how long execution actually took
//
TimeSpan timeSpan = DateTime.Now - startDateTime;
double totalTime = timeSpan.TotalSeconds;
logMessage = String.Format(STRLOG_ExecuteTime_Fmt, totalTime);
Trace.WriteLine(logMessage);
logMessage += Logfile.STRLOG_Spacer + STRLOG_Success + success.ToString();
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
//-------------------------------------------------------------------------------------------------//
public bool TakeMeasurement(ref Measurements measurement)
{
const string STRLOG_MethodName = "TakeMeasurement";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
this.lastError = null;
bool success = false;
try
{
// Wait before taking the measurement
dcDriveMut.WaitDelay(this.measurementDelay);
//
// Take the measurement
//
measurement.speed = dcDriveMut.ReadDriveSpeed();
measurement.voltage = dcDriveMut.ReadArmatureVoltage();
measurement.fieldCurrent = dcDriveMut.ReadFieldCurrent();
measurement.load = dcDriveMut.ReadTorque();
success = true;
}
catch (Exception ex)
{
this.lastError = ex.Message;
Logfile.WriteError(ex.Message);
}
string logMessage = STRLOG_Success + success.ToString() +
Logfile.STRLOG_Spacer + STRLOG_Speed + measurement.speed.ToString() + STRLOG_Rpm +
Logfile.STRLOG_Spacer + STRLOG_Voltage + measurement.voltage + STRLOG_Volts +
Logfile.STRLOG_Spacer + STRLOG_FieldCurrent + measurement.fieldCurrent.ToString() + STRLOG_Amps;
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
public void ComputeLength_LineString_RetursZeroForLineStringWithoutPoints()
{
LineString linestring = new LineString();
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
Measurements target = new Measurements(calculatorM.Object);
double length = target.ComputeLength(linestring);
Assert.Equal(0, length);
}
public void ComputeDistance_PointLineString_ReturnsNaNIfLineStringIsEmpty()
{
Point point = new Point(new Coordinate(10.1, 20.1));
LineString linestring = new LineString();
Mock<IDimensionsCalculator> calculatorM = new Mock<IDimensionsCalculator>();
Measurements target = new Measurements(calculatorM.Object);
double distance = target.ComputeDistance(point, linestring);
Assert.True(double.IsNaN(distance));
}
