void CDFData::SetDataTypeId(CDFDataTypeIds p, int32_t probesetCnt)
{
GenericDataHeader* gPtr = genericData.Header().GetGenericDataHdr();
std::string typeId;
std::wstring groupName;
if(p == Expression)
{
typeId = AFFY_EXPR_PS;
groupName = CDF_PS_GROUP_LBL;
}
else if(p == Genotyping)
{
typeId = AFFY_GENO_PS;
groupName = CDF_PS_GROUP_LBL;
}
else if(p == Tag)
{
typeId = AFFY_TAG_PS;
groupName = CDF_PS_GROUP_LBL;
}
else if(p == Resequencing)
{
typeId = AFFY_RESEQ_PS;
groupName = CDF_PS_GROUP_LBL;
}
else
{
typeId = AFFY_CNTRL_PS;
groupName = CDF_QC_GROUP_LBL;
}
gPtr->SetFileTypeId(typeId);
CreateDataGroups(groupName, probesetCnt);
}
void CDFData::SetUInt32ToGenericHdr(const std::wstring& name, u_int32_t value)
{
ParameterNameValueType paramType;
paramType.SetName(name);
paramType.SetValueUInt32(value);
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
hdr->AddNameValParam(paramType);
}
void CHPQuantificationData::SetWStringToGenericHdr(const std::wstring& name, const std::wstring value, int32_t reserve)
{
ParameterNameValueType paramType;
paramType.SetName(name);
paramType.SetValueText(value, reserve);
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
hdr->AddNameValParam(paramType);
}
void CHPData::SetFloatToGenericHdr(const std::wstring& name, float value)
{
ParameterNameValueType paramType;
paramType.SetName(name);
paramType.SetValueFloat(value);
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
hdr->AddNameValParam(paramType);
}
void CDFData::SetRefSequence(const std::string &seq)
{
GenericDataHeader* gPtr = genericData.Header().GetGenericDataHdr();
ParameterNameValueType paramType;
paramType.SetName(CDF_REFSEQ_PARAM);
paramType.SetValueAscii(seq);
gPtr->AddNameValParam(paramType);
}
ParameterNameValueType CHPData::GetAlgParam(const std::wstring& tag)
{
std::wstring name = ALGORITHM_PARAM_NAME_PREFIX_S + tag;
ParameterNameValueType paramType;
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
hdr->FindNameValParam(name, paramType);
ParameterNameValueType type = paramType;
type.SetName(tag);
return type;
}
ParameterNameValueType CHPData::GetChipSum(const std::wstring& tag)
{
std::wstring name = CHIP_SUMMARY_PARAMETER_NAME_PREFIX_S + tag;
ParameterNameValueType paramType;
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
hdr->FindNameValParam(name, paramType);
ParameterNameValueType type = paramType;
type.SetName(tag);
return type;
}
void CHPMultiDataData::AddAppMetaInfo(const ParameterNameValueTypeList& params)
{
ParameterNameValueType param;
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
for (ParameterNameValueTypeList::const_iterator it=params.begin(); it != params.end(); ++it)
{
param = *it;
param.SetName(APPLICATION_META_INFO_PREFIX_S + param.GetName());
hdr->AddNameValParam(param);
}
}
int32_t CHPData::GetInt32FromGenericHdr(const std::wstring& name)
{
int32_t result = 0;
ParameterNameValueType paramType;
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
if (hdr->FindNameValParam(name, paramType))
{
result = paramType.GetValueInt32();
}
return result;
}
void CHPMultiDataData::AddAlgParams(const ParameterNameValueTypeList& params)
{
ParameterNameValueType param;
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
for (ParameterNameValueTypeList::const_iterator it=params.begin(); it != params.end(); it++)
{
param = *it;
param.SetName(ALGORITHM_PARAM_NAME_PREFIX_S + param.GetName());
hdr->AddNameValParam(param);
}
}
void CHPQuantificationData::AddSummaryParams(const ParameterNameValueTypeList& params)
{
ParameterNameValueType param;
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
for (ParameterNameValueTypeList::const_iterator it=params.begin(); it != params.end(); it++)
{
param = *it;
param.SetName(CHIP_SUMMARY_PARAMETER_NAME_PREFIX_S + param.GetName());
hdr->AddNameValParam(param);
}
}
std::wstring CHPQuantificationData::GetWStringFromGenericHdr(const std::wstring& name)
{
std::wstring result;
ParameterNameValueType paramType;
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
if (hdr->FindNameValParam(name, paramType))
{
result = paramType.GetValueText();
}
return result;
}
std::string CDFData::GetRefSequence()
{
std::string result;
ParameterNameValueType paramType;
GenericDataHeader* hdr = genericData.Header().GetGenericDataHdr();
if (hdr->FindNameValParam(CDF_REFSEQ_PARAM, paramType))
{
result = paramType.GetValueAscii();
}
return result;
}
std::wstring CalvinCELDataAdapter::GetDatHeader()
{
std::wstring datHeader;
//GenDataHdrVectorIt begin, end;
GenericDataHeader* gdh = calvinCel.GetFileHeader()->GetGenericDataHdr()->FindParent(SCAN_ACQUISITION_DATA_TYPE);
if (gdh)
{
// found the right header, now look for the parameter
ParameterNameValueType nvt;
if (gdh->FindNameValParam(DAT_HEADER_PARAM_NAME, nvt))
{
if (nvt.GetParameterType() == ParameterNameValueType::TextType)
datHeader = nvt.GetValueText();
}
else if (gdh->FindNameValParam(PARTIAL_DAT_HEADER_PARAM_NAME, nvt))
{
if (nvt.GetParameterType() == ParameterNameValueType::TextType)
{
std::wstring partialDatHeader = nvt.GetValueText();
u_int16_t min = 0;
u_int16_t max = 0;
// Find the max and min parameters and append to the string.
if (gdh->FindNameValParam(MAX_PIXEL_INTENSITY_PARAM_NAME, nvt))
{
if (nvt.GetParameterType() == ParameterNameValueType::UInt16Type)
max = nvt.GetValueUInt16();
}
if (gdh->FindNameValParam(MIN_PIXEL_INTENSITY_PARAM_NAME, nvt))
{
if (nvt.GetParameterType() == ParameterNameValueType::UInt16Type)
min = nvt.GetValueUInt16();
}
wchar_t buf[30]=L"";
FormatString2(buf, 30, L"[%d..%d]", min, max);
datHeader = buf;
datHeader += partialDatHeader;
}
}
}
return datHeader;
}
void TestFileGenerator::WriteSmallCelFileWithAPartialDatHeaderTest()
{
CelFileData data("small_cel_file_partial_datheader");
// Write
ParameterNameValueType nvt;
GenericDataHeader datHdr;
datHdr.SetFileId(AffymetrixGuid::GenerateNewGuid());
datHdr.SetFileTypeId("affymetrix-calvin-scan-acquisition");
datHdr.SetFileCreationTime(L"2004-07-01T13:14:15Z");
nvt.SetName(L"affymetrix-partial-dat-header");
std::wstring datHeaderString = L" small_cel_file_partial_datheader:CLS=25 RWS=25 XIN=1 YIN=1 VE=0 0 05/19/05 02:45:59 ScannerID: ScannerTyp \x14 \x14 Hg-Small.1sq \x14 \x14 \x14 \x14 \x14 570 \x14 45.200001 \x14 0.340000 \x14 1.0900 \x14 3";
nvt.SetValueText(datHeaderString);
datHdr.AddNameValParam(nvt);
nvt.SetName(L"affymetrix-max-pixel-intensity");
nvt.SetValueUInt16(46001);
datHdr.AddNameValParam(nvt);
nvt.SetName(L"affymetrix-min-pixel-intensity");
nvt.SetValueUInt16(1);
datHdr.AddNameValParam(nvt);
// Add DAT GenericDataHeader as parent.
data.GetFileHeader()->GetGenericDataHdr()->AddParent(datHdr);
WriteRemaingSmallCelFileWithGridParameters(data);
}
void GenericDataHeaderWriter::WriteParentHdrs(std::ofstream &os, GenericDataHeader &g)
{
GenDataHdrVectorIt begin;
GenDataHdrVectorIt end;
g.GetParentIterators(begin, end);
while(begin != end)
{
Write(os, *begin);
begin++;
}
}
void TestFileGenerator::WriteSmallCelFileWithAFullDatHeaderTest() // Files converted from GCOS will have a full DatHeader
{
CelFileData data("small_cel_file_full_datheader");
// Write
ParameterNameValueType nvt;
GenericDataHeader datHdr;
datHdr.SetFileId(AffymetrixGuid::GenerateNewGuid());
datHdr.SetFileTypeId("affymetrix-calvin-scan-acquisition");
datHdr.SetFileCreationTime(L"2004-07-01T13:14:15Z");
nvt.SetName(L"affymetrix-dat-header");
std::wstring datHeaderString = L"[45..56789] small_cel_file_full_datheader:CLS=25 RWS=25 XIN=1 YIN=1 VE=0 0 05/19/05 02:45:59 ScannerID: ScannerTyp \x14 \x14 Hg-Small.1sq \x14 \x14 \x14 \x14 \x14 570 \x14 45.200001 \x14 0.340000 \x14 1.0900 \x14 3";
nvt.SetValueText(datHeaderString);
datHdr.AddNameValParam(nvt);
// Add DAT GenericDataHeader as parent.
data.GetFileHeader()->GetGenericDataHdr()->AddParent(datHdr);
WriteRemaingSmallCelFileWithGridParameters(data);
}
void GenericDataHeaderWriter::WriteNameValParams(std::ofstream &os, GenericDataHeader &g)
{
ParameterNameValueTypeIt begin;
ParameterNameValueTypeIt end;
g.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++;
}
}
static int Fusion_GetDataSetOffsetAndSize
(
const char *file_name,
const char *wavelength,
int &offset,
int &size,
char *err_msg,
int err_msg_alloc_sz
)
{
GenericFileReader reader;
string fname = file_name;
reader.SetFilename (fname);
GenericData hdr_data;
reader.ReadHeader (hdr_data);
GenericDataHeader *hdr = hdr_data.Header ().GetGenericDataHdr ();
ParameterNameValueType cel_cols,cel_rows;
if (hdr->FindNameValParam(L"affymetrix-cel-cols",cel_cols) == false ||
hdr->FindNameValParam(L"affymetrix-cel-cols",cel_rows) == false)
{
strncpy (err_msg,"Invalid cel file",sizeof(err_msg_alloc_sz)-1);
return FALSE;
}
string err_s;
while (1)
{
size_t len = strlen (wavelength)+1;
wchar_t *_wavelength = new wchar_t[len];
for (UINT i=0; i<len; i++)
{
_wavelength[i] = (WORD)wavelength[i];
}
wstring group_name = _wavelength;
delete [] _wavelength;
DataGroupHeader *data_group_header = hdr_data.Header ().FindDataGroupHeader (group_name);
if (data_group_header == 0)
{
err_s = "Missing data group ";
err_s += wavelength;
break;
}
DataSet *data_set = GetDataSet (L"Intensity", group_name, hdr_data);
if (data_set == 0)
{
err_s = "Missing data set \"Intensity\"";
break;
}
offset = data_set->Header ().GetDataStartFilePos ();
size = data_set->Header ().GetDataSize ();
break;
}
if (strlen (err_s.c_str ()))
{
strncpy (err_msg,err_s.c_str (),sizeof(err_msg_alloc_sz)-1);
return FALSE;
}
return TRUE;
}
std::string CDFData::GetDataTypeId()
{
GenericDataHeader* gPtr = genericData.Header().GetGenericDataHdr();
return gPtr->GetFileTypeId();
}
void TestFileGenerator::AddStandardGenericDataHeader(GenericDataHeader& gdh)
{
// Fill the GenericDataHeader.
gdh.SetFileTypeId(SCAN_ACQUISITION_DATA_TYPE);
gdh.SetFileId("test-dat-guid");
gdh.SetFileCreationTime(L"2004-07-04T11:12:13Z");
gdh.SetLocale(L"en-US");
ParameterNameValueType nvt;
nvt.SetName(ARRAY_TYPE_PARAM_NAME);
nvt.SetValueText(L"Hg-U133A");
gdh.AddNameValParam(nvt);
nvt.SetName(ARRAY_BARCODE_PARAM_NAME);
nvt.SetValueText(L"Barcode");
gdh.AddNameValParam(nvt);
nvt.SetName(L"Parameter1");
nvt.SetValueText(L"Value1");
gdh.AddNameValParam(nvt);
GenericDataHeader gdhParent;
gdhParent.SetFileTypeId(ARRAY_TYPE_IDENTIFIER);
gdhParent.SetFileId("test-array-guid");
gdhParent.SetFileCreationTime(L"2004-07-01T13:14:15Z");
gdhParent.SetLocale(L"en-US");
nvt.SetName(ARRAY_TYPE_PARAM_NAME);
nvt.SetValueText(L"Hg-U133A");
gdhParent.AddNameValParam(nvt);
nvt.SetName(ARRAY_LOT_PARAM_NAME);
nvt.SetValueText(L"Thanks alot");
gdhParent.AddNameValParam(nvt);
gdh.AddParent(gdhParent);
}
void GenericDataHeaderWriter::WriteFileId(std::ofstream &os, const GenericDataHeader &g) const
{
FileOutput::WriteString8(os, g.GetFileId());
}
/**
* No more probesets will be processed, this is a chance to finish outputting
* results and clean up.
* @param qMethod - Quantification method that was used.
* @return true if success, false otherwise.
*/
bool QuantMethodExprCCCHPReport::finish(QuantMethod &qMethod)
{
// Sanity to check we saw all the probe sets we were expecting.
if (m_CurrentProbeSetCount != m_Info.m_NumProbeSets) {
Err::errAbort("QuantMethodExprCCCHPReport::finish() - Expecting: " + ToStr(m_Info.m_NumProbeSets) +
" but got: " + ToStr(m_CurrentProbeSetCount) + ". Command Console CHP file will be corrupt.");
}
// Flush remaining signal entries in the buffer.
m_ExpressionQuantificationBufferWriter.FlushBuffer();
// Rewrite CHP files to get chip summary entires
Verbose::out(1,"Creating final files for CHP output");
Verbose::progressBegin(1, ToStr("Finalizing Expression CHP Files"),
m_CHPFileNames.size(), 1, m_CHPFileNames.size());
try {
for (unsigned int chip = 0; chip < m_CHPFileNames.size(); chip++) {
// open up tmp chp file to pull results from
GenericData data;
GenericFileReader reader;
std::string filename = m_CHPFileNames[chip]+".tmp";
reader.SetFilename(filename);
reader.ReadHeader(data);
GenericDataHeader* hdr = data.Header().GetGenericDataHdr();
GenericDataHeader updateHdr;
for (int source = 0; source < m_ChipSummaries.size(); source++) {
ChipSummary::metricDefVec_t metricDefs = m_ChipSummaries[source]->getMetricDefs();
for (int i = 0; i < metricDefs.size(); i++) {
ChipSummary::Metric metric;
if (!m_ChipSummaries[source]->getMetric(chip, metricDefs[i].m_name, metric)) {
Err::errAbort("QuantMethodExprCCCHPReport: metric '" + metricDefs[i].m_name +
"' was not found");
}
std::wstring mName(CHIP_SUMMARY_PARAMETER_NAME_PREFIX);
mName += StringUtils::ConvertMBSToWCS(metric.m_Name);
ParameterNameValueType param;
if (hdr->FindNameValParam(mName, param) == false) {
Err::errAbort("QuantMethodExprCCCHPReport: metric name '" + StringUtils::ConvertWCSToMBS(mName) +
"' could not be found in the header of " + filename);
}
switch (param.GetParameterType()) {
case ParameterNameValueType::Int8Type:
param.SetValueInt8((int8_t)metric.m_Integer);
break;
case ParameterNameValueType::UInt8Type:
param.SetValueUInt8((u_int8_t)metric.m_Integer);
break;
case ParameterNameValueType::Int16Type:
param.SetValueInt16((int16_t)metric.m_Integer);
break;
case ParameterNameValueType::UInt16Type:
param.SetValueUInt16((u_int16_t)metric.m_Integer);
break;
case ParameterNameValueType::Int32Type:
param.SetValueInt32((int32_t)metric.m_Integer);
break;
case ParameterNameValueType::UInt32Type:
param.SetValueUInt32((u_int32_t)metric.m_Integer);
break;
case ParameterNameValueType::FloatType:
param.SetValueFloat((float)metric.m_Double);
break;
case ParameterNameValueType::TextType:
param.SetValueText(StringUtils::ConvertMBSToWCS(metric.m_String), (int) metric.m_String.length());
break;
case ParameterNameValueType::AsciiType:
if (metric.m_String.size() > 256) {
Err::errAbort("QuantMethodExprCCCHPReport: string header parameter too long, name = '" +
metric.m_Name + "', value = '" + metric.m_String + "'");
}
param.SetValueAscii(metric.m_String, (int) metric.m_String.length());
break;
default:
Err::errAbort("QuantMethodExprCCCHPReport: unknown header parameter type found in file " +
filename);
}
updateHdr.AddNameValParam(param);
}
}
std::ofstream os;
Fs::aptOpen(os, filename, std::ios::out|std::ios::binary|std::ios::in);
if (!os) {
Err::errAbort("QuantMethodExprCCCHPReport: file " + filename +
" could not be opened for writing");
}
GenericDataHeaderUpdater updater;
updater.Update(os, updateHdr, *hdr);
os.close();
Verbose::progressStep(1);
}
} catch (...) {
removeAllChps();
Err::errAbort("Error in creating final CHP output.");
}
Verbose::progressEnd(1, ToStr("Done."));
// Remove .tmp extension
for (unsigned int i = 0; i < m_CHPFileNames.size(); i++) {
std::string from = m_CHPFileNames[i] + ".tmp";
std::string to = m_CHPFileNames[i];
if (!Fs::fileRename(from.c_str(),to.c_str())) {
removeAllChps();
Err::errAbort("Unable to rename '" + from + "' to '" + to + "'");
}
}
removeTmpChps();
return true;
}
void GenericDataHeaderWriter::WriteFileCreationTime(std::ofstream &os, const GenericDataHeader &g) const
{
FileOutput::WriteString16(os, g.GetFileCreationTime());
}
void GenericDataHeaderWriter::WriteLocale(std::ofstream &os, const GenericDataHeader &g) const
{
FileOutput::WriteString16(os, g.GetLocale());
}
void GenericDataHeaderWriter::WriteNameValParamCnt(std::ofstream &os, const GenericDataHeader &g) const
{
FileOutput::WriteInt32(os, g.GetNameValParamCnt());
}
/*
* Create a results file with the CEL file header and other parameters.
*/
void CopyNumberResultWriter::CreateResultFile(affymetrix_fusion_io::FusionCELData& cel, const std::string& fileName)
{
try
{
// Create the results file with the header.
CHPMultiDataData *data = new CHPMultiDataData(fileName);
data->SetEntryCount(CopyNumberMultiDataType, numberProbeSets, maxProbeSetNameLength[CopyNumberMultiDataType], columns);
if (numberCytoRegions > 0)
data->SetEntryCount(CytoMultiDataType, numberCytoRegions, maxProbeSetNameLength[CytoMultiDataType],cytoRegionColumns);
if (numberGenotypeProbeSets > 0)
data->SetEntryCount(GenotypeMultiDataType, numberGenotypeProbeSets, maxProbeSetNameLength[GenotypeMultiDataType], genotypeColumns);
data->SetAlgName(StringUtils::ConvertMBSToWCS(algName));
data->SetAlgVersion(StringUtils::ConvertMBSToWCS(algVersion));
data->SetArrayType(cel.GetChipType());
GenericDataHeader *gdh = data->GetFileHeader()->GetGenericDataHdr();
ParameterNameValueType param;
param.SetName(PROGRAM_NAME);
param.SetValueText(StringUtils::ConvertMBSToWCS(programName));
gdh->AddNameValParam(param);
param.SetName(L"program-version");
param.SetValueText(StringUtils::ConvertMBSToWCS(programVersion));
gdh->AddNameValParam(param);
param.SetName(PROGRAM_COMPANY);
param.SetValueText(StringUtils::ConvertMBSToWCS(programCompany));
gdh->AddNameValParam(param);
ParameterNameValueTypeList params = algParams;
param.SetName(L"ArraySet");
param.SetValueText(cel.GetChipType());
params.push_back(param);
data->AddAlgParams(params);
data->AddSummaryParams(summaryParams);
DataSetHeader *dsh = data->GetDataSetHeader(CopyNumberMultiDataType);
for (ParameterNameValueTypeList::iterator it=chrStartStop.begin(); it!=chrStartStop.end(); it++)
dsh->AddNameValParam(*it);
GenericData *gdata = cel.GetGenericData();
if (gdata != NULL)
gdh->AddParent(*gdata->Header().GetGenericDataHdr());
CHPMultiDataFileWriter *writer = new CHPMultiDataFileWriter(*data);
delete writer;
delete data;
// Create a buffer writer object
outputFiles.clear();
outputFiles.push_back(fileName);
vector<MultiDataType> dataTypes;
dataTypes.push_back(CopyNumberMultiDataType);
if (numberCytoRegions > 0)
dataTypes.push_back(CytoMultiDataType);
if (numberGenotypeProbeSets > 0)
dataTypes.push_back(GenotypeMultiDataType);
bufferWriter = new CHPMultiDataFileBufferWriter();
bufferWriter->Initialize(&outputFiles, dataTypes, maxProbeSetNameLength);
}
catch (CalvinException &ex)
{
string err = "Error creating the output file: " + fileName;
wstring msg = ex.ToString();
if (msg.empty() == false)
err += " " + StringUtils::ConvertWCSToMBS(msg);
throw err;
}
catch (...)
{
string err = "Error creating the output file: " + fileName;
throw err;
}
}
void GenericDataHeaderWriter::WriteParentHdrCnt(std::ofstream &os, const GenericDataHeader &g) const
{
FileOutput::WriteInt32(os, g.GetParentCnt());
}
