public void Should_works_disconnected()
{
CreateEnvironmentNode("default");
CreateApplicationNode("default", "application");
CreateReplicaNode(new ReplicaInfo("default", "application", "https://github.com/vostok"));
using (var storage = GetApplicationsStorage())
{
var properties = new Dictionary <string, string>
{
{ "key", "value" }
};
CreateApplicationNode("default", "application", properties);
var expected = ServiceTopology.Build(new List <Uri> {
new Uri("https://github.com/vostok")
}, properties);
ShouldReturnImmediately(storage, "default", "application", expected);
Ensemble.Stop();
ShouldReturnImmediately(storage, "default", "application", expected);
Ensemble.Start();
ShouldReturnImmediately(storage, "default", "application", expected);
}
}
public async Task Should_works_with_multiple_clients()
{
var clients = Enumerable.Range(0, 3).Select(_ => GetClient()).ToList();
var path = "/multiple_clients";
await client.CreateAsync(path, CreateMode.Persistent);
var times = 0;
foreach (var c in clients)
{
await c.SetDataAsync(path, new[] { (byte)++times });
await KillSession(c, Ensemble.ConnectionString);
await c.SetDataAsync(path, new[] { (byte)++times });
}
Ensemble.Stop();
Ensemble.Start();
foreach (var c in clients)
{
var data = await c.GetDataAsync(path);
data.Data.Should().BeEquivalentTo(new[] { (byte)times });
}
}
public void Similarity()
{
Console.WriteLine("start");
double result = Ensemble.Similarity(SimilarityType.Euclidean, System.IO.Directory.GetFiles(@"U:\JICWork\ensemble\xrn4_kmeans_k_4_init_random\", "*labels.csv"));
Console.WriteLine(result);
}
static public void ClearEnsembles()
{
Ensemble.Clear();
EnsemblePrep.Clear();
EnsembleAnnul.Clear();
EnsembleDone.Clear();
}
public void AuditionModel_WhenGivenValidData_StoresValidData()
{
/* Arrange */
// Create a Mocked IHostingEnviornment
var mockHostEnv = new Mock <IHostingEnvironment>();
//Create a Audition Model
var model = new AuditionModel();
//create valid data
var ensemble = new Ensemble();
var audition = new Audition();
var view = "profile";
var profiles = new List <Profile>();
/* Act */
model.Ensemble = ensemble;
model.Audition = audition;
model.ViewType = view;
model.Profiles = profiles;
/* Assert */
Assert.IsType <Ensemble>(model.Ensemble);
Assert.IsType <Audition>(model.Audition);
Assert.IsType <string>(model.ViewType);
Assert.IsAssignableFrom <ICollection <Profile> >(model.Profiles);
}
public void EnsembleDashModel_WhenGivenValidData_StoresValidData()
{
/* Arrange */
// Create a Mocked IHostingEnviornment
var mockHostEnv = new Mock <IHostingEnvironment>();
//Create a Dash Model
var model = new EnsembleDashModel();
//create valid data
var ensemble = new Ensemble();
var members = new List <ProfileEnsemble>();
var auds = new List <Audition>();
var audnums = new Dictionary <int, int>();
/* Act */
model.Ensemble = ensemble;
model.Members = members;
model.AuditionList = auds;
model.AuditionNumbers = audnums;
/* Assert */
Assert.IsType <Ensemble>(model.Ensemble);
Assert.IsType <List <ProfileEnsemble> >(model.Members);
Assert.IsType <List <Audition> >(model.AuditionList);
Assert.IsType <Dictionary <int, int> >(model.AuditionNumbers);
}
// GET: Cart/Select
//Given an ensemble, this matches every player with the parts they can play.
public IActionResult Select(int id)
{
Ensemble ensemble = _context.Ensemble.Find(id);
if (ensemble == null)
{
return(NotFound());
}
CheckOutSelect outSelect = new CheckOutSelect();
//Find all musicians that are in the selected ensemble.
outSelect.AddAllMusicians(from musician in _context.Musician
where _context.EnsemblePlayers.Any(e => e.EnsembleId == id && e.MusicianId == musician.MusicianId)
select musician);
//Find all scores that are being checked out.
outSelect.AddAllScores(Cart.ShoppingCart);
//Find all pieces that are in some score being checked out.
outSelect.AddAllPieces(from piece in _context.Piece
where Cart.ShoppingCart.Any(e => e.ScoreId == piece.ScoreId)
select piece);
outSelect.MatchMusicians();
return(View(outSelect));
}
public void EnsembleModel_WhenGivenValidData_StoresValidData()
{
/* Arrange */
// Create a Mocked IHostingEnviornment
var mockHostEnv = new Mock <IHostingEnvironment>();
//Create a Ensemble Model
var model = new EnsembleModel();
//create valid data
var ensemble = new Ensemble();
var profiles = new List <Profile>();
var instruments = new List <SelectListItem>();
var selected = new List <string>();
var auds = new HashSet <Audition>();
/* Act */
model.Ensemble = ensemble;
model.Profiles = profiles;
model.Instruments = instruments;
model.SelectedInsId = selected;
model.Audition = auds;
/* Assert */
Assert.IsType <Ensemble>(model.Ensemble);
Assert.IsType <List <Profile> >(model.Profiles);
Assert.IsType <List <string> >(model.SelectedInsId);
Assert.IsAssignableFrom <ICollection <Audition> >(model.Audition);
}
public void EnsembleTable_WhenGivenValidData_StoresValidData()
{
/* Arrange */
System.DateTime testdate = new System.DateTime(2019, 5, 2);
/* Act */
Ensemble ensemble = new Ensemble()
{
EnsembleId = 21, UserId = 1,
Ensemble_Name = "Test Venue",
Formed_Date = testdate,
Type = "Garage Band", Genre = "Jazz",
Pic_Url = "/uploads/image.png", Bio = "I am a test ensemble",
City = "Chicago", State = "IL"
};
/* Assert */
Assert.Equal(21, ensemble.EnsembleId);
Assert.Equal(1, ensemble.UserId);
Assert.Equal("Test Venue", ensemble.Ensemble_Name);
Assert.Equal(testdate, ensemble.Formed_Date);
Assert.Equal("Garage Band", ensemble.Type);
Assert.Equal("Jazz", ensemble.Genre);
Assert.Equal("/uploads/image.png", ensemble.Pic_Url);
Assert.Equal("I am a test ensemble", ensemble.Bio);
Assert.Equal("Chicago", ensemble.City);
Assert.Equal("IL", ensemble.State);
}
internal override InternalRegressionTree TrainingIteration(IChannel ch, bool[] activeFeatures)
{
Contracts.CheckValue(ch, nameof(ch));
AgdScoreTracker trainingScores = TrainingScores as AgdScoreTracker;
//First Let's make XK=YK as we want to fit YK and LineSearch YK
// and call base class that uses fits XK (in our case will fir YK thanks to the swap)
var xk = trainingScores.XK;
trainingScores.XK = trainingScores.YK;
trainingScores.YK = null;
//Invoke standard gradient descent on YK rather than XK(Scores)
InternalRegressionTree tree = base.TrainingIteration(ch, activeFeatures);
//Reverse the XK/YK swap
trainingScores.YK = trainingScores.XK;
trainingScores.XK = xk;
if (tree == null)
{
return(null); // No tree was actually learnt. Give up.
}
// ... and update the training scores that we omitted from update
// in AcceleratedGradientDescent.UpdateScores
// Here we could use faster way of comuting train scores taking advantage of scores precompited by LineSearch
// But that would make the code here even more difficult/complex
trainingScores.AddScores(tree, TreeLearner.Partitioning, 1.0);
//Now rescale all previous trees based on ratio of new_desired_tree_scale/previous_tree_scale
for (int t = 0; t < Ensemble.NumTrees - 1; t++)
{
Ensemble.GetTreeAt(t).ScaleOutputsBy(AgdScoreTracker.TreeMultiplier(t, Ensemble.NumTrees) / AgdScoreTracker.TreeMultiplier(t, Ensemble.NumTrees - 1));
}
return(tree);
}
public List <ServiceDetails> GetMultiplexInformation()
{
IntPtr data;
while (true)
{
var result = filterInterface.GetMultiplexInformation(out data);
if ((int)result == 2)
{
Thread.Sleep(50);
}
else
{
break;
}
}
var ensemble = Ensemble.FromIntPtr(data);
var abbreviatedLabel = ensemble.ShortLabel;
var date = ensemble.DateTime.Time;
var serviceDetails = new List <ServiceDetails>();
foreach (var service in ensemble.Services)
{
foreach (var audioNode in service.AudioNodes)
{
if (audioNode.ServiceType == AudioType.AacAudio)
{
continue;
}
serviceDetails.Add(new ServiceDetails(service.Label, audioNode));
}
}
return(serviceDetails);
}
public async Task <IActionResult> Edit(int id, [Bind("EnsembleId,Type")] Ensemble ensemble)
{
if (id != ensemble.EnsembleId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(ensemble);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnsembleExists(ensemble.EnsembleId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(ensemble));
}
public void GetConnectedClient_should_return_new_after_disconnect_and_timeout()
{
var holder = GetClientHolder(Ensemble.ConnectionString);
var observer = GetObserver(holder);
WaitForNewConnectedClient(holder);
Ensemble.Stop();
WaitForDisconnectedState(holder);
Thread.Sleep(DefaultTimeout + 1.Seconds());
holder.SessionId.Should().Be(0);
Ensemble.Start();
WaitForNewConnectedClient(holder);
var sid = holder.SessionId;
holder.SessionId.Should().NotBe(0);
Thread.Sleep(DefaultTimeout + 1.Seconds());
holder.SessionId.Should().Be(sid);
VerifyObserverMessages(
observer,
ConnectionState.Disconnected,
ConnectionState.Connected,
ConnectionState.Disconnected,
ConnectionState.Connected
);
}
/// <summary>
/// Screen the data for any velocities above the surface.
/// This will check if Range Track data exist. If it does not,
/// then we do not know the surface range. It will then check that a
/// Range track range is given. If all the range values are bad,
/// then we do not know the surface. If they are good, take the average
/// of the range. Then determine which bin is located at and surface the water.
/// Then mark all the velocities at and above the surface bad.
/// </summary>
/// <param name="ensemble">Ensemble to screen.</param>
/// <param name="prevSurface">Previous Good range.</param>
/// <returns>True = Screen could be done.</returns>
public static bool Screen(ref DataSet.Ensemble ensemble, double prevSurface = DataSet.Ensemble.BAD_RANGE)
{
if (ensemble != null)
{
// Ensure bottom track data exist
if (ensemble.IsRangeTrackingAvail && // Needed for Range Tracking Range
ensemble.IsAncillaryAvail && // Needed for Blank and Bin Size
ensemble.IsEnsembleAvail // Needed for number of bins
)
{
// Get the bottom
double surface = ensemble.RangeTrackingData.GetAverageRange();
// Ensure we found a bottom
if (surface == DataSet.Ensemble.BAD_RANGE && prevSurface == DataSet.Ensemble.BAD_RANGE)
{
return(false);
}
else if (surface == DataSet.Ensemble.BAD_RANGE && prevSurface != DataSet.Ensemble.BAD_RANGE)
{
// PrevBottom is good, so use it
surface = prevSurface;
}
// Get the bottom bin
int bottomBin = Ensemble.GetBottomBin(ensemble, surface);
// Check if the bottom bin is at or beyond
// the number of bins
if (bottomBin < 0 || bottomBin >= ensemble.EnsembleData.NumBins)
{
return(true);
}
// Set all the velocities bad
// for the bins below the bottom.
// This will also set the Good Pings bad
for (int bin = bottomBin; bin < ensemble.EnsembleData.NumBins; bin++)
{
// Set the velocities bad
EnsembleHelper.SetVelocitiesBad(ref ensemble, bin);
// Set the Correlation bad
EnsembleHelper.SetCorelationBad(ref ensemble, bin);
// Set the Amplitude bad
EnsembleHelper.SetAmplitudeBad(ref ensemble, bin);
}
return(true);
}
else
{
return(false);
}
}
return(false);
}
/// <inheritdoc />
public SabberStoneAction Act(SabberStoneState state)
{
var timer = System.Diagnostics.Stopwatch.StartNew();
var gameState = (SabberStoneState)state.Copy();
if (_debug)
{
Console.WriteLine();
}
if (_debug)
{
Console.WriteLine(Name());
}
if (_debug)
{
Console.WriteLine($"Starting a NMCTS search in turn {(gameState.Game.Turn + 1) / 2}");
}
// Setup and start the ensemble-search
EnsembleSolutions = new List <SabberStoneAction>();
var search = (NMCTS <List <SabberStoneAction>, SabberStoneState, SabberStoneAction, object, SabberStoneAction>)Builder.Build();
var context = SearchContext <List <SabberStoneAction>, SabberStoneState, SabberStoneAction, object, SabberStoneAction> .GameSearchSetup(GameLogic, EnsembleSolutions, gameState, null, search);
Ensemble.EnsembleSearch(context, Searcher.Search, EnsembleSize);
IterationsSpent = EnsembleSolutions.Sum(i => i.BudgetUsed);
// Determine the best tasks to play based on the ensemble search, or just take the one in case of a single search.
var solution = EnsembleSize > 1 ? Searcher.VoteForSolution(EnsembleSolutions, state) : EnsembleSolutions.First();
if (_debug)
{
Console.WriteLine();
}
if (_debug)
{
Console.WriteLine($"NMCTS returned with solution: {solution}");
}
if (_debug)
{
Console.WriteLine($"My total calculation time was: {timer.ElapsedMilliseconds} ms.");
}
// Check if the solution is a complete action.
if (!solution.IsComplete())
{
// Otherwise add an End-Turn task before returning.
if (_debug)
{
Console.WriteLine("Solution was an incomplete action; adding End-Turn task.");
}
solution.Tasks.Add((SabberStonePlayerTask)EndTurnTask.Any(Player));
}
if (_debug)
{
Console.WriteLine();
}
return(solution);
}
public async Task Should_return_NotConnected()
{
Ensemble.Stop();
WaitForDisconnectedState(client);
var result = await client.CreateAsync("/return_connection_loss", CreateMode.Persistent);
result.Status.Should().Be(ZooKeeperStatus.NotConnected);
}
internal override InternalRegressionTree TrainingIteration(IChannel ch, bool[] activeFeatures)
{
Contracts.CheckValue(ch, nameof(ch));
// Fit a regression tree to the gradient using least squares.
InternalRegressionTree tree = TreeLearner.FitTargets(ch, activeFeatures, AdjustTargetsAndSetWeights(ch));
if (tree == null)
{
return(null); // Could not learn a tree. Exit.
}
// Adjust output values of tree by performing a Newton step.
// REVIEW: This should be part of OptimizingAlgorithm.
using (Timer.Time(TimerEvent.TreeLearnerAdjustTreeOutputs))
{
double[] backupScores = null;
// when doing dropouts we need to replace the TrainingScores with the scores without the dropped trees
if (DropoutRate > 0)
{
backupScores = TrainingScores.Scores;
TrainingScores.Scores = _scores;
}
if (AdjustTreeOutputsOverride != null)
{
AdjustTreeOutputsOverride.AdjustTreeOutputs(ch, tree, TreeLearner.Partitioning, TrainingScores);
}
else if (ObjectiveFunction is IStepSearch)
{
(ObjectiveFunction as IStepSearch).AdjustTreeOutputs(ch, tree, TreeLearner.Partitioning, TrainingScores);
}
else
{
throw ch.Except("No AdjustTreeOutputs defined. Objective function should define IStepSearch or AdjustTreeOutputsOverride should be set");
}
if (DropoutRate > 0)
{
// Returning the original scores.
TrainingScores.Scores = backupScores;
}
}
if (Smoothing != 0.0)
{
SmoothTree(tree, Smoothing);
UseFastTrainingScoresUpdate = false;
}
if (DropoutRate > 0)
{
// Don't do shrinkage if you do dropouts.
double scaling = (1.0 / (1.0 + _numberOfDroppedTrees));
tree.ScaleOutputsBy(scaling);
_treeScores.Add(tree.GetOutputs(TrainingScores.Dataset));
}
UpdateAllScores(ch, tree);
Ensemble.AddTree(tree);
return(tree);
}
public void OnConnectionStateChanged_should_observe_disconnected()
{
var holder = GetClientHolder(Ensemble.ConnectionString);
var observer = GetObserver(holder);
WaitForNewConnectedClient(holder);
Ensemble.Stop();
VerifyObserverMessages(observer, ConnectionState.Disconnected, ConnectionState.Connected, ConnectionState.Disconnected);
}
public void OnConnectionStateChanged_should_observe_disconnected_as_initial_state()
{
Ensemble.Stop();
var holder = GetClientHolder(Ensemble.ConnectionString, 1.Seconds());
var observer = GetObserver(holder);
VerifyObserverMessages(observer, ConnectionState.Disconnected);
}
//GET: Score/Details
//Returns a page displaying all the information about a score.
public async Task <IActionResult> Details(int id)
{
Ensemble ensemble = await _context.Ensemble.FindAsync(id);
if (ensemble == null)
{
return(NotFound());
}
return(View(ensemble));
}
public async Task Should_reconnect()
{
Ensemble.Stop();
WaitForDisconnectedState(client);
Ensemble.Start();
var result = await client.CreateAsync("/reconnect", CreateMode.Persistent);
result.EnsureSuccess();
}
public Predictors <TOutput> Train(Datasets data
, Func <int, double> learningRateSchedule = null // optional: learning rate as a function of iteration (zero-based)
)
{
// For multi class, the number of labels is required.
if (!(PredictionKind != PredictionKind.MultiClassClassification || Objective.NumClass > 1))
{
throw new Exception("LightGBM requires the number of classes to be specified in the parameters for multi-class classification.");
}
if (PredictionKind == PredictionKind.Ranking)
{
if (data.Training.GetGroups() == null)
{
throw new Exception("Require Groups training data for ObjectiveType.LambdaRank");
}
if (data.Validation != null && data.Validation.GetGroups() == null)
{
throw new Exception("Require Groups validation data for ObjectiveType.LambdaRank");
}
}
TrainMetrics.Clear();
ValidMetrics.Clear();
Booster?.Dispose();
Booster = null;
Datasets = data;
var args = GetParameters(data);
Booster = Train(args, data.Training, data.Validation, TrainMetrics, ValidMetrics, learningRateSchedule);
(var model, var argsout) = Booster.GetModel();
TrainedEnsemble = model;
FeatureCount = data.Training.NumFeatures;
// check parameter strings
if (learningRateSchedule != null)
{
argsout.Learning.LearningRate = args.Learning.LearningRate;
}
var strIn = args.ToString();
var strOut = argsout.ToString();
if (strIn != strOut)
{
throw new Exception($"Parameters differ:\n{strIn}\n{strOut}");
}
var managed = CreateManagedPredictor();
var native = CreateNativePredictor();
return(new Predictors <TOutput>(managed, native));
}
private Ensemble GetBinaryEnsemble(int classID)
{
var numClass = Objective.NumClass;
Ensemble res = new Ensemble();
for (int i = classID; i < TrainedEnsemble.NumTrees; i += numClass)
{
res.AddTree(TrainedEnsemble.GetTreeAt(i));
}
return(res);
}
public async Task <IActionResult> Create([Bind("EnsembleId,Type")] Ensemble ensemble)
{
if (ModelState.IsValid)
{
_context.Add(ensemble);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(ensemble));
}
public void GetConnectedClient_should_be_null_after_timeout()
{
Ensemble.Stop();
var holder = GetClientHolder(Ensemble.ConnectionString, 1.Seconds());
holder.GetConnectedClient().ShouldCompleteIn(1.5.Seconds());
holder.ConnectionState.Should().Be(ConnectionState.Disconnected);
holder.SessionId.Should().Be(0);
}
private async Task EnsembleThread(CancellationToken token)
{
while (!token.IsCancellationRequested)
{
await SleepRandom();
Ensemble.Stop();
await SleepRandom();
Ensemble.Start();
}
}
private void calculateButton_Click(object sender, EventArgs e)
{
string[] items = new string[fileListBox.Items.Count];
for (int i = 0; i < items.Length; i++)
{
items[i] = fileListBox.Items[i].ToString();
}
SimilarityType type = SimilarityType.Euclidean;
Enum.TryParse <SimilarityType>(similarityTypeComboBox.SelectedValue.ToString(), out type);
resultTextBox.Text = Ensemble.Similarity(type, items).ToString("0.00000");
}
public override void FinalizeLearning(int bestIteration)
{
if (bestIteration != Ensemble.NumTrees)
{
// Restore multiplier for each tree as it was set during bestIteration
for (int t = 0; t < bestIteration; t++)
{
Ensemble.GetTreeAt(t).ScaleOutputsBy(AgdScoreTracker.TreeMultiplier(t, bestIteration) / AgdScoreTracker.TreeMultiplier(t, Ensemble.NumTrees));
}
}
base.FinalizeLearning(bestIteration);
}
public async Task <IActionResult> EditEnsemble(int id, string button, [Bind("EnsembleId", "EnsembleName", "Year", "Conductor")] Ensemble ensemble)
{
if (button != null)
{
//Delete the ensemble from the database.
if (button.Equals("Delete"))
{
var toDelete = await _context.Ensemble.FindAsync(id);
_context.Remove(toDelete);
IEnumerable <EnsemblePlayers> eps = _context.EnsemblePlayers
.Where(s => s.EnsembleId == id).ToList();
foreach (EnsemblePlayers ep in eps)
{
System.Diagnostics.Debug.WriteLine("DELETING");
System.Diagnostics.Debug.WriteLine(ep);
_context.EnsemblePlayers.Remove(ep);
await _context.SaveChangesAsync();
System.Diagnostics.Debug.WriteLine("AFTER DELETE");
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
//Update the ensemble
if (ModelState.IsValid)
{
try
{
ensemble.EnsembleId = id;
_context.Update(ensemble);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnsembleExists(ensemble.EnsembleId))
{
return(NotFound());
}
else
{
throw;
}
}
//Success
return(RedirectToAction(nameof(Index)));
}
return(View(ensemble));
}
// GET: Ensemble/Musicians
//Given an ensemble id, return a list of all musicians who play in that ensemble.
public IActionResult Musicians(int id)
{
//Nested query. Select any musician whose id is in an ensemble player record where the ensemble id for that record matches the id supplied.
IEnumerable <Musician> musicians = from musician in _context.Musician
where (from ensemblePlayer in _context.EnsemblePlayers
where ensemblePlayer.EnsembleId == id
select ensemblePlayer).Any(e => e.MusicianId == musician.MusicianId)
select musician;
Ensemble ensemble = _context.Ensemble.Find(id);
EnsembleAndMusicians eAndM = new EnsembleAndMusicians(ensemble, musicians);
return(View(eAndM));
}
/// <summary>
/// Output the System Setup dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>System Setup DataSet data in CSV format.</returns>
public static string WriteSystemSetupData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsSystemSetupAvail)
{
sb.Append(ensemble.SystemSetupData.BtSamplesPerSecond);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.BtSystemFreqHz);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.BtCPCE);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.BtNCE);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.BtRepeatN);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.WpSamplesPerSecond);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.WpSystemFreqHz);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.WpCPCE);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.WpNCE);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.WpRepeatN);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.WpLagSamples);
sb.Append(",");
sb.Append(ensemble.SystemSetupData.Voltage);
}
else
{
sb.Append(",,,,,,,,,,,");
}
return sb.ToString();
}
/// <summary>
/// Output the Range Tracking dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Range Tracking DataSet data in CSV format.</returns>
public static string WriteRangeTrackingData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsRangeTrackingAvail)
{
if (ensemble.RangeTrackingData.SNR.Length >= 1)
{
sb.Append(ensemble.RangeTrackingData.SNR[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.SNR.Length >= 2)
{
sb.Append(ensemble.RangeTrackingData.SNR[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.SNR.Length >= 3)
{
sb.Append(ensemble.RangeTrackingData.SNR[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.SNR.Length >= 4)
{
sb.Append(ensemble.RangeTrackingData.SNR[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.Range.Length >= 1)
{
sb.Append(ensemble.RangeTrackingData.Range[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.Range.Length >= 2)
{
sb.Append(ensemble.RangeTrackingData.Range[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.Range.Length >= 3)
{
sb.Append(ensemble.RangeTrackingData.Range[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.Range.Length >= 4)
{
sb.Append(ensemble.RangeTrackingData.Range[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.Pings.Length >= 1)
{
sb.Append(ensemble.RangeTrackingData.Pings[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.Pings.Length >= 2)
{
sb.Append(ensemble.RangeTrackingData.Pings[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.Pings.Length >= 3)
{
sb.Append(ensemble.RangeTrackingData.Pings[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.RangeTrackingData.Pings.Length >= 4)
{
sb.Append(ensemble.RangeTrackingData.Pings[3].ToString(new CultureInfo("en-US")));
//sb.Append(",");
}
else
{
//sb.Append(",");
}
}
else
{
sb.Append(",,,,,,,,,,,");
}
return sb.ToString();
}
/// <summary>
/// Output the Amplitude dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <param name="options">Export Options.</param>
/// <returns>Amplitude DataSet data in CSV format.</returns>
public static string WriteAmplitudeData(Ensemble ensemble, ExportOptions options)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsAmplitudeAvail)
{
for (int bin = options.AmplitudeMinBin; bin < options.AmplitudeMaxBin + 1; bin++)
{
for (int beam = 0; beam < ensemble.AmplitudeData.AmplitudeData.GetLength(1); beam++)
{
sb.Append(string.Format("{0},", ensemble.AmplitudeData.AmplitudeData[bin, beam].ToString(new CultureInfo("en-US"))));
}
// If a vertical beam
if (ensemble.AmplitudeData.AmplitudeData.GetLength(1) <= 1)
{
sb.Append(",,,");
}
}
}
else
{
// Put blank data
for (int bin = options.AmplitudeMinBin; bin < options.AmplitudeMaxBin + 1; bin++)
{
sb.Append(",,,,");
}
}
return sb.ToString();
}
/// <summary>
/// Output the Gage Height dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Gage Height DataSet data in CSV format.</returns>
public static string WriteGageHeightData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsGageHeightAvail)
{
sb.Append(ensemble.GageHeightData.Status);
sb.Append(",");
sb.Append(ensemble.GageHeightData.AvgRange.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.StdDev.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.AvgSN.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.N.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.Salinity.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.Pressure.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.Depth.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.WaterTemp.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.SystemTemp.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.SoS.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.Heading.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.Pitch.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.GageHeightData.Roll.ToString(new CultureInfo("en-US")));
}
else
{
sb.Append(",,,,,,,,,,,,,");
}
return sb.ToString();
}
/// <summary>
/// Output the Bottom Track dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Bottom Track DataSet data in CSV format.</returns>
public static string WriteBottomTrackData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsBottomTrackAvail)
{
sb.Append(ensemble.BottomTrackData.FirstPingTime.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.LastPingTime.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Heading.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Pitch.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Roll.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.WaterTemp.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.SystemTemp.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Salinity.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Pressure.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.TransducerDepth.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.SpeedOfSound.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Status.ToString().Replace(",", ";")); // Replace the , with ; so it does not mess up the seperation
sb.Append(",");
sb.Append(ensemble.BottomTrackData.NumBeams.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.BottomTrackData.ActualPingCount.ToString(new CultureInfo("en-US")));
sb.Append(",");
#region Range Tracking
if (ensemble.BottomTrackData.Range.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.Range[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.Range.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.Range[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.Range.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.Range[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.Range.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.Range[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
#endregion
#region SNR
if (ensemble.BottomTrackData.SNR.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.SNR[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.SNR.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.SNR[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.SNR.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.SNR[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.SNR.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.SNR[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
#endregion
#region Amplitude
if (ensemble.BottomTrackData.Amplitude.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.Amplitude[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.Amplitude.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.Amplitude[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.Amplitude.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.Amplitude[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.Amplitude.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.Amplitude[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
#endregion
#region Correlation
if (ensemble.BottomTrackData.Correlation.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.Correlation[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.Correlation.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.Correlation[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.Correlation.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.Correlation[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.Correlation.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.Correlation[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
#endregion
#region Beam Velocity
if (ensemble.BottomTrackData.BeamVelocity.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.BeamVelocity[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.BeamVelocity.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.BeamVelocity[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.BeamVelocity.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.BeamVelocity[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.BeamVelocity.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.BeamVelocity[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
#endregion
#region BeamGood
if (ensemble.BottomTrackData.BeamGood.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.BeamGood[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.BeamGood.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.BeamGood[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.BeamGood.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.BeamGood[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.BeamGood.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.BeamGood[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
#endregion
#region Instrument Velocity
if (ensemble.BottomTrackData.InstrumentVelocity.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.InstrumentVelocity[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.InstrumentVelocity.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.InstrumentVelocity[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.InstrumentVelocity.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.InstrumentVelocity[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.InstrumentVelocity.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.InstrumentVelocity[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
#endregion
#region Instrument Good
if (ensemble.BottomTrackData.InstrumentGood.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.InstrumentGood[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.InstrumentGood.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.InstrumentGood[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.InstrumentGood.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.InstrumentGood[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.InstrumentGood.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.InstrumentGood[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
#endregion
#region Earth Velocity
if (ensemble.BottomTrackData.EarthVelocity.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.EarthVelocity[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.EarthVelocity.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.EarthVelocity[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.EarthVelocity.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.EarthVelocity[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.EarthVelocity.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.EarthVelocity[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
#endregion
#region Earth Good
if (ensemble.BottomTrackData.EarthGood.Length >= 1)
{
sb.Append(ensemble.BottomTrackData.EarthGood[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.EarthGood.Length >= 2)
{
sb.Append(ensemble.BottomTrackData.EarthGood[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.EarthGood.Length >= 3)
{
sb.Append(ensemble.BottomTrackData.EarthGood[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
if (ensemble.BottomTrackData.EarthGood.Length >= 4)
{
sb.Append(ensemble.BottomTrackData.EarthGood[3].ToString(new CultureInfo("en-US")));
//sb.Append(",");
}
else
{
//sb.Append(",");
}
#endregion
}
else
{
sb.Append(",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,");
}
return sb.ToString();
}
/// <summary>
/// Output the Bottom Track dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Bottom Track DataSet data in CSV format.</returns>
public static string WriteBottomTrackData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsBottomTrackAvail)
{
sb.Append(ensemble.BottomTrackData.FirstPingTime);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.LastPingTime);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Heading);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Pitch);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Roll);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.WaterTemp);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.SystemTemp);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Salinity);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Pressure);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.TransducerDepth);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.SpeedOfSound);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Status.ToString().Replace(",", ";")); // Replace the , with ; so it does not mess up the seperation
sb.Append(",");
sb.Append(ensemble.BottomTrackData.NumBeams);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.ActualPingCount);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Range[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Range[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Range[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Range[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.SNR[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.SNR[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.SNR[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.SNR[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Amplitude[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Amplitude[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Amplitude[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Amplitude[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Correlation[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Correlation[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Correlation[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.Correlation[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.BeamVelocity[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.BeamVelocity[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.BeamVelocity[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.BeamVelocity[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.BeamGood[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.BeamGood[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.BeamGood[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.BeamGood[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.InstrumentVelocity[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.InstrumentVelocity[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.InstrumentVelocity[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.InstrumentVelocity[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.InstrumentGood[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.InstrumentGood[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.InstrumentGood[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.InstrumentGood[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.EarthVelocity[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.EarthVelocity[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.EarthVelocity[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.EarthVelocity[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.EarthGood[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.EarthGood[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.EarthGood[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackData.EarthGood[3]);
}
else
{
sb.Append(",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,");
}
return sb.ToString();
}
/// <summary>
/// Output the Bottom Track Engineering dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Bottom Track Engineering DataSet data in CSV format.</returns>
public static string WriteBottomTrackEngineeringData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsBottomTrackEngineeringAvail)
{
sb.Append(ensemble.BottomTrackEngineeringData.SamplesPerSecond);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.SystemFreqHz);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.LagSamples);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.CPCE);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.NCE);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.RepeatN);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbHz[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbHz[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbHz[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbHz[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbVel[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbVel[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbVel[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbVel[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbAmp[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbAmp[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbAmp[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbAmp[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbCor[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbCor[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbCor[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbCor[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbSNR[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbSNR[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbSNR[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.AmbSNR[3]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.LagUsed[0]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.LagUsed[1]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.LagUsed[2]);
sb.Append(",");
sb.Append(ensemble.BottomTrackEngineeringData.LagUsed[3]);
}
else
{
sb.Append(",,,,,,,,,,,,,,,,,,,,,,,,,,,,,");
}
return sb.ToString();
}
/// <summary>
/// Output the Ancillary dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Ancillary DataSet data in CSV format.</returns>
public static string WriteAncillaryData(Ensemble ensemble)
{
if (ensemble.IsAncillaryAvail)
{
StringBuilder sb = new StringBuilder();
sb.Append(ensemble.AncillaryData.FirstBinRange.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.BinSize.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.FirstPingTime.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.LastPingTime.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.Heading.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.Pitch.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.Roll.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.WaterTemp.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.SystemTemp.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.Salinity.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.Pressure.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.TransducerDepth.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.AncillaryData.SpeedOfSound.ToString(new CultureInfo("en-US")));
return sb.ToString();
}
return ",,,,,,,,,,,,";
}
/// <summary>
/// Output the Beam Velocity dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <param name="options">Export Options.</param>
/// <returns>Beam Velocity DataSet data in CSV format.</returns>
public static string WriteBeamVelocityData(Ensemble ensemble, ExportOptions options)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsBeamVelocityAvail)
{
for (int bin = options.BeamMinBin; bin < options.BeamMaxBin + 1; bin++)
{
for (int beam = 0; beam < ensemble.BeamVelocityData.BeamVelocityData.GetLength(1); beam++)
{
sb.Append(string.Format("{0},", ensemble.BeamVelocityData.BeamVelocityData[bin, beam]));
}
// If a vertical beam
if (ensemble.BeamVelocityData.BeamVelocityData.GetLength(1) <= 1)
{
sb.Append(",,,");
}
}
}
else
{
// Put blank data
for (int bin = options.BeamMinBin; bin < options.BeamMaxBin + 1; bin++)
{
sb.Append(",,,,");
}
}
return sb.ToString();
}
/// <summary>
/// Output the Profile Engineering dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Profile Engineering DataSet data in CSV format.</returns>
public static string WriteProfileEngineeringData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsProfileEngineeringAvail)
{
sb.Append(ensemble.ProfileEngineeringData.SamplesPerSecond.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.SystemFreqHz.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.LagSamples.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.CPCE.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.NCE.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.RepeatN.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingGap.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingNCE.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingRepeatN.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingLagSamples.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.TRHighGain.ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingVel.Length > 0)
sb.Append(ensemble.ProfileEngineeringData.PrePingVel[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingVel.Length > 1)
sb.Append(ensemble.ProfileEngineeringData.PrePingVel[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingVel.Length > 2)
sb.Append(ensemble.ProfileEngineeringData.PrePingVel[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingVel.Length > 3)
sb.Append(ensemble.ProfileEngineeringData.PrePingVel[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingCor.Length > 0)
sb.Append(ensemble.ProfileEngineeringData.PrePingCor[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingCor.Length > 1)
sb.Append(ensemble.ProfileEngineeringData.PrePingCor[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingCor.Length > 2)
sb.Append(ensemble.ProfileEngineeringData.PrePingCor[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingCor.Length > 3)
sb.Append(ensemble.ProfileEngineeringData.PrePingCor[3].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingAmp.Length > 0)
sb.Append(ensemble.ProfileEngineeringData.PrePingAmp[0].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingAmp.Length > 1)
sb.Append(ensemble.ProfileEngineeringData.PrePingAmp[1].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingAmp.Length > 2)
sb.Append(ensemble.ProfileEngineeringData.PrePingAmp[2].ToString(new CultureInfo("en-US")));
sb.Append(",");
if (ensemble.ProfileEngineeringData.PrePingAmp.Length > 3)
sb.Append(ensemble.ProfileEngineeringData.PrePingAmp[3].ToString(new CultureInfo("en-US")));
}
else
{
sb.Append(",,,,,,,,,,,,,,,,,,,,,,");
}
return sb.ToString();
}
/// <summary>
/// Parse the incoming packet for all the Data Sets.
/// Add the data to a AdcpDataSet variable and
/// return the filled variable when complete.
/// </summary>
/// <param name="binaryEnsemble">Byte array containing data from an ADCP.</param>
/// <returns>Object holding decoded ADCP data.</returns>
private Ensemble DecodeAdcpData(byte[] binaryEnsemble)
{
Ensemble ensemble = new Ensemble();
#region DataSets
if(!ensemble.IsEnsembleAvail)
{
ensemble.EnsembleData = new EnsembleDataSet();
ensemble.IsEnsembleAvail = true;
}
if (!ensemble.IsAncillaryAvail)
{
ensemble.AncillaryData = new AncillaryDataSet();
ensemble.IsAncillaryAvail = true;
}
// Add Bottom Track data
if (!ensemble.IsBottomTrackAvail)
{
ensemble.BottomTrackData = new BottomTrackDataSet();
ensemble.IsBottomTrackAvail = true;
}
// Add DVL dataset
if (!ensemble.IsDvlDataAvail)
{
ensemble.DvlData = new DvlDataSet();
ensemble.IsDvlDataAvail = true;
}
#endregion
#region System Config
// Data Flow Bit
byte data = binaryEnsemble[1];
SystemConfig sysCfg = new SystemConfig();
//sysCfg.VelTransform = GetTransform(value);
//sysCfg.IsTiltUsed = GetTilt(value);
//sysCfg.Is3BeamSolution = Get3BeamSolution(value);
//sysCfg.Frequency = GetFreq(value);
// Set the serial number
ensemble.EnsembleData.SysSerialNumber = SerialNumber.DVL;
ensemble.EnsembleData.SysSerialNumber.RemoveSubsystem(SerialNumber.DVL_Subsystem);
ensemble.EnsembleData.SysSerialNumber.AddSubsystem(sysCfg.Frequency);
#endregion
//#region Speed of Sound
//// Speed of Sound
////ensemble.AncillaryData.SpeedOfSound = MathHelper.LsbMsbUShort(binaryEnsemble[41], binaryEnsemble[42]);
////ensemble.BottomTrackData.SpeedOfSound = MathHelper.LsbMsbUShort(binaryEnsemble[41], binaryEnsemble[42]);
////ensemble.DvlData.SpeedOfSound = MathHelper.LsbMsbUShort(binaryEnsemble[41], binaryEnsemble[42]);
////// Temperature
////ensemble.AncillaryData.WaterTemp = MathHelper.LsbMsbUShort(binaryEnsemble[43], binaryEnsemble[44]) * 0.01f;
////ensemble.BottomTrackData.WaterTemp = MathHelper.LsbMsbUShort(binaryEnsemble[43], binaryEnsemble[44]) * 0.01f;
////ensemble.DvlData.WaterTemp = MathHelper.LsbMsbUShort(binaryEnsemble[43], binaryEnsemble[44]) * 0.01f;
//#endregion
//#region Bottom Track Velcocity
//// X
//if (MathHelper.LsbMsbShort(binaryEnsemble[2], binaryEnsemble[3]) == PD0.BAD_VELOCITY)
//{
// ensemble.BottomTrackData.BeamVelocity[Ensemble.BEAM_0_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.InstrumentVelocity[Ensemble.BEAM_X_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.EarthVelocity[Ensemble.BEAM_EAST_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.BeamGood[Ensemble.BEAM_0_INDEX] = 0.0f;
// ensemble.BottomTrackData.EarthGood[Ensemble.BEAM_EAST_INDEX] = 0.0f;
// ensemble.BottomTrackData.InstrumentGood[Ensemble.BEAM_X_INDEX] = 0.0f;
// ensemble.DvlData.BtEastVelocity = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.BtXVelocity = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.BtTransverseVelocity = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.BtEarthIsGoodVelocity = false;
// ensemble.DvlData.BtInstrumentIsGoodVelocity = false;
// ensemble.DvlData.BtShipIsGoodVelocity = false;
//}
//else
//{
// // Beam velocity
// if (config.VelTransform == Core.Commons.Transforms.BEAM)
// {
// ensemble.BottomTrackData.BeamVelocity[Ensemble.BEAM_X_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[2], binaryEnsemble[3]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.BeamGood[Ensemble.BEAM_X_INDEX] = 1.0f;
// }
// // Earth velocity
// if (config.VelTransform == Core.Commons.Transforms.EARTH)
// {
// ensemble.BottomTrackData.EarthVelocity[Ensemble.BEAM_EAST_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[2], binaryEnsemble[3]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.EarthGood[Ensemble.BEAM_EAST_INDEX] = 1.0f;
// ensemble.DvlData.BtEastVelocity = MathHelper.LsbMsbShort(binaryEnsemble[2], binaryEnsemble[3]) * 0.001f; // mm/s to m/s
// ensemble.DvlData.BtEarthIsGoodVelocity = true;
// }
// // Instrument velocity
// if (config.VelTransform == Core.Commons.Transforms.INSTRUMENT)
// {
// ensemble.BottomTrackData.InstrumentVelocity[Ensemble.BEAM_X_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[5], binaryEnsemble[6]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.InstrumentGood[Ensemble.BEAM_X_INDEX] = 1.0f;
// ensemble.DvlData.BtXVelocity = MathHelper.LsbMsbShort(binaryEnsemble[5], binaryEnsemble[6]) * 0.001f; // mm/s to m/s
// ensemble.DvlData.BtInstrumentIsGoodVelocity = true;
// }
// // Ship velocity
// if (config.VelTransform == Core.Commons.Transforms.SHIP)
// {
// ensemble.DvlData.BtTransverseVelocity = MathHelper.LsbMsbShort(binaryEnsemble[5], binaryEnsemble[6]) * 0.001f; // mm/s to m/s
// ensemble.DvlData.BtShipIsGoodVelocity = true;
// }
//}
//// Y
//if (MathHelper.LsbMsbShort(binaryEnsemble[7], binaryEnsemble[8]) == PD0.BAD_VELOCITY)
//{
// ensemble.BottomTrackData.BeamVelocity[Ensemble.BEAM_1_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.InstrumentVelocity[Ensemble.BEAM_Y_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.EarthVelocity[Ensemble.BEAM_NORTH_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.BeamGood[Ensemble.BEAM_1_INDEX] = 0.0f;
// ensemble.BottomTrackData.EarthGood[Ensemble.BEAM_NORTH_INDEX] = 0.0f;
// ensemble.BottomTrackData.InstrumentGood[Ensemble.BEAM_Y_INDEX] = 0.0f;
// ensemble.DvlData.BtEastVelocity = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.BtXVelocity = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.BtLongitudinalVelocity = Ensemble.BAD_VELOCITY;
//}
//else
//{
// // Beam velocity
// if (config.VelTransform == Core.Commons.Transforms.BEAM)
// {
// ensemble.BottomTrackData.BeamVelocity[Ensemble.BEAM_1_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[7], binaryEnsemble[8]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.BeamGood[Ensemble.BEAM_1_INDEX] = 1.0f;
// }
// // Earth velocity
// if (config.VelTransform == Core.Commons.Transforms.EARTH)
// {
// ensemble.BottomTrackData.EarthVelocity[Ensemble.BEAM_NORTH_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[7], binaryEnsemble[8]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.EarthGood[Ensemble.BEAM_NORTH_INDEX] = 1.0f;
// ensemble.DvlData.BtNorthVelocity = MathHelper.LsbMsbShort(binaryEnsemble[7], binaryEnsemble[8]) * 0.001f; // mm/s to m/s
// }
// // Instrument velocity
// if (config.VelTransform == Core.Commons.Transforms.INSTRUMENT)
// {
// ensemble.BottomTrackData.InstrumentVelocity[Ensemble.BEAM_Y_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[7], binaryEnsemble[8]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.InstrumentGood[Ensemble.BEAM_Y_INDEX] = 1.0f;
// ensemble.DvlData.BtYVelocity = MathHelper.LsbMsbShort(binaryEnsemble[7], binaryEnsemble[8]) * 0.001f; // mm/s to m/s
// }
// // Ship velocity
// if (config.VelTransform == Core.Commons.Transforms.SHIP)
// {
// ensemble.DvlData.BtLongitudinalVelocity = MathHelper.LsbMsbShort(binaryEnsemble[7], binaryEnsemble[8]) * 0.001f; // mm/s to m/s
// }
//}
//// Z
//if (MathHelper.LsbMsbShort(binaryEnsemble[9], binaryEnsemble[10]) == PD0.BAD_VELOCITY)
//{
// ensemble.BottomTrackData.BeamVelocity[Ensemble.BEAM_2_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.InstrumentVelocity[Ensemble.BEAM_Z_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.EarthVelocity[Ensemble.BEAM_VERTICAL_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.BeamGood[Ensemble.BEAM_2_INDEX] = 0.0f;
// ensemble.BottomTrackData.EarthGood[Ensemble.BEAM_VERTICAL_INDEX] = 0.0f;
// ensemble.BottomTrackData.InstrumentGood[Ensemble.BEAM_Z_INDEX] = 0.0f;
// ensemble.DvlData.BtUpwardVelocity = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.BtZVelocity = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.BtNormalVelocity = Ensemble.BAD_VELOCITY;
//}
//else
//{
// // Beam velocity
// if (config.VelTransform == Core.Commons.Transforms.BEAM)
// {
// ensemble.BottomTrackData.BeamVelocity[Ensemble.BEAM_2_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[9], binaryEnsemble[10]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.BeamGood[Ensemble.BEAM_2_INDEX] = 1.0f;
// }
// // Earth velocity
// if (config.VelTransform == Core.Commons.Transforms.EARTH)
// {
// ensemble.BottomTrackData.EarthVelocity[Ensemble.BEAM_VERTICAL_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[9], binaryEnsemble[10]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.EarthGood[Ensemble.BEAM_VERTICAL_INDEX] = 1.0f;
// ensemble.DvlData.BtUpwardVelocity = MathHelper.LsbMsbShort(binaryEnsemble[9], binaryEnsemble[10]) * 0.001f; // mm/s to m/s
// }
// // Instrument velocity
// if (config.VelTransform == Core.Commons.Transforms.INSTRUMENT)
// {
// ensemble.BottomTrackData.InstrumentVelocity[Ensemble.BEAM_Z_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[9], binaryEnsemble[10]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.InstrumentGood[Ensemble.BEAM_Z_INDEX] = 1.0f;
// ensemble.DvlData.BtZVelocity = MathHelper.LsbMsbShort(binaryEnsemble[9], binaryEnsemble[10]) * 0.001f; // mm/s to m/s
// }
// // Ship velocity
// if (config.VelTransform == Core.Commons.Transforms.SHIP)
// {
// ensemble.DvlData.BtNormalVelocity = MathHelper.LsbMsbShort(binaryEnsemble[9], binaryEnsemble[10]) * 0.001f; // mm/s to m/s
// }
//}
//// Q
//if (MathHelper.LsbMsbShort(binaryEnsemble[11], binaryEnsemble[12]) == PD0.BAD_VELOCITY)
//{
// ensemble.BottomTrackData.BeamVelocity[Ensemble.BEAM_3_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.InstrumentVelocity[Ensemble.BEAM_Q_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.EarthVelocity[Ensemble.BEAM_Q_INDEX] = Ensemble.BAD_VELOCITY;
// ensemble.BottomTrackData.BeamGood[Ensemble.BEAM_Q_INDEX] = 0.0f;
// ensemble.BottomTrackData.EarthGood[Ensemble.BEAM_Q_INDEX] = 0.0f;
// ensemble.BottomTrackData.InstrumentGood[Ensemble.BEAM_Q_INDEX] = 0.0f;
// ensemble.DvlData.BtErrorVelocity = Ensemble.BAD_VELOCITY;
//}
//else
//{
// // Beam velocity
// if (config.VelTransform == Core.Commons.Transforms.BEAM)
// {
// ensemble.BottomTrackData.BeamVelocity[Ensemble.BEAM_3_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[11], binaryEnsemble[12]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.BeamGood[Ensemble.BEAM_3_INDEX] = 1.0f;
// }
// // Earth velocity
// if (config.VelTransform == Core.Commons.Transforms.EARTH)
// {
// ensemble.BottomTrackData.EarthVelocity[Ensemble.BEAM_Q_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[11], binaryEnsemble[12]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.EarthGood[Ensemble.BEAM_Q_INDEX] = 1.0f;
// ensemble.DvlData.BtErrorVelocity = MathHelper.LsbMsbShort(binaryEnsemble[11], binaryEnsemble[12]) * 0.001f; // mm/s to m/s
// }
// // Instrument velocity
// if (config.VelTransform == Core.Commons.Transforms.INSTRUMENT)
// {
// ensemble.BottomTrackData.InstrumentVelocity[Ensemble.BEAM_Q_INDEX] = MathHelper.LsbMsbShort(binaryEnsemble[11], binaryEnsemble[12]) * 0.001f; // mm/s to m/s
// ensemble.BottomTrackData.InstrumentGood[Ensemble.BEAM_Q_INDEX] = 1.0f;
// ensemble.DvlData.BtErrorVelocity = MathHelper.LsbMsbShort(binaryEnsemble[11], binaryEnsemble[12]) * 0.001f; // mm/s to m/s
// }
// // Ship velocity
// if (config.VelTransform == Core.Commons.Transforms.SHIP)
// {
// }
//}
//// Range
//ensemble.BottomTrackData.Range[Ensemble.BEAM_0_INDEX] = MathHelper.LsbMsbUShort(binaryEnsemble[13], binaryEnsemble[14]) * 0.01f; // cm to m
//ensemble.BottomTrackData.Range[Ensemble.BEAM_1_INDEX] = MathHelper.LsbMsbUShort(binaryEnsemble[15], binaryEnsemble[16]) * 0.01f; // cm to m
//ensemble.BottomTrackData.Range[Ensemble.BEAM_2_INDEX] = MathHelper.LsbMsbUShort(binaryEnsemble[17], binaryEnsemble[18]) * 0.01f; // cm to m
//ensemble.BottomTrackData.Range[Ensemble.BEAM_3_INDEX] = MathHelper.LsbMsbUShort(binaryEnsemble[19], binaryEnsemble[20]) * 0.01f; // cm to m
//ensemble.DvlData.RangeBeam0 = MathHelper.LsbMsbUShort(binaryEnsemble[13], binaryEnsemble[14]) * 0.01f; // cm to m
//ensemble.DvlData.RangeBeam1 = MathHelper.LsbMsbUShort(binaryEnsemble[15], binaryEnsemble[16]) * 0.01f; // cm to m
//ensemble.DvlData.RangeBeam2 = MathHelper.LsbMsbUShort(binaryEnsemble[17], binaryEnsemble[18]) * 0.01f; // cm to m
//ensemble.DvlData.RangeBeam3 = MathHelper.LsbMsbUShort(binaryEnsemble[19], binaryEnsemble[20]) * 0.01f; // cm to m
//#endregion
//#region Ensemble Time
//// Ensemble time
//int hour = binaryEnsemble[35];
//int min = binaryEnsemble[36];
//int sec = binaryEnsemble[37];
//int hun = binaryEnsemble[38];
//ensemble.EnsembleData.Hour = hour;
//ensemble.EnsembleData.Minute = min;
//ensemble.EnsembleData.Second = sec;
//ensemble.EnsembleData.HSec = hun;
//ensemble.DvlData.Hour = hour;
//ensemble.DvlData.Minute = min;
//ensemble.DvlData.Second = sec;
//ensemble.DvlData.HSec = hun;
//// Time of first ping
//float currTime = (hour * 3600.0f) + (min * 60.0f) + sec + (hun * 0.01f);
//ensemble.AncillaryData.FirstPingTime = currTime - _prevTime;
//ensemble.AncillaryData.LastPingTime = currTime - _prevTime;
//ensemble.BottomTrackData.FirstPingTime = currTime - _prevTime;
//ensemble.BottomTrackData.LastPingTime = currTime - _prevTime;
//// Set the prev time if it has not been set
//if (_prevTime == 0)
//{
// _prevTime = currTime;
//}
//#endregion
//#region Reference Layer Data
//#region Earth
//// Add the proper DataSet
//if(config.VelTransform == Core.Commons.Transforms.EARTH)
//{
// // Add Earth Water Mass
// if (!ensemble.IsEarthWaterMassAvail)
// {
// ensemble.EarthWaterMassData = new EarthWaterMassDataSet();
// ensemble.IsEarthWaterMassAvail = true;
// }
// // East
// if (MathHelper.LsbMsbShort(binaryEnsemble[22], binaryEnsemble[23]) == PD0.BAD_VELOCITY)
// {
// ensemble.EarthWaterMassData.VelocityEast = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.WmEastVelocity = Ensemble.BAD_VELOCITY;
// }
// else
// {
// ensemble.EarthWaterMassData.VelocityEast = MathHelper.LsbMsbShort(binaryEnsemble[22], binaryEnsemble[23]) * 0.001f; // mm/s to m/s
// ensemble.DvlData.WmEastVelocity = MathHelper.LsbMsbShort(binaryEnsemble[22], binaryEnsemble[23]) * 0.001f; // mm/s to m/s
// }
// // North
// if (MathHelper.LsbMsbShort(binaryEnsemble[24], binaryEnsemble[25]) == PD0.BAD_VELOCITY)
// {
// ensemble.EarthWaterMassData.VelocityNorth = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.WmNorthVelocity = Ensemble.BAD_VELOCITY;
// }
// else
// {
// ensemble.EarthWaterMassData.VelocityNorth = MathHelper.LsbMsbShort(binaryEnsemble[24], binaryEnsemble[25]) * 0.001f; // mm/s to m/s
// ensemble.DvlData.WmNorthVelocity = MathHelper.LsbMsbShort(binaryEnsemble[24], binaryEnsemble[25]) * 0.001f; // mm/s to m/s
// }
// // Vertical
// if (MathHelper.LsbMsbShort(binaryEnsemble[26], binaryEnsemble[27]) == PD0.BAD_VELOCITY)
// {
// ensemble.EarthWaterMassData.VelocityVertical = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.WmUpwardVelocity = Ensemble.BAD_VELOCITY;
// }
// else
// {
// ensemble.EarthWaterMassData.VelocityVertical = MathHelper.LsbMsbShort(binaryEnsemble[26], binaryEnsemble[27]) * 0.001f; // mm/s to m/s
// ensemble.DvlData.WmUpwardVelocity = MathHelper.LsbMsbShort(binaryEnsemble[26], binaryEnsemble[27]) * 0.001f; // mm/s to m/s
// }
// // Depth layer
// ensemble.EarthWaterMassData.WaterMassDepthLayer = MathHelper.LsbMsbShort(binaryEnsemble[30], binaryEnsemble[31]) * 0.1f; // dm to m
// ensemble.DvlData.RefLayerMin = (int)(MathHelper.LsbMsbUShort(binaryEnsemble[30], binaryEnsemble[31]) * 0.1f); // dm to m
// ensemble.DvlData.RefLayerMax = (int)(MathHelper.LsbMsbUShort(binaryEnsemble[32], binaryEnsemble[33]) * 0.1f); // dm to m
//}
//#endregion
//#region Instrument
//if (config.VelTransform == Core.Commons.Transforms.INSTRUMENT)
//{
// // Add Instrument Water Mass
// if (!ensemble.IsInstrumentWaterMassAvail)
// {
// ensemble.InstrumentWaterMassData = new InstrumentWaterMassDataSet();
// ensemble.IsInstrumentWaterMassAvail = true;
// }
// // X
// if (MathHelper.LsbMsbShort(binaryEnsemble[22], binaryEnsemble[23]) == PD0.BAD_VELOCITY)
// {
// ensemble.InstrumentWaterMassData.VelocityX = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.WmXVelocity = Ensemble.BAD_VELOCITY;
// }
// else
// {
// ensemble.InstrumentWaterMassData.VelocityX = MathHelper.LsbMsbShort(binaryEnsemble[22], binaryEnsemble[23]) * 0.001f; // mm/s to m/s
// ensemble.DvlData.WmXVelocity = MathHelper.LsbMsbShort(binaryEnsemble[22], binaryEnsemble[23]) * 0.001f; // mm/s to m/s
// }
// // Y
// if (MathHelper.LsbMsbShort(binaryEnsemble[24], binaryEnsemble[25]) == PD0.BAD_VELOCITY)
// {
// ensemble.InstrumentWaterMassData.VelocityY = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.WmYVelocity = Ensemble.BAD_VELOCITY;
// }
// else
// {
// ensemble.InstrumentWaterMassData.VelocityY = MathHelper.LsbMsbShort(binaryEnsemble[24], binaryEnsemble[25]) * 0.001f; // mm/s to m/s
// ensemble.DvlData.WmYVelocity = MathHelper.LsbMsbShort(binaryEnsemble[24], binaryEnsemble[25]) * 0.001f; // mm/s to m/s
// }
// // Z
// if (MathHelper.LsbMsbShort(binaryEnsemble[26], binaryEnsemble[27]) == PD0.BAD_VELOCITY)
// {
// ensemble.InstrumentWaterMassData.VelocityZ = Ensemble.BAD_VELOCITY;
// ensemble.DvlData.WmZVelocity = Ensemble.BAD_VELOCITY;
// }
// else
// {
// ensemble.InstrumentWaterMassData.VelocityZ = MathHelper.LsbMsbShort(binaryEnsemble[26], binaryEnsemble[27]) * 0.001f; // mm/s to m/s
// ensemble.DvlData.WmZVelocity = MathHelper.LsbMsbShort(binaryEnsemble[26], binaryEnsemble[27]) * 0.001f; // mm/s to m/s
// }
// // Error
// if (MathHelper.LsbMsbShort(binaryEnsemble[28], binaryEnsemble[29]) == PD0.BAD_VELOCITY)
// {
// ensemble.InstrumentWaterMassData.VelocityQ = Ensemble.BAD_VELOCITY;
// }
// else
// {
// ensemble.InstrumentWaterMassData.VelocityQ = MathHelper.LsbMsbShort(binaryEnsemble[28], binaryEnsemble[29]) * 0.001f; // mm/s to m/s
// }
// // Depth layer
// ensemble.InstrumentWaterMassData.WaterMassDepthLayer = MathHelper.LsbMsbShort(binaryEnsemble[30], binaryEnsemble[31]) * 0.1f; // dm to m
// ensemble.DvlData.RefLayerMin = (int)(MathHelper.LsbMsbUShort(binaryEnsemble[30], binaryEnsemble[31]) * 0.1f); // dm to m
// ensemble.DvlData.RefLayerMax = (int)(MathHelper.LsbMsbUShort(binaryEnsemble[32], binaryEnsemble[33]) * 0.1f); // dm to m
//}
//#endregion
//#endregion
//#region PD5
//// If PD5
//// PD5 will have more bytes than PD4
//if(binaryEnsemble.Length >= PD5_ENS_SIZE)
//{
// // Decode PD5 values
// // Salinity
// ensemble.AncillaryData.Salinity = binaryEnsemble[45];
// ensemble.BottomTrackData.Salinity = binaryEnsemble[45];
// ensemble.DvlData.Salinity = binaryEnsemble[45];
// // Tranducer Depth
// ensemble.AncillaryData.TransducerDepth = MathHelper.LsbMsbUShort(binaryEnsemble[46], binaryEnsemble[47]) * 0.1f;
// ensemble.BottomTrackData.TransducerDepth = MathHelper.LsbMsbUShort(binaryEnsemble[46], binaryEnsemble[47]) * 0.1f;
// ensemble.DvlData.TransducerDepth = MathHelper.LsbMsbUShort(binaryEnsemble[46], binaryEnsemble[47]) * 0.1f;
// // Heading
// ensemble.AncillaryData.Heading = MathHelper.LsbMsbUShort(binaryEnsemble[52], binaryEnsemble[53]) * 0.01f;
// ensemble.BottomTrackData.Heading = MathHelper.LsbMsbUShort(binaryEnsemble[52], binaryEnsemble[53]) * 0.01f;
// ensemble.DvlData.Heading = MathHelper.LsbMsbUShort(binaryEnsemble[52], binaryEnsemble[53]) * 0.01f;
// // Pitch
// ensemble.AncillaryData.Pitch = MathHelper.LsbMsbShort(binaryEnsemble[48], binaryEnsemble[49]) * 0.01f;
// ensemble.BottomTrackData.Pitch = MathHelper.LsbMsbShort(binaryEnsemble[48], binaryEnsemble[49]) * 0.01f;
// ensemble.DvlData.Pitch = MathHelper.LsbMsbShort(binaryEnsemble[48], binaryEnsemble[49]) * 0.01f;
// // Roll
// ensemble.AncillaryData.Roll = MathHelper.LsbMsbShort(binaryEnsemble[50], binaryEnsemble[51]) * 0.01f;
// ensemble.BottomTrackData.Roll = MathHelper.LsbMsbShort(binaryEnsemble[50], binaryEnsemble[51]) * 0.01f;
// ensemble.DvlData.Roll = MathHelper.LsbMsbShort(binaryEnsemble[50], binaryEnsemble[51]) * 0.01f;
// // DMG
// ensemble.DvlData.DmgEast = MathHelper.ByteArrayToInt32(binaryEnsemble, 54) * 0.1f; // dm to m
// ensemble.DvlData.DmgNorth = MathHelper.ByteArrayToInt32(binaryEnsemble, 58) * 0.1f; // dm to m
// ensemble.DvlData.DmgUpward = MathHelper.ByteArrayToInt32(binaryEnsemble, 62) * 0.1f; // dm to m
// ensemble.DvlData.DmgError = MathHelper.ByteArrayToInt32(binaryEnsemble, 66) * 0.1f; // dm to m
// // DMG Ref Layer
// ensemble.DvlData.DmgRefEast = MathHelper.ByteArrayToInt32(binaryEnsemble, 70) * 0.1f; // dm to m
// ensemble.DvlData.DmgRefNorth = MathHelper.ByteArrayToInt32(binaryEnsemble, 74) * 0.1f; // dm to m
// ensemble.DvlData.DmgRefUpward = MathHelper.ByteArrayToInt32(binaryEnsemble, 78) * 0.1f; // dm to m
// ensemble.DvlData.DmgRefError = MathHelper.ByteArrayToInt32(binaryEnsemble, 82) * 0.1f; // dm to m
//}
//#endregion
// Send an event that data was processed
// in this format
if (ProcessDataEvent != null)
{
ProcessDataEvent(binaryEnsemble, ensemble);
}
return ensemble;
}
/// <summary>
/// Output the Profile Engineering dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Profile Engineering DataSet data in CSV format.</returns>
public static string WriteProfileEngineeringData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsProfileEngineeringAvail)
{
sb.Append(ensemble.ProfileEngineeringData.SamplesPerSecond);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.SystemFreqHz);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.LagSamples);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.CPCE);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.NCE);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.RepeatN);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingGap);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingNCE);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingRepeatN);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingLagSamples);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.TRHighGain);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingVel[0]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingVel[1]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingVel[2]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingVel[3]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingCor[0]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingCor[1]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingCor[2]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingCor[3]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingAmp[0]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingAmp[1]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingAmp[2]);
sb.Append(",");
sb.Append(ensemble.ProfileEngineeringData.PrePingAmp[3]);
}
else
{
sb.Append(",,,,,,,,,,,,,,,,,,,,,,");
}
return sb.ToString();
}
/// <summary>
/// Output the Instrument Water Mass dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Instrument Water Mass DataSet data in CSV format.</returns>
public static string WriteInstrumentWaterMassData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsInstrumentWaterMassAvail)
{
sb.Append(ensemble.InstrumentWaterMassData.WaterMassDepthLayer);
sb.Append(",");
sb.Append(ensemble.InstrumentWaterMassData.VelocityX);
sb.Append(",");
sb.Append(ensemble.InstrumentWaterMassData.VelocityY);
sb.Append(",");
sb.Append(ensemble.InstrumentWaterMassData.VelocityZ);
}
else
{
// Put blank data
sb.Append(",,,,");
}
return sb.ToString();
}
/// <summary>
/// Output the Ensemble dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Ensemble DataSet data in CSV format.</returns>
public static string WriteEnsembleData(Ensemble ensemble)
{
if (ensemble.IsEnsembleAvail)
{
StringBuilder sb = new StringBuilder();
sb.Append(ensemble.EnsembleData.EnsembleNumber);
sb.Append(",");
sb.Append(ensemble.EnsembleData.EnsDateTime.ToString());
sb.Append(",");
sb.Append(ensemble.EnsembleData.NumBins);
sb.Append(",");
sb.Append(ensemble.EnsembleData.NumBeams);
sb.Append(",");
sb.Append(ensemble.EnsembleData.DesiredPingCount);
sb.Append(",");
sb.Append(ensemble.EnsembleData.ActualPingCount);
sb.Append(",");
sb.Append(ensemble.EnsembleData.SysSerialNumber.ToString());
sb.Append(",");
sb.Append(ensemble.EnsembleData.SysFirmware.ToString());
sb.Append(",");
sb.Append(ensemble.EnsembleData.SubsystemConfig.SubSystem.CodeToString());
sb.Append(",");
sb.Append(ensemble.EnsembleData.SubsystemConfig.SubSystem.Index);
sb.Append(",");
sb.Append(ensemble.EnsembleData.Status.ToString().Replace(",", ";")); // Replace the , with ; so it does not mess up the seperation);
return sb.ToString();
}
return ",,,,,,,,,,";
}
/// <summary>
/// Output the Earth Water Mass dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Earth Water Mass DataSet data in CSV format.</returns>
public static string WriteEarthWaterMassData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsEarthWaterMassAvail)
{
sb.Append(ensemble.EarthWaterMassData.WaterMassDepthLayer);
sb.Append(",");
sb.Append(ensemble.EarthWaterMassData.VelocityEast);
sb.Append(",");
sb.Append(ensemble.EarthWaterMassData.VelocityNorth);
sb.Append(",");
sb.Append(ensemble.EarthWaterMassData.VelocityVertical);
}
else
{
// Put blank data
sb.Append(",,,,");
}
return sb.ToString();
}
/// <summary>
/// Output the NMEA dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>NMEA DataSet data in CSV format.</returns>
public static string WriteNmeaData(Ensemble ensemble)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsNmeaAvail)
{
if (ensemble.NmeaData.IsGpggaAvail())
{
sb.Append(ensemble.NmeaData.GPGGA.Position.Latitude.DecimalDegrees.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.NmeaData.GPGGA.Position.Longitude.DecimalDegrees.ToString(new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.NmeaData.GPGGA.Altitude.ToMeters().ToString("g", new CultureInfo("en-US")));
sb.Append(",");
sb.Append(ensemble.NmeaData.GPGGA.UtcTime);
sb.Append(",");
}
else
{
sb.Append(",,,,");
}
if(ensemble.NmeaData.IsGphdtAvail())
{
sb.Append(ensemble.NmeaData.GPHDT.Heading.DecimalDegrees.ToString(new CultureInfo("en-US")));
sb.Append(",");
}
else
{
sb.Append(",");
}
}
else
{
sb.Append(",,,,,");
}
return sb.ToString();
}
/// <summary>
/// Write the Ensemble number, Ensemble date and time, the velocity data, the pressure, heading pitch and roll
/// to the file.
/// </summary>
/// <param name="ensemble">Ensemble to get the data.</param>
/// <param name="isMultipleFiles">Set if each ensemble should be a seperate file. Default to FALSE.</param>
public void Write(Ensemble ensemble, bool isMultipleFiles = false)
{
// Encode the ensemble to a string and write it to the file
_writer.WriteLine(EncodeCSV(ensemble, _options));
}
/// <summary>
/// Output the Ancillary dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <returns>Ancillary DataSet data in CSV format.</returns>
public static string WriteAncillaryData(Ensemble ensemble)
{
if (ensemble.IsAncillaryAvail)
{
StringBuilder sb = new StringBuilder();
sb.Append(ensemble.AncillaryData.FirstBinRange);
sb.Append(",");
sb.Append(ensemble.AncillaryData.BinSize);
sb.Append(",");
sb.Append(ensemble.AncillaryData.FirstPingTime);
sb.Append(",");
sb.Append(ensemble.AncillaryData.LastPingTime);
sb.Append(",");
sb.Append(ensemble.AncillaryData.Heading);
sb.Append(",");
sb.Append(ensemble.AncillaryData.Pitch);
sb.Append(",");
sb.Append(ensemble.AncillaryData.Roll);
sb.Append(",");
sb.Append(ensemble.AncillaryData.WaterTemp);
sb.Append(",");
sb.Append(ensemble.AncillaryData.SystemTemp);
sb.Append(",");
sb.Append(ensemble.AncillaryData.Salinity);
sb.Append(",");
sb.Append(ensemble.AncillaryData.Pressure);
sb.Append(",");
sb.Append(ensemble.AncillaryData.TransducerDepth);
sb.Append(",");
sb.Append(ensemble.AncillaryData.SpeedOfSound);
return sb.ToString();
}
return ",,,,,,,,,,,,";
}
/// <summary>
/// Parse the incoming packet for all the Data Sets.
/// Add the data to a AdcpDataSet variable and
/// return the filled variable when complete.
/// </summary>
/// <param name="binaryEnsemble">Byte array containing data from an ADCP.</param>
/// <returns>Object holding decoded ADCP data.</returns>
private Ensemble DecodeAdcpData(byte[] binaryEnsemble)
{
// Keep track where in the packet
// we are currently decoding
int packetPointer = DataSet.Ensemble.ENSEMBLE_HEADER_LEN;
int type = 0;
int numElements = 0;
int elementMultiplier = 0;
int imag = 0;
int nameLen = 0;
string name = "";
int dataSetSize = 0;
Ensemble ensemble = new Ensemble();
for (int i = 0; i < DataSet.Ensemble.MAX_NUM_DATA_SETS; i++)
{
//Debug.Print("binaryEnsemble: " + binaryEnsemble.Length + " packetPointer: " + packetPointer + "\n");
type = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 0));
numElements = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 1));
elementMultiplier = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 2));
imag = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 3));
nameLen = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 4));
name = MathHelper.ByteArrayToString(binaryEnsemble, 8, packetPointer + (DataSet.Ensemble.BYTES_IN_FLOAT * 5));
// Verify the data is good
if (string.IsNullOrEmpty(name))
{
break;
}
//Debug.Print("name: " + name + "\n");
//Debug.Print("numElements: " + numElements + "\n");
//Debug.Print("elementMultiplier" + elementMultiplier + "\n");
// Get the size of this data set
dataSetSize = BaseDataSet.GetDataSetSize(type, nameLen, numElements, elementMultiplier);
if (Ensemble.BeamVelocityID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] velData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddBeamVelocityData(type, numElements, elementMultiplier, imag, nameLen, name, velData);
//Debug.WriteLine(adcpData.BeamVelocityData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.InstrumentVelocityID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] velData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddInstrumentVelocityData(type, numElements, elementMultiplier, imag, nameLen, name, velData);
//Debug.WriteLine(adcpData.InstrVelocityData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.EarthVelocityID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] velData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddEarthVelocityData(type, numElements, elementMultiplier, imag, nameLen, name, velData);
//Debug.WriteLine(adcpData.EarthVelocityData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.AmplitudeID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ampData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddAmplitudeData(type, numElements, elementMultiplier, imag, nameLen, name, ampData);
//Debug.WriteLine(adcpData.AmplitudeData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.CorrelationID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] corrData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddCorrelationData(type, numElements, elementMultiplier, imag, nameLen, name, corrData);
//Debug.WriteLine(adcpData.CorrelationData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.GoodBeamID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] goodBeamData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddGoodBeamData(type, numElements, elementMultiplier, imag, nameLen, name, goodBeamData);
//Debug.WriteLine(adcpData.GoodBeamData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.GoodEarthID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] goodEarthData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddGoodEarthData(type, numElements, elementMultiplier, imag, nameLen, name, goodEarthData);
//Debug.WriteLine(adcpData.GoodEarthData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.EnsembleDataID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ensembleData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddEnsembleData(type, numElements, elementMultiplier, imag, nameLen, name, ensembleData);
//Debug.WriteLine(adcpData.EnsembleData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.AncillaryID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ancillaryData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddAncillaryData(type, numElements, elementMultiplier, imag, nameLen, name, ancillaryData);
//Debug.WriteLine(adcpData.AncillaryData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.BottomTrackID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] bottomTrackData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddBottomTrackData(type, numElements, elementMultiplier, imag, nameLen, name, bottomTrackData);
//Debug.WriteLine(adcpData.BottomTrackData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.NmeaID.Equals(name, StringComparison.Ordinal))
{
// List of all data read
byte[] nmeaData = new byte[dataSetSize];
// Scan through the data set and store all the data
for (int x = 0; x < dataSetSize; x++)
{
nmeaData[x] = binaryEnsemble[packetPointer++];
}
// Add the data
ensemble.AddNmeaData(type, numElements, elementMultiplier, imag, nameLen, name, nmeaData);
//Debug.WriteLine(adcpData.NmeaData.ToString());
}
else if (Ensemble.ProfileEngineeringID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] peData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddProfileEngineeringData(type, numElements, elementMultiplier, imag, nameLen, name, peData);
//Debug.WriteLine(adcpData.BottomTrackData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.BottomTrackEngineeringID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] bteData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddBottomTrackEngineeringData(type, numElements, elementMultiplier, imag, nameLen, name, bteData);
//Debug.WriteLine(adcpData.BottomTrackData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.SystemSetupID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ssData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddSystemSetupData(type, numElements, elementMultiplier, imag, nameLen, name, ssData);
//Debug.WriteLine(adcpData.BottomTrackData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.RangeTrackingID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] rtData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddRangeTrackingData(type, numElements, elementMultiplier, imag, nameLen, name, rtData);
//Debug.WriteLine(adcpData.RangeTrackingData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.GageHeightID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ghData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddGageHeightData(type, numElements, elementMultiplier, imag, nameLen, name, ghData);
//Debug.WriteLine(adcpData.GageHeightData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.Adcp2InfoID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] adcp2InfoData = MathHelper.SubArray<byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddAdcp2InfoData(type, numElements, elementMultiplier, imag, nameLen, name, adcp2InfoData);
//Debug.WriteLine(adcpData.GageHeightData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else
{
// Advance the packet pointer
packetPointer += dataSetSize;
}
//Debug.Print("DataSetSize: " + dataSetSize + "\n");
//Debug.Print(" packetPointer: " + packetPointer + "\n");
if (packetPointer + 4 >= binaryEnsemble.Length || packetPointer < 0)
break;
}
// If NMEA data is available, add it to the dataset
// Add it to both the binary data and ensemble object
if (_nmeaBuffer.Count > 0)
{
// Create a NMEA dataset
MergeNmeaDataSet(ref ensemble);
// Add the NMEA binary data to binary data
if (ensemble.IsNmeaAvail)
{
MergeNmeaBinary(ref binaryEnsemble, ensemble.NmeaData);
}
}
// Send an event that data was processed
// in this format
if (ProcessDataEvent != null)
{
ProcessDataEvent(binaryEnsemble, ensemble);
}
return ensemble;
}
/// <summary>
/// Output the Beam Velocity dataset to CSV format.
/// </summary>
/// <param name="ensemble">Data.</param>
/// <param name="options">Export Options.</param>
/// <returns>Beam Velocity DataSet data in CSV format.</returns>
public static string WriteBeamVelocityData(Ensemble ensemble, ExportOptions options)
{
StringBuilder sb = new StringBuilder();
if (ensemble.IsBeamVelocityAvail)
{
//// Check values
//int minBin = options.BeamMinBin;
//if (minBin >= ensemble.BeamVelocityData.BeamVelocityData.GetLength(0))
//{
// minBin = 0;
//}
//int maxBin = options.BeamMaxBin;
//if (maxBin >= ensemble.BeamVelocityData.BeamVelocityData.GetLength(0))
//{
// maxBin = ensemble.BeamVelocityData.BeamVelocityData.GetLength(0) - 1;
//}
for (int bin = options.BeamMinBin; bin < options.BeamMaxBin + 1; bin++)
{
for (int beam = 0; beam < ensemble.BeamVelocityData.BeamVelocityData.GetLength(1); beam++)
{
sb.Append(string.Format("{0},", ensemble.BeamVelocityData.BeamVelocityData[bin, beam].ToString(new CultureInfo("en-US"))));
}
// If a vertical beam
if (ensemble.BeamVelocityData.BeamVelocityData.GetLength(1) <= 1)
{
sb.Append(",,,");
}
}
}
else
{
// Put blank data
for (int bin = options.BeamMinBin; bin < options.BeamMaxBin + 1; bin++)
{
sb.Append(",,,,");
}
}
return sb.ToString();
}
