void CHPData::AddReseqColumns(DataSetHeader& hdr)
{
hdr.SetName(CHP_RESEQ_GROUP);
//call - char
hdr.AddByteColumn(CallColName);
//Score - float
hdr.AddFloatColumn(ScoreColName);
}
void CHPQuantificationData::AddColumns(DataSetHeader& hdr, bool keyIsID)
{
if (keyIsID == false)
hdr.AddAsciiColumn(QUANTIFICATION_PROBE_SET_NAME, maxProbeSetName);
else
hdr.AddIntColumn(QUANTIFICATION_PROBE_SET_ID);
hdr.AddFloatColumn(QUANTIFICATION_QUANTIFICATION_NAME);
}
void CHPData::SetEntryCount(int32_t ln, int32_t maxln, bool hasCompData)
{
maxProbeSetName = maxln;
DataSetHeader dpHdr;
dpHdr.SetRowCnt(ln);
AddColumns(dpHdr, hasCompData);
DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(0);
dcHdr->AddDataSetHdr(dpHdr);
}
void CDFData::CreateContentsGroup(const std::wstring& p, int32_t probesetCnt)
{
DataGroupHeader c(p);
DataSetHeader dp;
dp.SetRowCnt(probesetCnt);
dp.SetName(p);
dp.AddUnicodeColumn(L"", MAX_CDF_PROBE_SET_NAME_LENGTH);
dp.AddIntColumn(L"");
c.AddDataSetHdr(dp);
genericData.Header().AddDataGroupHdr(c);
}
void CHPQuantificationData::SetEntryCount(int32_t ln, int32_t maxln)
{
firstColumnType = ASCIICharColType;
maxProbeSetName = maxln;
ParameterNameValueType param;
DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(0);
DataSetHeader dpHdr;
dpHdr.SetRowCnt(ln);
dpHdr.SetName(QUANTIFICATION_QUANTIFICATION_NAME);
AddColumns(dpHdr, false);
dcHdr->AddDataSetHdr(dpHdr);
}
void DataSetHeaderWriter::WriteColumnTypes(std::ofstream &os, const DataSetHeader &dc) const
{
int32_t sz = dc.GetColumnCnt();
// Write the types
for(int i = 0; i < sz; i++)
{
ColumnInfo col = dc.GetColumnInfo(i);
FileOutput::WriteString16(os, col.GetName());
FileOutput::WriteInt8(os, col.GetColumnType());
FileOutput::WriteInt32(os, col.GetSize());
}
}
void CHPData::SetOrigCnt(int32_t ln)
{
DataSetHeader dpHdr;
dpHdr.SetRowCnt(ln);
dpHdr.SetName(CHP_RESEQ_ORIG_CALL_GROUP);
//position - int
dpHdr.AddIntColumn(PositionColName);
//call - byte
dpHdr.AddByteColumn(OriginalCallColName);
DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(3);
dcHdr->AddDataSetHdr(dpHdr);
}
void CHPMultiDataData::SetEntryCount(MultiDataType dataType, int32_t ln, int32_t maxln, const std::vector<ColumnInfo> &columns, const std::wstring &groupName)
{
DataSetInfo info;
info.maxName = maxln;
info.metricColumns = columns;
info.entries = NULL;
info.dataType = dataType;
info.dataSetIndex = (int)dataSetInfo.size();
dataSetInfo[dataType] = info;
DataSetHeader dsHdr;
dsHdr.SetRowCnt(ln);
dsHdr.SetName(MultiDataDataSetNames[(int)dataType]);
AddColumns(info, dsHdr);
if (groupName.empty() == true)
dataTypeGroupNames[dataType] = MULTI_DATA_NAME;
else
dataTypeGroupNames[dataType] = groupName;
DataGroupHeader* dgHdr = GetDataGroupHeader(dataTypeGroupNames[dataType]);
dgHdr->AddDataSetHdr(dsHdr);
}
void CHPData::AddGenoColumns(DataSetHeader& hdr)
{
hdr.SetName(CHP_GENO_GROUP);
//Probeset name - string
hdr.AddAsciiColumn(ProbeSetNameColName, maxProbeSetName);
//Call - unsigned char
hdr.AddUByteColumn(CallColName);
//Confidence - float
hdr.AddFloatColumn(ConfidenceColName);
//RAS1 - float
hdr.AddFloatColumn(RAS1ColName);
//RAS2 - float
hdr.AddFloatColumn(RAS2ColName);
//AA Call - float
hdr.AddFloatColumn(AAColName);
//AB Call - float
hdr.AddFloatColumn(ABColName);
//BB Call - float
hdr.AddFloatColumn(BBColName);
//No Call - float
hdr.AddFloatColumn(NoCallColName);
}
void TestFileGenerator::WriteOutGenericDATDataFileNoGrid()
{
GenericDataHeader gdh;
AddStandardGenericDataHeader(gdh);
// Fill the DataGroupHeader
DataGroupHeader dch;
dch.SetName(L"First Data Cube");
// Fill the DataSetHeader
DataSetHeader dph;
dph.SetName(L"acquired data");
ParameterNameValueType nvt;
nvt.SetName(L"Scanner");
nvt.SetValueText(L"M10");
dph.AddNameValParam(nvt);
nvt.SetName(L"Pixel Size");
nvt.SetValueFloat(0.051f);
dph.AddNameValParam(nvt);
dph.AddColumn(UShortColumn(L"Pixel"));
int32_t rows = 100;
dph.SetRowCnt(rows);
dch.AddDataSetHdr(dph);
// Set the FileHeader
FileHeader fh;
fh.SetFilename("test.file.data_dat");
fh.SetGenericDataHdr(gdh);
fh.AddDataGroupHdr(dch);
// Create the generic file writer
GenericFileWriter gfWriter(&fh);
gfWriter.WriteHeader();
DataGroupWriterIt dcwBegin, dcwEnd;
gfWriter.GetDataGroupWriters(dcwBegin, dcwEnd);
DataGroupWriter d = *dcwBegin;
dcwBegin->WriteHeader();
DataSetWriterIt dpwBegin, dpwEnd;
dcwBegin->GetDataSetWriters(dpwBegin, dpwEnd);
dpwBegin->WriteHeader();
// Write out the data
for( int32_t i=0; i < rows; ++i )
{
u_int16_t value = (u_int16_t)(i*10+i);
dpwBegin->Write(value);
}
dpwBegin->UpdateNextDataSetOffset();
dcwBegin->Close();
}
void CHPMultiDataData::SetEntryCount(MultiDataType dataType, int32_t ln, int segmentTypeMax, int referenceSegmentIDMax, int familialSegmentIDMax, const std::wstring &groupName)
{
DataSetInfo info;
info.maxSegmentType = segmentTypeMax;
info.maxReferenceSegmentID = referenceSegmentIDMax;
info.maxFamilialSegmentID = familialSegmentIDMax;
info.entries = NULL;
info.dataType = dataType;
info.dataSetIndex = (int)dataSetInfo.size();
dataSetInfo[dataType] = info;
DataSetHeader dsHdr;
dsHdr.SetRowCnt(ln);
dsHdr.SetName(MultiDataDataSetNames[(int)dataType]);
AddColumns(info, dsHdr);
if (groupName.empty() == true)
dataTypeGroupNames[dataType] = MULTI_DATA_NAME;
else
dataTypeGroupNames[dataType] = groupName;
DataGroupHeader* dgHdr = GetDataGroupHeader(dataTypeGroupNames[dataType]);
dgHdr->AddDataSetHdr(dsHdr);
}
void DataSetHeaderWriter::WriteNameValParams(std::ofstream &os, DataSetHeader &dc)
{
ParameterNameValueTypeConstIt begin;
ParameterNameValueTypeConstIt end;
dc.GetNameValIterators(begin, end);
while(begin != end)
{
FileOutput::WriteString16(os, begin->GetName());
MIMEValue mv = begin->GetMIMEValue();
u_int32_t sz;
const void* ptr = mv.GetValue(sz);
FileOutput::WriteBlob(os, ptr, sz);
FileOutput::WriteString16(os, begin->GetMIMEType());
begin++;
}
}
void CHPData::SetBackgroundZoneCnt(int32_t ln)
{
DataSetHeader dpHdr;
dpHdr.SetRowCnt(ln);
dpHdr.SetName(CHP_BG_ZONE_GROUP);
//center X coord - float
dpHdr.AddFloatColumn(CenterXColName);
//center Y coord - float
dpHdr.AddFloatColumn(CenterYColName);
//background - float
dpHdr.AddFloatColumn(BackgroundColName);
//smoothing factor - float
dpHdr.AddFloatColumn(SmoothFactorColName);
DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(1);
dcHdr->AddDataSetHdr(dpHdr);
}
void DataSetHeaderTest::AssignmentTest()
{
header->SetName(L"pixel data");
header->AddUShortColumn(L"Intensity");
header->SetRowCnt(101);
ParameterNameValueType t1;
t1.SetName(L"Scanner");
t1.SetValueText(L"M10");
header->AddNameValParam(t1);
ParameterNameValueType t2;
t2.SetName(L"Pixel Size");
t2.SetValueText(L"0.051");
header->AddNameValParam(t2);
DataSetHeader assignee;
assignee = *header;
// Check that the assignment worked
CPPUNIT_ASSERT(assignee.GetName() == header->GetName());
CPPUNIT_ASSERT(assignee.GetColumnCnt() == header->GetColumnCnt());
CPPUNIT_ASSERT(assignee.GetNameValParamCnt() == header->GetNameValParamCnt());
CPPUNIT_ASSERT(assignee.GetRowCnt() == header->GetRowCnt());
CPPUNIT_ASSERT(assignee.GetColumnInfo(0) == header->GetColumnInfo(0));
ParameterNameValueTypeConstIt nvpAssigneeBegin, nvpAssigneeEnd;
assignee.GetNameValIterators(nvpAssigneeBegin, nvpAssigneeEnd);
ParameterNameValueTypeConstIt nvpHeaderBegin, nvpHeaderEnd;
assignee.GetNameValIterators(nvpHeaderBegin, nvpHeaderEnd);
CPPUNIT_ASSERT(*nvpAssigneeBegin == *nvpHeaderBegin);
++nvpAssigneeBegin;
++nvpHeaderBegin;
CPPUNIT_ASSERT(*nvpAssigneeBegin == *nvpHeaderBegin);
++nvpAssigneeBegin;
++nvpHeaderBegin;
CPPUNIT_ASSERT(nvpAssigneeBegin == nvpAssigneeEnd);
CPPUNIT_ASSERT(nvpHeaderBegin == nvpHeaderEnd);
// TBD: no test of row offset array.
}
void CHPData::SetForceCnt(int32_t ln)
{
DataSetHeader dpHdr;
dpHdr.SetRowCnt(ln);
dpHdr.SetName(CHP_RESEQ_FORCE_CALL_GROUP);
//position - int
dpHdr.AddIntColumn(PositionColName);
//call - byte
dpHdr.AddByteColumn(ForceCallColName);
//reason - byte
dpHdr.AddByteColumn(ReasonColName);
DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(2);
dcHdr->AddDataSetHdr(dpHdr);
}
void TestFileGenerator::WriteOutGenericDATDataFileWithGrid()
{
GenericDataHeader gdh;
AddStandardGenericDataHeader(gdh);
// Fill the DataGroupHeader
DataGroupHeader dch;
dch.SetName(L""); // unnamed DataGroup
// Fill the pixel intensity DataSetHeader
DataSetHeader dphPixel;
dphPixel.SetName(L"acquired data");
ParameterNameValueType nvt;
nvt.SetName(L"Scanner");
nvt.SetValueText(L"M10");
dphPixel.AddNameValParam(nvt);
nvt.SetName(L"Pixel Size");
nvt.SetValueFloat(0.051f);
dphPixel.AddNameValParam(nvt);
dphPixel.AddColumn(UShortColumn(L"Pixel"));
int32_t rows = 1000;
dphPixel.SetRowCnt(rows);
dch.AddDataSetHdr(dphPixel);
// Fill the grid DataSetHeader
DataSetHeader dphGrid;
dphGrid.SetName(L"grid position");
nvt.SetName(L"GhostGrids");
nvt.SetValueText(L"True");
dphGrid.AddNameValParam(nvt);
nvt.SetName(L"Pixel Size");
nvt.SetValueFloat(0.051f);
dphGrid.AddNameValParam(nvt);
dphGrid.AddColumn(FloatColumn(L"Upper left x"));
dphGrid.AddColumn(FloatColumn(L"Upper left y"));
dphGrid.AddColumn(FloatColumn(L"Upper right x"));
dphGrid.AddColumn(FloatColumn(L"Upper right y"));
dphGrid.AddColumn(FloatColumn(L"Lower right x"));
dphGrid.AddColumn(FloatColumn(L"Lower right y"));
dphGrid.AddColumn(FloatColumn(L"Lower left x"));
dphGrid.AddColumn(FloatColumn(L"Lower left y"));
int32_t grids = 5; // first is the global grid with 4 subgrids
dphGrid.SetRowCnt(grids);
dch.AddDataSetHdr(dphGrid);
// Set the FileHeader
FileHeader fh;
fh.SetFilename("test.file.data_dat_with_grid");
fh.SetGenericDataHdr(gdh);
fh.AddDataGroupHdr(dch);
// Create the generic file writer
GenericFileWriter gfWriter(&fh);
gfWriter.WriteHeader();
DataGroupWriterIt dcwBegin, dcwEnd;
gfWriter.GetDataGroupWriters(dcwBegin, dcwEnd);
DataGroupWriter d = *dcwBegin;
dcwBegin->WriteHeader();
DataSetWriterIt dpwBegin, dpwEnd;
dcwBegin->GetDataSetWriters(dpwBegin, dpwEnd);
// Write out the pixel DataSet
dpwBegin->WriteHeader();
for( int32_t i=0; i < rows; ++i )
{
u_int16_t value = (u_int16_t)(i*10+i);
dpwBegin->Write(value);
}
dpwBegin->UpdateNextDataSetOffset();
++dpwBegin;
// Write out the grid DataSet
dpwBegin->WriteHeader();
for( int32_t i=0; i < grids; ++i )
{
for (int32_t corner = 0; corner < 4; ++corner)
{
float value = (float)(i*100 + corner);
dpwBegin->Write(value);
dpwBegin->Write(value);
}
}
dpwBegin->UpdateNextDataSetOffset();
dcwBegin->Close();
}
void DataSetHeaderWriter::WriteColumnCnt(std::ofstream &os, const DataSetHeader &dc) const
{
FileOutput::WriteInt32(os, dc.GetColumnCnt());
}
void DataSetHeaderWriter::WriteName(std::ofstream &os, const DataSetHeader &dc) const
{
FileOutput::WriteString16(os, dc.GetName());
}
void DataSetHeaderWriter::WriteNameValCnt(std::ofstream &os, const DataSetHeader &dc) const
{
FileOutput::WriteInt32(os, dc.GetNameValParamCnt());
}
int32_t CHPMultiDataData::GetEntryCount(MultiDataType dataType)
{
DataSetHeader *h = GetDataSetHeader(dataType);
return (h == NULL ? 0 : h->GetRowCnt());
}
void CopyNumberResultWriterTest::testWrite()
{
CopyNumberResultWriter writer;
const char *fileNames[] = {"test1.cn", "test2.cn"};
list<ParameterNameValueType> algParams;
list<ParameterNameValueType> sumParams;
vector<ColumnInfo> cols;
writer.MaximumProbeSetNameLength(12);
writer.MaximumCytoRegionNameLength(12);
writer.MaximumGenotypeProbeSetNameLength(12);
writer.AlgName() = "MYALG";
writer.AlgVersion() = "1.0";
writer.NumberProbeSets() = 10;
writer.NumberCytoRegions() = 10;
writer.NumberGenotypeProbeSets() = 10;
writer.Columns() = cols;
writer.AlgParams() = algParams;
writer.SetChromosomeProbeSetIndexInformation(X_CHR, 0, writer.NumberProbeSets());
for (int i=0; i<2; i++)
{
FusionCELData cel;
cel.SetFileName("../data/small_cel_file");
cel.Read(false);
writer.SummaryParams() = sumParams;
writer.CreateResultFile(cel, fileNames[i]);
cel.Close();
ProbeSetMultiDataCopyNumberData entry;
char buf[64];
for (int j=0; j<writer.NumberProbeSets(); j++)
{
entry.chr = X_CHR;
entry.position = j+i;
snprintf(buf, 64, "%d", j+i);
entry.name = buf;
writer.WriteProbeSetResult(entry);
}
ProbeSetMultiDataCytoRegionData cy;
for (int j=0; j<writer.NumberCytoRegions(); j++)
{
cy.call = 1;
cy.confidenceScore = (float)(j+i);
snprintf(buf, 64, "%d", j+i);
cy.name = buf;
writer.WriteCytoRegionResult(cy);
}
ProbeSetMultiDataGenotypeData gt;
for (int j=0; j<writer.NumberGenotypeProbeSets(); j++)
{
gt.call = 1;
gt.confidence = (float)(j+i);
snprintf(buf, 64, "%d", j+i);
gt.name = buf;
writer.WriteGenotypeProbeSetResult(gt);
}
writer.CloseResultsFile();
}
for (int i=0; i<2; i++)
{
FusionCHPData *chp = FusionCHPDataReg::Read(fileNames[i]);
CPPUNIT_ASSERT(chp != NULL);
FusionCHPMultiDataData *genoChp = FusionCHPMultiDataData::FromBase(chp);
CPPUNIT_ASSERT(genoChp != NULL);
CPPUNIT_ASSERT(genoChp->GetAlgName() == L"MYALG");
CPPUNIT_ASSERT(genoChp->GetAlgVersion() == L"1.0");
CPPUNIT_ASSERT(genoChp->GetArrayType() == L"Hg-small");
CPPUNIT_ASSERT(genoChp->GetEntryCount(ExpressionMultiDataType) == 0);
CPPUNIT_ASSERT(genoChp->GetEntryCount(GenotypeMultiDataType) == 10);
CPPUNIT_ASSERT(genoChp->GetEntryCount(CopyNumberMultiDataType) == 10);
CPPUNIT_ASSERT(genoChp->GetEntryCount(CytoMultiDataType) == 10);
DataSetHeader *dsh = genoChp->GetDataSetHeader(CopyNumberMultiDataType);
CPPUNIT_ASSERT(dsh->GetNameValParamCnt() == 3);
ParameterNameValueTypeConstIt begin;
ParameterNameValueTypeConstIt end;
ParameterNameValueTypeConstIt it;
dsh->GetNameValIterators(begin, end);
it = begin;
CPPUNIT_ASSERT(it->GetValueInt32() == 0);
++it;
CPPUNIT_ASSERT(it->GetValueInt32() == 10);
++it;
CPPUNIT_ASSERT(it->GetValueAscii() == "X");
ProbeSetMultiDataCopyNumberData entry;
char buf[64];
for (int j=0; j<10; j++)
{
genoChp->GetCopyNumberEntry(CopyNumberMultiDataType, j, entry);
CPPUNIT_ASSERT(entry.chr == X_CHR);
CPPUNIT_ASSERT(entry.position == j+i);
snprintf(buf, 64, "%d", j+i);
CPPUNIT_ASSERT(entry.name.compare(buf) == 0);
}
ProbeSetMultiDataCytoRegionData cy;
for (int j=0; j<10; j++)
{
genoChp->GetCytoRegionEntry(CytoMultiDataType, j, cy);
CPPUNIT_ASSERT(cy.call == 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL(cy.confidenceScore, j+i, 0.0001f);
snprintf(buf, 64, "%d", j+i);
CPPUNIT_ASSERT(cy.name.compare(buf) == 0);
}
ProbeSetMultiDataGenotypeData gt;
for (int j=0; j<10; j++)
{
genoChp->GetGenotypeEntry(GenotypeMultiDataType, j, gt);
CPPUNIT_ASSERT(gt.call == 1);
CPPUNIT_ASSERT_DOUBLES_EQUAL(gt.confidence, j+i, 0.0001f);
snprintf(buf, 64, "%d", j+i);
CPPUNIT_ASSERT(gt.name.compare(buf) == 0);
}
delete chp;
}
}
void CHPMultiDataData::AddColumns(DataSetInfo &info, DataSetHeader& hdr)
{
switch (info.dataType)
{
case ExpressionMultiDataType:
hdr.AddAsciiColumn(PROBE_SET_NAME, info.maxName);
hdr.AddFloatColumn(QUANTIFICATION);
break;
case GenotypeMultiDataType:
hdr.AddAsciiColumn(PROBE_SET_NAME, info.maxName);
hdr.AddUByteColumn(CALL);
hdr.AddFloatColumn(CONFIDENCE);
break;
case CopyNumberMultiDataType:
hdr.AddAsciiColumn(PROBE_SET_NAME, info.maxName);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(POSITION);
break;
case CytoMultiDataType:
hdr.AddAsciiColumn(REGION, info.maxName);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(START_POSITION);
hdr.AddUIntColumn(STOP_POSITION);
hdr.AddUByteColumn(CALL);
hdr.AddFloatColumn(CONFIDENCE);
break;
case CopyNumberVariationMultiDataType:
hdr.AddAsciiColumn(REGION, info.maxName);
hdr.AddFloatColumn(SIGNAL);
hdr.AddUByteColumn(CALL);
hdr.AddFloatColumn(CONFIDENCE);
break;
case DmetCopyNumberMultiDataType:
hdr.AddAsciiColumn(PROBE_SET_NAME, info.maxName);
hdr.AddShortColumn(CN_CALL);
hdr.AddFloatColumn(CN_CONFIDENCE);
hdr.AddShortColumn(CN_FORCE);
hdr.AddFloatColumn(CN_ESTIMATE);
hdr.AddFloatColumn(CN_LOWER);
hdr.AddFloatColumn(CN_UPPER);
break;
case DmetMultiAllelicMultiDataType:
hdr.AddAsciiColumn(PROBE_SET_NAME, info.maxName);
hdr.AddUByteColumn(CALL);
hdr.AddFloatColumn(CONFIDENCE);
hdr.AddUByteColumn(FORCE);
hdr.AddUByteColumn(ALLELE_COUNT);
hdr.AddFloatColumn(SIGNAL_A);
hdr.AddFloatColumn(SIGNAL_B);
hdr.AddFloatColumn(SIGNAL_C);
hdr.AddFloatColumn(SIGNAL_D);
hdr.AddFloatColumn(SIGNAL_E);
hdr.AddFloatColumn(SIGNAL_F);
hdr.AddUByteColumn(CONTEXT_A);
hdr.AddUByteColumn(CONTEXT_B);
hdr.AddUByteColumn(CONTEXT_C);
hdr.AddUByteColumn(CONTEXT_D);
hdr.AddUByteColumn(CONTEXT_E);
hdr.AddUByteColumn(CONTEXT_F);
break;
case DmetBiAllelicMultiDataType:
hdr.AddAsciiColumn(PROBE_SET_NAME, info.maxName);
hdr.AddUByteColumn(CALL);
hdr.AddFloatColumn(CONFIDENCE);
hdr.AddUByteColumn(FORCE);
hdr.AddFloatColumn(SIGNAL_A);
hdr.AddFloatColumn(SIGNAL_B);
hdr.AddUByteColumn(CONTEXT_A);
hdr.AddUByteColumn(CONTEXT_B);
break;
case ChromosomeSummaryMultiDataType:
hdr.AddUByteColumn(CHR);
hdr.AddAsciiColumn(CHR_DISPLAY, info.maxName);
hdr.AddUIntColumn(START_INDEX);
hdr.AddUIntColumn(MARKER_COUNT);
hdr.AddFloatColumn(MIN_SIGNAL);
hdr.AddFloatColumn(MAX_SIGNAL);
hdr.AddFloatColumn(MEDIAN_CN_STATE);
hdr.AddFloatColumn(HOM_FREQ);
hdr.AddFloatColumn(HET_FREQ);
break;
case SegmentCNMultiDataType:
hdr.AddUIntColumn(SEGMENT_ID);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(START_POSITION);
hdr.AddUIntColumn(STOP_POSITION);
hdr.AddIntColumn(MARKER_COUNT);
hdr.AddUIntColumn(MEAN_MARKER_DISTANCE);
break;
case SegmentLOHMultiDataType:
hdr.AddUIntColumn(SEGMENT_ID);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(START_POSITION);
hdr.AddUIntColumn(STOP_POSITION);
hdr.AddIntColumn(MARKER_COUNT);
hdr.AddUIntColumn(MEAN_MARKER_DISTANCE);
break;
case SegmentCNNeutralLOHMultiDataType:
hdr.AddUIntColumn(SEGMENT_ID);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(START_POSITION);
hdr.AddUIntColumn(STOP_POSITION);
hdr.AddIntColumn(MARKER_COUNT);
hdr.AddUIntColumn(MEAN_MARKER_DISTANCE);
break;
case SegmentNormalDiploidMultiDataType:
hdr.AddUIntColumn(SEGMENT_ID);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(START_POSITION);
hdr.AddUIntColumn(STOP_POSITION);
hdr.AddIntColumn(MARKER_COUNT);
hdr.AddUIntColumn(MEAN_MARKER_DISTANCE);
break;
case SegmentNoCallMultiDataType:
hdr.AddUIntColumn(SEGMENT_ID);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(START_POSITION);
hdr.AddUIntColumn(STOP_POSITION);
hdr.AddIntColumn(MARKER_COUNT);
hdr.AddUIntColumn(MEAN_MARKER_DISTANCE);
break;
case SegmentMosaicismMultiDataType:
hdr.AddUIntColumn(SEGMENT_ID);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(START_POSITION);
hdr.AddUIntColumn(STOP_POSITION);
hdr.AddIntColumn(MARKER_COUNT);
hdr.AddUIntColumn(MEAN_MARKER_DISTANCE);
break;
case SegmentGenotypeConcordanceMultiDataType:
case SegmentGenotypeDiscordanceMultiDataType:
case SegmentCNLossLOHConcordanceMultiDataType:
case SegmentCNNeutralLOHConcordanceMultiDataType:
case SegmentHeteroUPDMultiDataType:
case SegmentIsoUPDMultiDataType:
case SegmentDenovoCopyNumberMultiDataType:
case SegmentHemizygousParentOfOriginMultiDataType:
hdr.AddUIntColumn(SEGMENT_ID);
hdr.AddUIntColumn(REFERENCE_SAMPLE_KEY);
hdr.AddUIntColumn(FAMILIAL_SAMPLE_KEY);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(START_POSITION);
hdr.AddUIntColumn(STOP_POSITION);
hdr.AddUByteColumn(CALL);
hdr.AddFloatColumn(CONFIDENCE);
hdr.AddIntColumn(MARKER_COUNT);
hdr.AddFloatColumn(HOMOZYGOSITY);
hdr.AddFloatColumn(HETEROZYGOSITY);
break;
case FamilialSegmentOverlapsMultiDataType:
hdr.AddAsciiColumn(SEGMENT_TYPE, info.maxSegmentType);
hdr.AddUIntColumn(REFERENCE_SAMPLE_KEY);
hdr.AddAsciiColumn(REFERENCE_SEGMENT_ID, info.maxReferenceSegmentID);
hdr.AddUIntColumn(FAMILIAL_SAMPLE_KEY);
hdr.AddAsciiColumn(FAMILIAL_SEGMENT_ID, info.maxFamilialSegmentID);
break;
case FamilialSamplesMultiDataType:
hdr.AddUIntColumn(SAMPLE_KEY);
hdr.AddAsciiColumn(ARRID, info.maxFamilialARRID);
hdr.AddAsciiColumn(CHPID, info.maxFamilialCHPID);
hdr.AddUnicodeColumn(CHP_FILENAME, info.maxFamilialCHPFile);
hdr.AddAsciiColumn(ROLE, info.maxFamilialRole);
hdr.AddUByteColumn(ROLE_VALIDITY);
hdr.AddFloatColumn(ROLE_CONFIDENCE);
break;
case AllelePeaksMultiDataType:
hdr.AddAsciiColumn(PROBE_SET_NAME, info.maxName);
hdr.AddUByteColumn(CHR);
hdr.AddUIntColumn(POSITION);
break;
case MarkerABSignalsMultiDataType:
hdr.AddUIntColumn(PROBE_SET_INDEX);
/*hdr.AddFloatColumn(A_SIGNAL);
hdr.AddFloatColumn(B_SIGNAL);
hdr.AddFloatColumn(SCAR);*/
break;
case CytoGenotypeCallMultiDataType:
hdr.AddUIntColumn(PROBE_SET_INDEX);
hdr.AddByteColumn(CALL);
hdr.AddFloatColumn(CONFIDENCE);
hdr.AddByteColumn(FORCE);
hdr.AddFloatColumn(A_SIGNAL);
hdr.AddFloatColumn(B_SIGNAL);
hdr.AddFloatColumn(SIGNAL_STRENGTH);
hdr.AddFloatColumn(CONTRAST);
break;
default:
break;
}
for (vector<ColumnInfo>::iterator it=info.metricColumns.begin(); it!=info.metricColumns.end(); ++it)
{
hdr.AddColumn(*it);
}
}
int32_t CHPData::GetOrigCnt()
{
DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(3);
DataSetHeader dpHdr = dcHdr->GetDataSet(0);
return dpHdr.GetRowCnt();
}
void CHPData::AddUnivColumns(DataSetHeader& hdr)
{
hdr.SetName(CHP_UNIV_GROUP);
//Background - float
hdr.AddFloatColumn(BackgroundColName);
}
int32_t CHPData::GetBackgroundZoneCnt()
{
DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(1);
DataSetHeader dpHdr = dcHdr->GetDataSet(0);
return dpHdr.GetRowCnt();
}
void TestFileGenerator::WriteOutGenericDataFileWithAllColumnTypes()
{
GenericDataHeader gdh;
AddStandardGenericDataHeader(gdh);
// Fill the DataGroupHeader
DataGroupHeader dch;
dch.SetName(L"default"); // default DataGroup
// Fill the all types DataSetHeader
DataSetHeader dphAT;
dphAT.SetName(L"all types");
ParameterNameValueType nvt;
nvt.SetName(L"How many types");
nvt.SetValueText(L"All types");
dphAT.AddNameValParam(nvt);
nvt.SetName(L"Powered by");
nvt.SetValueText(L"Affymetrix");
dphAT.AddNameValParam(nvt);
dphAT.AddColumn(ByteColumn(L"Byte type"));
dphAT.AddColumn(UByteColumn(L"UByte type"));
dphAT.AddColumn(ASCIIColumn(L"ASCII type", 10));
dphAT.AddColumn(ShortColumn(L"Short type"));
dphAT.AddColumn(UShortColumn(L"UShort type"));
dphAT.AddColumn(IntColumn(L"Int type"));
dphAT.AddColumn(UIntColumn(L"UInt type"));
dphAT.AddColumn(UnicodeColumn(L"Unicode type", 15));
dphAT.AddColumn(FloatColumn(L"Float type"));
int32_t rows = 2;
dphAT.SetRowCnt(rows);
dch.AddDataSetHdr(dphAT);
// Set the FileHeader
FileHeader fh;
fh.SetFilename("test.file.data_all_column_types");
fh.SetGenericDataHdr(gdh);
fh.AddDataGroupHdr(dch);
// Create the generic file writer
GenericFileWriter gfWriter(&fh);
gfWriter.WriteHeader();
DataGroupWriterIt dcwBegin, dcwEnd;
gfWriter.GetDataGroupWriters(dcwBegin, dcwEnd);
DataGroupWriter d = *dcwBegin;
dcwBegin->WriteHeader();
DataSetWriterIt dpwBegin, dpwEnd;
dcwBegin->GetDataSetWriters(dpwBegin, dpwEnd);
// Write out the all types DataSet
dpwBegin->WriteHeader();
for( int32_t row = 0; row < rows; ++row )
{
char str[10];
wchar_t wstr[15];
int8_t b = 1+10*row;
u_int8_t ub = 2+10*row;
sprintf(str, "%d", 3+10*row);
int16_t s = 4+10*row;
u_int16_t us = 5+10*row;
int32_t i = 6+10*row;
u_int32_t ui = 7+10*row;
FormatString1(wstr, 15, L"%d", 8+10*row);
float f = 9+10*row;
dpwBegin->Write(b); // btye
dpwBegin->Write(ub); // unsigned byte
dpwBegin->Write(str, 10); // ACSII string
dpwBegin->Write(s); // short
dpwBegin->Write(us); // unsigned short
dpwBegin->Write(i); // int
dpwBegin->Write(ui); // unsigned int
dpwBegin->Write(wstr, 15); // Unicode string
dpwBegin->Write(f); // float
}
dpwBegin->UpdateNextDataSetOffset();
dcwBegin->Close();
}
// Uses a mix of the GenericFileWriter and raw commands
void TestFileGenerator::WriteOutGenericDATDataFile1UsingGenericWriter()
{
GenericDataHeader gdh;
AddStandardGenericDataHeader(gdh);
// Fill the DataSetHeader
DataSetHeader dph;
dph.SetName(L"acquired data");
ParameterNameValueType nvt;
nvt.SetName(L"Scanner");
nvt.SetValueText(L"M10");
dph.AddNameValParam(nvt);
nvt.SetName(L"Pixel Size");
nvt.SetValueFloat(0.051f);
dph.AddNameValParam(nvt);
dph.AddColumn(UShortColumn(L"Pixel"));
int32_t rows = 100;
dph.SetRowCnt(rows);
// Open the file.
ofstream fileStream;
fileStream.open( "test.file.data_dat", ios_base::out | ios_base::binary | ios_base::trunc);
// Write the file header using raw methods until the writer is available.
// magic number
FileOutput::WriteUInt8(fileStream, 59);
// version
FileOutput::WriteInt8(fileStream, 1);
// Number of data cubes - confirm this
FileOutput::WriteUInt32(fileStream, 1);
// offset to the data cube byte offset array
int offsetLocation = fileStream.tellp();
FileOutput::WriteUInt32(fileStream, 1); //????
// Write the GenericDataHeader to the file
GenericDataHeaderWriter gdhWriter;
gdhWriter.Write(fileStream, gdh);
//
// Data Cube
//
int offset = fileStream.tellp();
// Write the DataSetHeader
DataSetWriter dphWriter(&fileStream, &dph);
dphWriter.WriteHeader();
// Write out the data
for( int32_t i=0; i < rows; ++i )
{
u_int16_t value = (u_int16_t)(i*10+i);
FileOutput::WriteUInt16(fileStream, value);
}
// write the offset
fileStream.seekp(offsetLocation);
FileOutput::WriteUInt32(fileStream, offset);
fileStream.close();
}
int32_t CHPQuantificationData::GetEntryCount()
{
DataGroupHeader* dcHdr = &genericData.Header().GetDataGroup(0);
DataSetHeader dpHdr = dcHdr->GetDataSet(0);
return dpHdr.GetRowCnt();
}
void CHPData::AddExprColumns(DataSetHeader& hdr, bool hasCompData)
{
hdr.SetName(CHP_EXPR_GROUP);
//Probeset name - string
hdr.AddAsciiColumn(ProbeSetNameColName, maxProbeSetName);
//Detection - unsigned char
hdr.AddUByteColumn(DetectionColName);
//Detection p-value - float
hdr.AddFloatColumn(DetectionPValueColName);
//Signal - float
hdr.AddFloatColumn(SignalColName);
//Number of pairs - unsigned short
hdr.AddUShortColumn(NumberPairsColName);
//Number of pairs used - unsigned short
hdr.AddUShortColumn(NumberPairsUsedColName);
if (hasCompData == true)
{
//Change - unsigned char
hdr.AddUByteColumn(ChangeColName);
//Change p-value - float
hdr.AddFloatColumn(ChangePValueColName);
//Signal Log Ratio - float
hdr.AddFloatColumn(SignalLogRatioColName);
//Signal Log Ratio Low - float
hdr.AddFloatColumn(SignalLogRatioLowColName);
//Signal Log Ratio High - float
hdr.AddFloatColumn(SignalLogRatioHighColName);
//Common Pairs - unsigned short
hdr.AddUShortColumn(CommonPairsColName);
}
}
void DataSetUpdaterTest::CreateReferenceFile()
{
// Create the data object.
GenericData data;
data.Header().SetFilename(TEST_FILE);
DataGroupHeader dgHdr(L"data");
DataSetHeader dsHdr;
dsHdr.SetName(L"test");
dsHdr.AddAsciiColumn(L"string8", 64);
dsHdr.AddUnicodeColumn(L"string16", 64);
dsHdr.AddByteColumn(L"int8");
dsHdr.AddShortColumn(L"int16");
dsHdr.AddIntColumn(L"int32");
dsHdr.AddUByteColumn(L"uint8");
dsHdr.AddUShortColumn(L"uint16");
dsHdr.AddUIntColumn(L"uint32");
dsHdr.AddFloatColumn(L"float");
dsHdr.SetRowCnt(3);
dgHdr.AddDataSetHdr(dsHdr);
data.Header().AddDataGroupHdr(dgHdr);
data.Header().GetGenericDataHdr()->SetFileTypeId("affymetrix.test.data");
// Write the data object to the file
GenericFileWriter writer(&data.Header());
writer.WriteHeader();
DataGroupWriter &dataGroupWriter = writer.GetDataGroupWriter(0);
dataGroupWriter.WriteHeader();
//int iSet=0;
DataSetWriterIt beginSet;
DataSetWriterIt endSet;
dataGroupWriter.GetDataSetWriters(beginSet, endSet);
beginSet->WriteHeader();
int32_t dataSetSz = beginSet->GetDataSetSize();
int32_t offset = writer.GetFilePos();
writer.SeekFromCurrentPos(dataSetSz + 1);
beginSet->UpdateNextDataSetOffset();
dataGroupWriter.UpdateNextDataGroupPos();
writer.SeekFromBeginPos(offset);
// Write the data.
beginSet->Write("first_row", 64);
beginSet->Write(L"first_row", 64);
beginSet->Write((int8_t) 1);
beginSet->Write((int16_t) 1);
beginSet->Write((int32_t) 1);
beginSet->Write((u_int8_t) 1);
beginSet->Write((u_int16_t) 1);
beginSet->Write((u_int32_t) 1);
beginSet->Write(1.0f);
beginSet->Write("second_row", 64);
beginSet->Write(L"second_row", 64);
beginSet->Write((int8_t) 2);
beginSet->Write((int16_t) 2);
beginSet->Write((int32_t) 2);
beginSet->Write((u_int8_t) 2);
beginSet->Write((u_int16_t) 2);
beginSet->Write((u_int32_t) 2);
beginSet->Write(2.0f);
beginSet->Write("third_row", 64);
beginSet->Write(L"third_row", 64);
beginSet->Write((int8_t) 3);
beginSet->Write((int16_t) 3);
beginSet->Write((int32_t) 3);
beginSet->Write((u_int8_t) 3);
beginSet->Write((u_int16_t) 3);
beginSet->Write((u_int32_t) 3);
beginSet->Write(3.0f);
}
