public void MemoryStream_Lines_2_Trailing_NewLine_BufferSize_3()
{
const int bufferSize = 3;
Encoding encoding = Encoding.Unicode;
TestProbe owner = CreateTestProbe(name: "owner");
MemoryStream stream = CreateMemoryStream("ABCDE\nFGHIJ\n", encoding);
IActorRef streamLines = ActorOf(
StreamLines.Create("lines-2-buffer-size-3", owner, stream, encoding, bufferSize)
);
Within(TimeSpan.FromSeconds(5), () =>
{
owner.ExpectMsg <StreamLines.StreamLine>(streamLine =>
{
Assert.Equal("ABCDE", streamLine.Line);
});
owner.ExpectMsg <StreamLines.StreamLine>(streamLine =>
{
Assert.Equal("FGHIJ", streamLine.Line);
});
owner.ExpectMsg <StreamLines.EndOfStream>();
owner.ExpectNoMsg();
});
}
public void MemoryStream_JustNewLines_3_BufferSize_2()
{
const int bufferSize = 2;
Encoding encoding = Encoding.Unicode;
TestProbe owner = CreateTestProbe(name: "owner");
MemoryStream stream = CreateMemoryStream("\n\n\n", encoding);
IActorRef streamLines = ActorOf(
StreamLines.Create("just-new-lines-3-buffer-size-2", owner, stream, encoding, bufferSize),
name: "stream-lines"
);
Within(TimeSpan.FromSeconds(5), () =>
{
owner.ExpectMsg <StreamLines.StreamLine>(streamLine =>
{
Assert.Equal(String.Empty, streamLine.Line);
});
owner.ExpectMsg <StreamLines.StreamLine>(streamLine =>
{
Assert.Equal(String.Empty, streamLine.Line);
});
owner.ExpectMsg <StreamLines.StreamLine>(streamLine =>
{
Assert.Equal(String.Empty, streamLine.Line);
});
owner.ExpectMsg <StreamLines.EndOfStream>();
owner.ExpectNoMsg();
});
}
void Transform()
{
async_transform = new TransformationAsync(AsyncTransform);
res_list = new List <IAsyncResult>();
foreach (List <DataPoint> sllb in StreamLinesBase)
{
StreamLines.Add(new List <DataPoint>());
res_list.Add(async_transform.BeginInvoke(sllb, StreamLines[StreamLines.Count - 1], null, null));
}
while (!res_list.IsAllThreadsCompleted())
{
}
g.DrawCurve(new List <DataPoint>()
{
new DataPoint(-5, 0), new DataPoint(-w.a, 0)
}, 3, OxyColors.Black);
g.DrawCurve(new List <DataPoint>()
{
new DataPoint(w.a, 0), new DataPoint(-w.a + w.R, 0)
}, 3, OxyColors.Black);
g.DrawCurve(new List <DataPoint>()
{
new DataPoint(w.a + w.R, 0), new DataPoint(10, 0)
}, 3, OxyColors.Black);
if (w.Sh1 == 0 && w.Sh2 == 0)
{
g.DrawCurve(new List <DataPoint>()
{
new DataPoint(0.5 * (w.a + (-w.a + w.R)), 0), new DataPoint(0.5 * (w.a + (-w.a + w.R)), 10)
}, 3, OxyColors.Black);
}
res_list = null;
}
public List <Thread> PrepareField(ManualResetEvent notifier, StreamLines sls, int maxThreads)
{
List <StreamLine> streamLines = sls.GetStreamLines();
if (streamLines.Count > 0)
{
bulkList = new List <SeedPoint>(streamLines.Count * streamLines[0].Points.Count);
}
else
{
Debug.WriteLine("[WARNING] No streamsLines were created previously");
bulkList = new List <SeedPoint>();
}
double minFTLE = double.PositiveInfinity;
double maxFTLE = double.NegativeInfinity;
foreach (StreamLine sl in streamLines)
{
foreach (SeedPoint sp in sl.Points)
{
if (!double.IsNaN(sp.FTLE))
{
if (sp.FTLE < minFTLE)
{
minFTLE = sp.FTLE;
}
if (sp.FTLE > maxFTLE)
{
maxFTLE = sp.FTLE;
}
}
}
}
Debug.WriteLine("MinFTLE: " + minFTLE + "; MaxFTLE: " + maxFTLE);
foreach (StreamLine sl in streamLines)
{
foreach (SeedPoint sp in sl.Points)
{
if (double.IsNaN(sp.FTLE))
{
sp.FTLE = maxFTLE;
}
}
}
List <Thread> threads = new List <Thread>(streamLines.Count);
semaphore = new Semaphore(maxThreads, maxThreads);
foreach (StreamLine sl in streamLines)
{
Thread t = new Thread(AnalyzeLine);
t.Start(new List <object> {
sl, notifier
});
threads.Add(t);
}
return(threads);
}
/// <summary>
/// Create a new <see cref="DockerEventParser"/> actor.
/// </summary>
/// <param name="correlationId">
/// The message correlation Id that will be sent with the stream data.
/// </param>
/// <param name="owner">
/// The actor that owns the <see cref="DockerEventParser"/> actor (this actor will receive the stream data).
/// </param>
/// <param name="stream">
/// The <see cref="Stream"/> to read from.
/// </param>
/// <param name="bufferSize">
/// The buffer size to use when reading from the stream.
/// </param>
public DockerEventParser(string correlationId, IActorRef owner, Stream stream, int bufferSize)
{
if (String.IsNullOrWhiteSpace(correlationId))
{
throw new ArgumentException($"Argument cannot be null, empty, or entirely composed of whitespace: {nameof(correlationId)}.", nameof(correlationId));
}
if (owner == null)
{
throw new ArgumentNullException(nameof(owner));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
_owner = owner;
_streamLinesProps = StreamLines.Create(correlationId, Self, stream, Encoding.ASCII, bufferSize);
Receive <StreamLines.StreamLine>(streamLine =>
{
var parsedEvent = DockerEvent.FromJson(streamLine.Line, correlationId);
_owner.Tell(parsedEvent);
});
Receive <ReadStream.StreamError>(error =>
{
_owner.Tell(error);
});
Receive <Terminated>(terminated =>
{
if (terminated.ActorRef.Equals(_owner))
{
Log.Debug("Owner '{0}' terminated.", _owner);
Context.Stop(Self);
}
else if (terminated.ActorRef.Equals(_streamLines))
{
Log.Debug("Streamer '{0}' terminated.", _streamLines);
Context.Stop(Self);
}
else
{
Unhandled(terminated);
}
});
}
void Transform()
{
async_transform = new TransformationAsync(AsyncTransform);
res_list = new List <IAsyncResult>();
foreach (List <DataPoint> sllb in StreamLinesBase)
{
StreamLines.Add(new List <DataPoint>());
res_list.Add(async_transform.BeginInvoke(sllb, StreamLines[StreamLines.Count - 1], null, null));
}
while (!res_list.IsAllThreadsCompleted())
{
}
res_list = null;
}
void FindAllStreamLines()
{
async_full = new FullBuildAsync(AsyncFullBuild);
res_list = new List <IAsyncResult>();
for (double y = y_min + h; y <= y_max - h; y += h)
{
StreamLines.Add(new List <DataPoint>());
StreamLinesBase.Add(new List <DataPoint>());
res_list.Add(async_full.BeginInvoke(StreamLinesBase[StreamLinesBase.Count - 1], StreamLines[StreamLines.Count - 1], y, null, null));
}
while (!res_list.IsAllThreadsCompleted())
{
}
res_list = null;
}
public Advection(InputDataSet ids, StreamLines sls)
{
IDS = ids;
SLS = sls;
}
private void MakeCalculations(object sender, DoWorkEventArgs e)
{
List <Thread> threads;
ManualResetEvent notifier = new ManualResetEvent(false);
BackgroundWorker worker = sender as BackgroundWorker;
worker.ReportProgress(0);
Debug.WriteLine("Start doing work!");
sls = new StreamLines();
Advection adv = new Advection(ids, sls);
// start advection routine
float radius = float.Parse(this.avDistance.Text) / 2;
int steps = int.Parse(this.steps.Text);
double dt = double.Parse(this.dt.Text);
List <Point> entryPoints = new List <Point>();
int segments = 20; //segments => points = segments - 1 + end_point //TODO
foreach (List <Point> line in picture.Lines)
{
Point last = null;
foreach (Point p in line)
{
if (last != null)
{
//interpolate a line
for (int i = 1; i < segments; i++)
{
float ratio = (float)i / segments;
Vector3 pos = new Vector3(
((p.Pos.X - last.Pos.X) * ratio) + last.Pos.X,
((p.Pos.Y - last.Pos.Y) * ratio) + last.Pos.Y,
((p.Pos.Z - last.Pos.Z) * ratio) + last.Pos.Z
);
entryPoints.Add(ids.GetPoint(pos));
}
}
entryPoints.Add(p);
last = p;
}
}
Debug.WriteLine("N-points: " + entryPoints.Count);
threads = adv.Start(radius, steps, dt, dir, entryPoints, 40, notifier, worker); //TODO
Debug.WriteLine("Threads are creared, waiting untilthey all die");
int threadMax = threads.Count;
worker.ReportProgress(0);
while (threads.Count > 0)
{
notifier.WaitOne(2000);
notifier.Reset();
foreach (Thread t in threads.ToList())
{
if (!t.IsAlive)
{
threads.Remove(t);
}
}
worker.ReportProgress((threadMax - threads.Count) * 1000 / threadMax);
}
worker.ReportProgress(0);
Debug.WriteLine("StreamLines were calculated");
Debug.WriteLine("Start creating uniform FTLE field");
int resolution = int.Parse(this.resolution.Text);
FTLEField field = new FTLEField(ids, resolution);
threads = field.PrepareField(notifier, sls, 40);
threadMax = threads.Count;
while (threads.Count > 0)
{
notifier.WaitOne(2000);
notifier.Reset();
foreach (Thread t in threads.ToList())
{
if (!t.IsAlive)
{
threads.Remove(t);
}
}
worker.ReportProgress((threadMax - threads.Count) * 1000 / threadMax);
Debug.WriteLine("threads.Count " + threads.Count + " Max " + threadMax +
" Fraction " + ((threadMax - threads.Count) * 1000 / threadMax) + "/" + 1000);
}
worker.ReportProgress(0);
threads = field.Start(notifier, resolution, 40);
Debug.WriteLine("Threads are done, waiting for their end");
threadMax = threads.Count;
while (threads.Count > 0)
{
notifier.WaitOne(2000);
notifier.Reset();
foreach (Thread t in threads.ToList())
{
if (!t.IsAlive)
{
threads.Remove(t);
}
}
worker.ReportProgress((threadMax - threads.Count) * 1000 / threadMax);
Debug.WriteLine("threads.Count " + threads.Count + " Max " + threadMax +
" Fraction " + ((threadMax - threads.Count) * 1000 / threadMax) + "/" + 1000);
}
worker.ReportProgress(0);
field.CreateSquares(resolution, worker);
field.Serialize(selectOutputFolderDialog.SelectedPath, worker);
Debug.WriteLine("All done!");
}
