public void MatrixCreatorTest_GetHammingMatrix()
{
//arrange
var expectedG = new byte[, ]
{
{ 1, 0, 0, 0, 1, 1, 0 },
{ 0, 1, 0, 0, 1, 0, 1 },
{ 0, 0, 1, 0, 1, 1, 1 },
{ 0, 0, 0, 1, 0, 1, 1 }
};
var expectedH = new byte[, ]
{
{ 1, 1, 1, 0, 1, 0, 0 },
{ 1, 0, 1, 1, 0, 1, 0 },
{ 0, 1, 1, 1, 0, 0, 1 }
};
//act
var m = new MatrixCreator();
var actualG = m.GeneratingMatrix;
var actualH = m.HammingCodesMatrix;
//assert
CollectionAssert.AreEqual(expectedG, actualG);
CollectionAssert.AreEqual(expectedH, actualH);
}
public void AddNullToMatrixExpectedException()
{
DataCreator <int, Position <IPoint <int> > > dataCreator = new MatrixCreator <int, Position <IPoint <int> > >();
var matrix = dataCreator.Create();
matrix.Add(null);
}
public void CreateMatrix()
{
DataCreator <int, Position <IPoint <int> > > dataCreator = new MatrixCreator <int, Position <IPoint <int> > >();
var matrix = dataCreator.Create();
var expectedMatrix = new Matrix <Position <IPoint <int> > >();
var expectedType = expectedMatrix.GetType();
var realType = matrix.GetType();
Assert.AreEqual(expectedType, realType);
}
private void EncodedCipherRecieved(string encodedText)
{
_matrix = MatrixCreator.GetCodeConstructionsFromCipher(encodedText);
var coll = new List <HCodeBlockViewModel>();
foreach (var constr in _matrix)
{
coll.Add(new HCodeBlockViewModel(constr));
}
HCodesCollection = new ObservableCollection <HCodeBlockViewModel>(coll);
}
public MatrixViewModel(IEventAggregator ea)
{
_eventAggregator = ea;
_eventAggregator.GetEvent <EnterTextEncodedEvent>().Subscribe(EncodedCipherRecieved);
GMatrixEditCommand = new DelegateCommand <DataGridCellEditEndingEventArgs>(OnCellEdited);
SendMessageCommand = new DelegateCommand(SendMessage, CanSend).ObservesProperty(() => HCodesCollection);
MatrixCreator = new MatrixCreator();
GeneratingCodesCollection = new ObservableCollection <ObservableCollection <byte> >
(ConvertTwoDimArrayToListArrays(MatrixCreator.GeneratingMatrix));
CheckCodesCollection = new ObservableCollection <ObservableCollection <byte> >
(ConvertTwoDimArrayToListArrays(MatrixCreator.HammingCodesMatrix));
}
public static IDataCollection <Container <Matrix <Position <IPoint <int> > > > > CreateContainerCollections()
{
var positionCreator = new PositionCreator <int, IPoint <int> >();
var firstPosition = positionCreator.Create();
var secondPosition = positionCreator.Create();
var thirdPosition = positionCreator.Create();
var fourthPosition = positionCreator.Create();
var fifthPosition = positionCreator.Create();
for (var i = 0; i < 10; i++)
{
firstPosition.Add(new Point3D <int>(i, i, i));
secondPosition.Add(new Point3D <int>(i, i, i));
thirdPosition.Add(new Point3D <int>(i, i, i));
fourthPosition.Add(new Point3D <int>(i, i, i));
fifthPosition.Add(new Point3D <int>(i, i, i));
}
var matrixCreator = new MatrixCreator <int, Position <IPoint <int> > >();
var firstMatrix = matrixCreator.Create();
var secondMatrix = matrixCreator.Create();
var thirdMatrix = matrixCreator.Create();
firstMatrix.Add((Position <IPoint <int> >)firstPosition);
firstMatrix.Add((Position <IPoint <int> >)secondPosition);
firstMatrix.Add((Position <IPoint <int> >)thirdPosition);
secondMatrix.Add((Position <IPoint <int> >)fifthPosition);
secondMatrix.Add((Position <IPoint <int> >)fourthPosition);
secondMatrix.Add((Position <IPoint <int> >)thirdPosition);
thirdMatrix.Add((Position <IPoint <int> >)secondPosition);
thirdMatrix.Add((Position <IPoint <int> >)fourthPosition);
thirdMatrix.Add((Position <IPoint <int> >)thirdPosition);
var containerCreator = new ContainerCreator <int, Matrix <Position <IPoint <int> > > >();
var container = containerCreator.Create();
container.Add((Matrix <Position <IPoint <int> > >)firstMatrix);
container.Add((Matrix <Position <IPoint <int> > >)secondMatrix);
container.Add((Matrix <Position <IPoint <int> > >)thirdMatrix);
var containerColectionCreator = new ContainerCollectionCreator <int, Container <Matrix <Position <IPoint <int> > > > >();
var containerCollection = containerColectionCreator.Create();
containerCollection.Add((Container <Matrix <Position <IPoint <int> > > >)container);
return(containerCollection);
}
public void GetCodeConstructionsFromCipherTest()
{
//arrange
var cipher = "0010010010111011111111";
var defaultG = new byte[, ]
{
{ 1, 0, 0, 0, 1, 1, 0 },
{ 0, 1, 0, 0, 1, 0, 1 },
{ 0, 0, 1, 0, 1, 1, 1 },
{ 0, 0, 0, 1, 0, 1, 1 }
};
var expectedCodes = new byte[][]
{
new byte[] { 0, 0, 0, 1, 0, 1, 1, 1 },
new byte[] { 1, 0, 1, 0, 0, 1, 0, 1 },
new byte[] { 0, 1, 0, 1, 1, 0, 1, 0 },
new byte[] { 0, 1, 0, 1, 1, 0, 1, 0 },
new byte[] { 1, 1, 1, 1, 1, 1, 1, 1 },
new byte[] { 0, 1, 1, 1, 0, 1, 0, 0 }
};
//act
var m = new MatrixCreator(defaultG);
var actualCodes = m.GetCodeConstructionsFromCipher(cipher);
//assert
Assert.That.AreEqual(expectedCodes, actualCodes, (
(m1, m2) =>
{
if (m1.Where((t, i) => t.Length != m2[i].Length).Any())
{
return(false);
}
for (var j = 0; j < m2.Length; j++)
{
for (var k = 0; k < m2[0].Length; k++)
{
if (m1[j][k] != m2[j][k])
{
return(false);
}
}
}
return(true);
}));
}
public void MatrixCreatorTest_ConstructorGenerateMatrix()
{
//arrange
var expectedG = new byte[, ]
{
{ 1, 0, 0, 0, 1, 1, 0 },
{ 0, 1, 0, 0, 1, 0, 1 },
{ 0, 0, 1, 0, 1, 1, 1 },
{ 0, 0, 0, 1, 0, 1, 1 }
};
//act
var m = new MatrixCreator(expectedG);
var actualG = m.GeneratingMatrix;
//assert
CollectionAssert.AreEqual(expectedG, actualG);
}
private void OnGenMatrixChanged()
{
MatrixCreator = new MatrixCreator(ConvertListArraysToTwoDimArray(GeneratingCodesCollection));
CheckCodesCollection = new ObservableCollection <ObservableCollection <byte> >
(ConvertTwoDimArrayToListArrays(MatrixCreator.HammingCodesMatrix));
}
public void TestDemultiplexUIMFSingleFrame()
{
// Old: const int numSegments = 24;
const int numberOfBits = 4;
const int lcFramesToSum = 1;
const string matrixString = "100110101111000";
var multiplierMatrix = MatrixCreator.CreateMatrixForDemultiplexing(matrixString);
var scaledMatrix = (DenseMatrix)multiplierMatrix.Multiply(2.0 / 16.0);
var inversedScaledMatrix = (DenseMatrix)scaledMatrix.Inverse();
Assert.AreEqual(15, inversedScaledMatrix.ColumnCount);
Assert.AreEqual(15, inversedScaledMatrix.RowCount);
var expectMatrixVals = new List <int>
{
1,
-1,
-1,
1,
1,
-1,
1,
-1,
1,
1,
1,
1,
-1
};
for (var i = 0; i < expectMatrixVals.Count; i++)
{
Assert.AreEqual(expectMatrixVals[i], inversedScaledMatrix.Values[i], 0.01, "inversedScaledMatrix has unexpected values");
}
var uimfFile = VerifyLocalUimfFile(@"Test_Data\9pep_mix_1uM_4bit_50_12Dec11_encoded.uimf");
if (uimfFile == null)
{
var currentDirectory = new DirectoryInfo(".");
Assert.Fail("UIMF file not found; Current working directory is " + currentDirectory.FullName);
}
Console.WriteLine("Opening " + uimfFile.FullName);
var uimfReader = new DataReader(uimfFile.FullName);
var globalParams = uimfReader.GetGlobalParams();
var binWidth = globalParams.BinWidth;
var frameNumbers = new List <int>(uimfReader.GetFrameNumbers(UIMFData.FrameType.MS1));
frameNumbers.AddRange(uimfReader.GetFrameNumbers(UIMFData.FrameType.Calibration));
frameNumbers.AddRange(uimfReader.GetFrameNumbers(UIMFData.FrameType.MS2));
frameNumbers.Sort();
var numFrames = frameNumbers.Count;
Console.WriteLine("Total Data Frames = " + numFrames);
var baseFileName = Path.GetFileNameWithoutExtension(uimfFile.Name);
string newFileName;
if (baseFileName.Contains("encoded"))
{
newFileName = baseFileName.Replace("encoded", "decoded") + ".uimf";
}
else
{
newFileName = baseFileName + "_decoded.uimf";
}
if (uimfFile.DirectoryName == null)
{
Assert.Fail("Unable to determine the parent directory of " + uimfFile.FullName);
}
var newFile = new FileInfo(Path.Combine(uimfFile.DirectoryName, newFileName));
var bitSequence = DemultiplexerOptions.GetBitSequence(numberOfBits);
Assert.AreEqual(matrixString, bitSequence, "Unexpected bit sequence: " + bitSequence + "; expecting " + matrixString);
if (newFile.Exists)
{
Console.WriteLine("Deleting existing decoded UIMF file: " + newFile.FullName);
try
{
newFile.Delete();
}
catch (Exception ex)
{
Assert.Fail("Error deleting file: " + ex.Message);
}
}
Console.WriteLine("Demultiplexing to create " + newFile.FullName);
var executingAssembly = System.Reflection.Assembly.GetExecutingAssembly();
using (var uimfWriter = new DataWriter(newFile.FullName, executingAssembly))
{
uimfWriter.CreateTables(globalParams.GetValue(GlobalParamKeyType.DatasetType));
uimfWriter.InsertGlobal(globalParams);
// Old method of instantiating the Demultiplexer:
// var firstFrameParams = uimfReader.GetFrameParams(1);
// var averageTOFLength = firstFrameParams.GetValueDouble(FrameParamKeyType.AverageTOFLength);
// Demultiplexer demultiplexer = new Demultiplexer(inversedScaledMatrix, numSegments, binWidth, averageTOFLength);
var demultiplexerOptions = new DemultiplexerOptions();
var demultiplexer = new Demultiplexer(demultiplexerOptions);
var scanToIndexMap = demultiplexerOptions.ScanToIndexMap;
var segmentLength = demultiplexer.NumberOfSegments;
foreach (var currentFrameNumber in frameNumbers)
{
Console.WriteLine("Processing Frame " + currentFrameNumber);
// Setup the frame in the UIMFWriter
var frameParams = uimfReader.GetFrameParams(currentFrameNumber);
uimfWriter.InsertFrame(currentFrameNumber, frameParams);
// If we are dealing with a calibration frame, we just want to write the data to the new UIMF file as is
if (frameParams.FrameType == UIMFData.FrameType.Calibration)
{
for (var i = 0; i < frameParams.Scans; i++)
{
var intensities = uimfReader.GetSpectrumAsBins(
currentFrameNumber,
currentFrameNumber,
frameParams.FrameType,
startScanNumber: i,
endScanNumber: i);
var nonZeroCount = intensities.Count(x => x > 0);
uimfWriter.InsertScan(currentFrameNumber, frameParams, i, intensities, binWidth);
}
continue;
}
// Data pulled from the UIMF file will not be re-ordered
const bool isReordered = false;
// Get the data of the frame from the UIMF File
var arrayOfIntensityArrays = UIMFDemultiplexer.UIMFDemultiplexer.GetIntensityBlockForDemultiplexing(
uimfReader,
currentFrameNumber,
frameParams.FrameType,
segmentLength,
scanToIndexMap,
isReordered,
lcFramesToSum);
// Demultiplex the frame, which updates the array
var scanDataEnumerable = demultiplexer.DemultiplexFrame(arrayOfIntensityArrays, isReordered);
var sortByScanNumberQuery = (from scanData in scanDataEnumerable
orderby scanData.ScanNumber
select scanData).ToList();
Assert.AreEqual(93, sortByScanNumberQuery.Count);
foreach (var scanData in sortByScanNumberQuery)
{
var dataPoints = new List <Tuple <int, int> >(scanData.BinsToIntensitiesMap.Count);
dataPoints.AddRange(from dataPoint in scanData.BinsToIntensitiesMap
where dataPoint.Value != 0
orderby dataPoint.Key
select new Tuple <int, int>(dataPoint.Key, dataPoint.Value));
uimfWriter.InsertScan(
currentFrameNumber,
frameParams,
scanData.ScanNumber,
dataPoints,
binWidth,
0);
}
uimfWriter.FlushUimf();
}
}
}
