ERR_VALUE read_set_generate_from_sequence(const char *Seq, const size_t SeqLen, const uint32_t ReadLength, const size_t ReadCount, PONE_READ *ReadSet)
{
PONE_READ r = NULL;
PONE_READ tmpReadSet = NULL;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(ReadCount, sizeof(ONE_READ), &tmpReadSet);
if (ret == ERR_SUCCESS) {
r = tmpReadSet;
for (size_t i = 0; i < ReadCount; ++i) {
memset(r, 0, sizeof(ONE_READ));
r->Pos = utils_ranged_rand(0, SeqLen - ReadLength + 1);
r->PosQuality = 254;
r->ReadSequenceLen = ReadLength;
ret = utils_calloc(r->ReadSequenceLen + 1, sizeof(char), &r->ReadSequence);
if (ret == ERR_SUCCESS) {
memcpy(r->ReadSequence, Seq + r->Pos, r->ReadSequenceLen*sizeof(char));
r->ReadSequence[r->ReadSequenceLen] = '\0';
r->QualityLen = r->ReadSequenceLen;
ret = utils_calloc(r->QualityLen, sizeof(uint8_t), &r->Quality);
if (ret == ERR_SUCCESS)
memset(r->Quality, 254, r->QualityLen);
if (ret != ERR_SUCCESS)
utils_free(r->ReadSequence);
}
if (ret != ERR_SUCCESS) {
--r;
for (size_t j = 0; j < i; ++j) {
_read_destroy_structure(r);
--r;
}
break;
}
++r;
}
if (ret == ERR_SUCCESS)
*ReadSet = tmpReadSet;
if (ret != ERR_SUCCESS)
utils_free(tmpReadSet);
}
return ret;
}
static ERR_VALUE _examine_read_coverage(const ONE_READ *Reads, const size_t ReadCount, const char *RefSeq, const size_t RefSeqLen, const char *Alternate)
{
uint32_t *c = NULL;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(RefSeqLen, sizeof(uint32_t), &c);
if (ret == ERR_SUCCESS) {
memset(c, 0, RefSeqLen*sizeof(uint32_t));
for (size_t i = 0; i < ReadCount; ++i) {
for (size_t j = 0; j < Reads[i].ReadSequenceLen; ++j)
c[Reads[i].Pos + j]++;
}
printf("Not covered: ");
for (size_t i = 0; i < RefSeqLen; ++i) {
if (c[i] == 0) {
printf("%u ", i);
if (RefSeq[i] != Alternate[i]) {
printf("%u: The position has SNPs but is not covered in any read (%c %c)\n", i, RefSeq[i], Alternate[i]);
ret = ERR_BAD_READ_COVERAGE;
}
}
}
printf("\n");
utils_free(c);
}
return ret;
}
ERR_VALUE read_set_load(FILE *Stream, PONE_READ *ReadSet, size_t *Count)
{
uint32_t count32 = 0;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
PONE_READ tmpReadSet = NULL;
ret = utils_fread(&count32, sizeof(count32), 1, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_calloc(count32, sizeof(ONE_READ), &tmpReadSet);
if (ret == ERR_SUCCESS) {
for (uint32_t i = 0; i < count32; ++i) {
ret = read_load(Stream, tmpReadSet + i);
if (ret != ERR_SUCCESS) {
for (uint32_t j = 0; j < i; ++j)
_read_destroy_structure(tmpReadSet + j);
break;
}
}
if (ret == ERR_SUCCESS) {
*ReadSet = tmpReadSet;
*Count = count32;
}
if (ret != ERR_SUCCESS)
utils_free(tmpReadSet);
}
}
return ret;
}
ERR_VALUE read_load(FILE *Stream, PONE_READ Read)
{
uint32_t rsLen32 = 0;
uint32_t qLen32 = 0;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
memset(Read, 0, sizeof(ONE_READ));
ret = utils_fread(&rsLen32, sizeof(rsLen32), 1, Stream);
if (ret == ERR_SUCCESS) {
Read->ReadSequenceLen = rsLen32;
ret = utils_calloc(Read->ReadSequenceLen + 1, sizeof(char), &Read->ReadSequence);
if (ret == ERR_SUCCESS) {
Read->ReadSequence[Read->ReadSequenceLen] = '\0';
ret = utils_fread(Read->ReadSequence, sizeof(char), Read->ReadSequenceLen, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_fread(&qLen32, sizeof(qLen32), 1, Stream);
if (ret == ERR_SUCCESS) {
Read->QualityLen = qLen32;
ret = utils_calloc(Read->QualityLen, sizeof(uint8_t), &Read->Quality);
if (ret == ERR_SUCCESS) {
ret = utils_fread(Read->Quality, sizeof(uint8_t), Read->QualityLen, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_fread(&Read->Pos, sizeof(Read->Pos), 1, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_fread(&Read->PosQuality, sizeof(Read->PosQuality), 1, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_fread(&Read->Flags, sizeof(Read->Flags), 1, Stream);
if (ret == ERR_SUCCESS)
read_split(Read);
}
}
}
if (ret != ERR_SUCCESS)
utils_free(Read->Quality);
}
}
}
if (ret != ERR_SUCCESS)
utils_free(Read->ReadSequence);
}
}
return ret;
}
ERR_VALUE read_copy(PONE_READ Dest, const ONE_READ *Source)
{
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = ERR_SUCCESS;
*Dest = *Source;
if (Dest->CIGARLen > 0)
ret = utils_copy_string(Source->CIGAR, &Dest->CIGAR);
if (ret == ERR_SUCCESS) {
if (Dest->TemplateNameLen > 0)
ret = utils_copy_string(Source->TemplateName, &Dest->TemplateName);
if (ret == ERR_SUCCESS) {
if (Dest->ReadSequenceLen > 0)
ret = utils_copy_string(Source->ReadSequence, &Dest->ReadSequence);
if (ret == ERR_SUCCESS) {
if (Dest->QualityLen > 0) {
ret = utils_calloc(Dest->QualityLen + 1, sizeof(uint8_t), &Dest->Quality);
if (ret == ERR_SUCCESS) {
memcpy(Dest->Quality, Source->Quality, Dest->QualityLen);;
Dest->Quality[Dest->QualityLen] = 0;
}
}
if (ret == ERR_SUCCESS && Source->RNameLen > 0)
ret = utils_copy_string(Source->RName, &Dest->RName);
if (ret == ERR_SUCCESS && Source->RNextLen > 0)
ret = utils_copy_string(Source->RNext, &Dest->RNext);
if (ret != ERR_SUCCESS) {
if (Dest->ReadSequenceLen > 0)
utils_free(Dest->ReadSequence);
}
}
if (ret != ERR_SUCCESS) {
if (Dest->TemplateNameLen > 0)
utils_free(Dest->TemplateName);
}
}
if (ret != ERR_SUCCESS) {
if (Dest->CIGARLen > 0)
utils_free(Dest->CIGAR);
}
}
return ret;
}
ERR_VALUE read_create_from_test_line(const char *Line, const size_t Length, PONE_READ *Read)
{
PONE_READ tmpRead = NULL;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(1, sizeof(ONE_READ), &tmpRead);
if (ret == ERR_SUCCESS) {
memset(tmpRead, 0, sizeof(ONE_READ));
tmpRead->Pos = (uint64_t)-1;
tmpRead->ReadSequenceLen = Length;
ret = utils_calloc(Length + 1, sizeof(char), &tmpRead->ReadSequence);
if (ret == ERR_SUCCESS) {
memcpy(tmpRead->ReadSequence, Line, Length*sizeof(char));
tmpRead->ReadSequence[Length] = '\0';
*Read = tmpRead;
}
if (ret != ERR_SUCCESS)
utils_free(tmpRead);
}
return ret;
}
ERR_VALUE read_set_merge(PONE_READ *Target, const size_t TargetCount, struct _ONE_READ *Source, const size_t SourceCount)
{
PONE_READ tmp = NULL;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(TargetCount + SourceCount, sizeof(ONE_READ), &tmp);
if (ret == ERR_SUCCESS) {
memcpy(tmp, *Target, TargetCount*sizeof(ONE_READ));
memcpy(tmp + TargetCount, Source, SourceCount*sizeof(ONE_READ));
utils_free(Source);
utils_free(*Target);
*Target = tmp;
}
return ret;
}
struct packet_buffer *init_packet_buffer_v2 (const int number_of_buffer) {
int i;
struct packet_buffer_t *ptr;
fprintf (stderr, "Allocate %d packet buffer ... ",
number_of_buffer);
if ((pktlink = utils_calloc (number_of_buffer,
sizeof (struct packet_buffer_t))) == NULL) {
fprintf (stderr, "error\n");
return NULL;
} else {
packet_buffer_count = number_of_buffer;
}
for (i = 0, ptr = NULL; i < packet_buffer_count; i++) {
// full_packet[i].buffer_ready = 0;
// pktlink[i].buffer_ready = 0;
pktlink[i].prev = NULL;
pktlink[i].next = ptr;
ptr = &pktlink[i];
}
pkt_freelist = ptr;
pkt_use_front = NULL;
pkt_use_rear = NULL;
fprintf (stderr, "ok\n");
bufuse = 0;
pktbuf.request = &request;
pktbuf.retrieve = &retrieve;
pktbuf.dequeue = &dequeue;
pktbuf.ready = &bufready;
pktbuf.close = &pktbuf_close;
pktbuf.count = &pktbuf_count;
pktbuf.num_of_buffers = &pktbuf_num_of_buffers;
pktbuf.num_of_freebuf = &pktbuf_num_of_freebuf;
return &pktbuf;
}
ERR_VALUE seq_load(FILE *Stream, char **RefSeq, size_t *Length)
{
char *tmpSeq = NULL;
uint32_t length32 = 0;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_fread(&length32, sizeof(length32), 1, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_calloc(length32 + 1, sizeof(char), &tmpSeq);
if (ret == ERR_SUCCESS) {
tmpSeq[length32] = '\0';
ret = utils_fread(tmpSeq, sizeof(char), length32, Stream);
if (ret == ERR_SUCCESS) {
*RefSeq = tmpSeq;
*Length = length32;
}
if (ret != ERR_SUCCESS)
utils_free(tmpSeq);
}
}
return ret;
}
ERR_VALUE kmer_freq_distribution(const PROGRAM_OPTIONS *Options, const uint32_t KMerSize, const ONE_READ *Reads, const size_t ReadCount)
{
int err;
size_t maxValue = 0;
khiter_t it;
size_t kmerCount = 0;
char *kmerString = NULL;
khash_t(kc) *table = kh_init(kc);
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(KMerSize + 1, sizeof(char), &kmerString);
if (ret == ERR_SUCCESS) {
const ONE_READ *r = Reads;
kmerString[KMerSize] = '\0';
for (size_t i = 0; i < ReadCount; ++i) {
const READ_PART *p = &r->Part;
read_split(r);
if (p->ReadSequenceLength >= KMerSize) {
for (size_t j = 0; j < p->ReadSequenceLength - KMerSize + 1; ++j) {
char *s = NULL;
memcpy(kmerString, p->ReadSequence + j, KMerSize*sizeof(char));
ret = utils_copy_string(kmerString, &s);
if (ret == ERR_SUCCESS) {
it = kh_put(kc, table, s, &err);
switch (err) {
case 0:
kh_value(table, it) += 1;
if (kh_value(table, it) > maxValue)
maxValue = kh_value(table, it);
utils_free(s);
break;
case 1:
case 2:
kh_value(table, it) = 1;
break;
default:
ret = ERR_OUT_OF_MEMORY;
break;
}
++kmerCount;
if (ret != ERR_SUCCESS)
utils_free(s);
}
if (ret != ERR_SUCCESS)
break;
}
}
if (ret != ERR_SUCCESS)
break;
++r;
}
if (ret == ERR_SUCCESS) {
size_t *freqArray = NULL;
++maxValue;
ret = utils_calloc(maxValue, sizeof(size_t), &freqArray);
if (ret == ERR_SUCCESS) {
memset(freqArray, 0, maxValue*sizeof(size_t));
for (it = kh_begin(table); it != kh_end(table); ++it) {
if (kh_exist(table, it))
++freqArray[kh_value(table, it)];
}
for (size_t i = 0; i < maxValue; ++i) {
if (freqArray[i] > 0)
fprintf(stdout, "%Iu, %Iu, %lf\n", i, freqArray[i], (double)freqArray[i]*100/ (double)kmerCount);
}
utils_free(freqArray);
}
}
utils_free(kmerString);
}
for (size_t i = kh_begin(table); i < kh_end(table); ++i) {
if (kh_exist(table, i))
utils_free(kh_key(table, i));
}
kh_destroy(kc, table);
return ret;
}
static ERR_VALUE _process_variant_call(const ASSEMBLY_TASK *Task, const size_t RefSeqStart, const size_t RefSeqEnd, const char *AltSeq, const size_t AltSeqLen, const size_t RSWeight, const size_t ReadWeight, PGEN_ARRAY_VARIANT_CALL VCArray)
{
VARIANT_CALL vc;
char *altSeqStart = NULL;
size_t rsPos = Task->RegionStart + RefSeqStart + 1;
size_t rsLen = RefSeqEnd - RefSeqStart;
size_t altLen = AltSeqLen;
char *altSeq = NULL;
const char *refSeq = Task->Reference + RefSeqStart;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(altLen + 2, sizeof(char), &altSeq);
if (ret == ERR_SUCCESS) {
altSeqStart = altSeq;
memcpy(altSeq + 1, AltSeq, altLen*sizeof(char));
*altSeq = *(refSeq - 1);
++altSeq;
altSeq[altLen] = '\0';
char *opString = NULL;
size_t opStringLen = 0;
ret = ssw_clever(refSeq, rsLen, altSeq, altLen, 2, -1, -1, &opString, &opStringLen);;
if (ret == ERR_SUCCESS) {
const char *opIt = opString;
const char *tmpRS = refSeq;
const char *tmpAltS = altSeq;
size_t pos = rsPos;
boolean nothing = TRUE;
while (ret == ERR_SUCCESS) {
switch (*opIt) {
case '\0':
case 'M':
if (!nothing) {
if (altSeq == tmpAltS || refSeq == tmpRS) {
--rsPos;
--refSeq;
--altSeq;
}
ret = variant_call_init("1", rsPos, ".", refSeq, tmpRS - refSeq, altSeq, tmpAltS - altSeq, 60, &vc);
if (ret == ERR_SUCCESS) {
vc.RefWeight = RSWeight;
vc.AltWeight = ReadWeight;
ret = vc_array_add(VCArray, &vc);
if (ret == ERR_SUCCESS) {
}
if (ret != ERR_SUCCESS) {
variant_call_finit(&vc);
if (ret == ERR_ALREADY_EXISTS)
ret = ERR_SUCCESS;
}
rsPos += (tmpRS - refSeq);
refSeq = tmpRS;
altSeq = tmpAltS;
}
nothing = TRUE;
} else {
rsPos++;
refSeq++;
altSeq++;
}
++tmpRS;
++tmpAltS;
break;
case 'X':
++tmpRS;
++tmpAltS;
nothing = FALSE;
break;
case 'I':
++tmpAltS;
nothing = FALSE;
break;
case 'D':
++tmpRS;
nothing = FALSE;
break;
}
if (*opIt == '\0')
break;
++opIt;
}
utils_free(opString);
}
utils_free(altSeqStart);
}
return ret;
}
int main(int argc, char *argv[])
{
ERR_VALUE ret = ERR_INTERNAL_ERROR;
utils_allocator_init(omp_get_num_procs());
omp_init_lock(&_readCoverageLock);
#ifdef _MSC_VER
uint64_t startTime = GetTickCount64();
#endif
ret = options_module_init(37);
if (ret == ERR_SUCCESS) {
ret = _init_default_values();
if (ret == ERR_SUCCESS) {
ret = options_parse_command_line(argc - 2, argv + 2);
if (ret == ERR_SUCCESS) {
PROGRAM_OPTIONS po;
PROGRAM_STATISTICS st;
memset(&st, 0, sizeof(st));
ret = _capture_program_options(&po);
if (ret == ERR_SUCCESS) {
omp_set_num_threads(po.OMPThreads);
const char *cmd = argv[1];
if (strncmp(cmd, "help", sizeof("help")) == 0) {
options_print_help();
} else if (strncmp(cmd, "repair", sizeof("repair")) == 0) {
size_t refSeqLen = 0;
FASTA_FILE seqFile;
char *rsFasta = NULL;
ret = fasta_load(po.RefSeqFile, &seqFile);
if (ret == ERR_SUCCESS) {
ret = fasta_read_seq(&seqFile, &rsFasta, &refSeqLen);
po.ReferenceSequence = rsFasta;
if (ret != ERR_SUCCESS)
fasta_free(&seqFile);
}
if (ret == ERR_SUCCESS) {
ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_vertexLAs);
if (ret == ERR_SUCCESS)
ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_edgeLAs);
if (ret == ERR_SUCCESS) {
ret = utils_calloc(omp_get_num_procs(), sizeof(GEN_ARRAY_ONE_READ), &po.ReadSubArrays);
if (ret == ERR_SUCCESS) {
const size_t numThreads = omp_get_num_procs();
for (size_t i = 0; i < numThreads; ++i) {
dym_array_init_ONE_READ(po.ReadSubArrays + i, 140);
_vertexLAs[i] = NULL;
_edgeLAs[i] = NULL;
}
size_t regionCount = 0;
PACTIVE_REGION regions = NULL;
ret = input_refseq_to_regions(po.ReferenceSequence, refSeqLen, ®ions, ®ionCount);
if (ret == ERR_SUCCESS) {
const ACTIVE_REGION *pa = NULL;
pa = regions;
for (size_t i = 0; i < regionCount; ++i) {
if (pa->Type == artValid && pa->Length >= po.RegionLength)
_activeRegionCount += (pa->Length / po.TestStep);
++pa;
}
_activeRegionProcessed = 0;
pa = regions;
for (size_t i = 0; i < regionCount; ++i) {
if (pa->Type == artValid && pa->Length >= po.RegionLength)
repair_reads_in_parallel(pa, &po);
++pa;
}
input_free_regions(regions, regionCount);
}
PONE_READ r = po.Reads;
for (size_t i = 0; i < po.ReadCount; ++i) {
if (r->NumberOfFixes * 100 / r->ReadSequenceLen <= po.ParseOptions.ReadMaxErrorRate) {
read_quality_encode(r);
read_write_sam(stdout, r);
read_quality_decode(r);
}
++r;
}
utils_free(rsFasta);
int i = 0;
#pragma omp parallel for shared (po)
for (i = 0; i < numThreads; ++i)
dym_array_finit_ONE_READ(po.ReadSubArrays + i);
utils_free(po.ReadSubArrays);
}
}
utils_free(_edgeLAs);
utils_free(_vertexLAs);
fasta_free(&seqFile);
}
} else if (strncmp(cmd, "rfreq", sizeof("rfreq")) == 0) {
kmer_freq_distribution(&po, po.KMerSize, po.Reads, po.ReadCount);
} else if (strncmp(cmd, "call", sizeof("call")) == 0) {
fprintf(stderr, "K-mer size: %u\n", po.KMerSize);
fprintf(stderr, "Active region length: %u\n", po.RegionLength);
fprintf(stderr, "Reference: %s\n", po.RefSeqFile);
fprintf(stderr, "Reads: %u\n", po.ReadCount);
fprintf(stderr, "Read coverage threshold: %u\n", po.Threshold);
fprintf(stderr, "Min. read position quality: %u\n", po.ReadPosQuality);
fprintf(stderr, "OpenMP thread count: %i\n", po.OMPThreads);
fprintf(stderr, "Output VCF file: %s\n", po.VCFFile);
ret = paired_reads_init();
if (ret == ERR_SUCCESS) {
if (ret == ERR_SUCCESS) {
size_t refSeqLen = 0;
FASTA_FILE seqFile;
char *rsFasta = NULL;
ret = fasta_load(po.RefSeqFile, &seqFile);
if (ret == ERR_SUCCESS) {
ret = fasta_read_seq(&seqFile, &rsFasta, &refSeqLen);
po.ReferenceSequence = rsFasta;
if (ret != ERR_SUCCESS)
fasta_free(&seqFile);
}
if (ret == ERR_SUCCESS) {
po.VCFFileHandle = NULL;
if (*po.VCFFile != '\0') {
ret = utils_fopen(po.VCFFile, FOPEN_MODE_WRITE, &po.VCFFileHandle);
if (ret == ERR_SUCCESS)
dym_array_init_VARIANT_CALL(&po.VCArray, 140);
}
if (ret == ERR_SUCCESS) {
ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_vertexLAs);
if (ret == ERR_SUCCESS)
ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_edgeLAs);
ret = utils_calloc(omp_get_num_procs(), sizeof(GEN_ARRAY_VARIANT_CALL), &po.VCSubArrays);
if (ret == ERR_SUCCESS) {
ret = utils_calloc(omp_get_num_procs(), sizeof(GEN_ARRAY_ONE_READ), &po.ReadSubArrays);
if (ret == ERR_SUCCESS) {
const size_t numThreads = omp_get_num_procs();
for (size_t i = 0; i < numThreads; ++i) {
dym_array_init_VARIANT_CALL(po.VCSubArrays + i, 140);
dym_array_init_ONE_READ(po.ReadSubArrays + i, 140);
_vertexLAs[i] = NULL;
_edgeLAs[i] = NULL;
}
size_t regionCount = 0;
PACTIVE_REGION regions = NULL;
ret = input_refseq_to_regions(po.ReferenceSequence, refSeqLen, ®ions, ®ionCount);
if (ret == ERR_SUCCESS) {
const ACTIVE_REGION *pa = NULL;
pa = regions;
for (size_t i = 0; i < regionCount; ++i) {
if (pa->Type == artValid && pa->Length >= po.RegionLength)
_activeRegionCount += (pa->Length / po.TestStep);
++pa;
}
_activeRegionProcessed = 0;
pa = regions;
for (size_t i = 0; i < regionCount; ++i) {
if (pa->Type == artValid && pa->Length >= po.RegionLength)
process_active_region_in_parallel(pa, &po);
++pa;
}
input_free_regions(regions, regionCount);
}
utils_free(rsFasta);
ret = vc_array_merge(&po.VCArray, po.VCSubArrays, numThreads);
int i = 0;
#pragma omp parallel for shared(po)
for (i = 0; i <(int) numThreads; ++i) {
dym_array_finit_ONE_READ(po.ReadSubArrays + i);
vc_array_finit(po.VCSubArrays + i);
}
utils_free(po.ReadSubArrays);
}
utils_free(po.VCSubArrays);
}
utils_free(_edgeLAs);
utils_free(_vertexLAs);
if (po.VCFFileHandle != NULL) {
if (ret == ERR_SUCCESS)
vc_array_print(po.VCFFileHandle, &po.VCArray);
vc_array_finit(&po.VCArray);
utils_fclose(po.VCFFileHandle);
}
}
fasta_free(&seqFile);
}
} else printf("fix_reads(): %u\n", ret);
printf("Read coverage: %lf\n", _readBaseCount / _totalRegionLength );
paired_reads_finit();
}
}
}
}
}
options_module_finit();
}
#ifdef _MSC_VER
uint64_t endTime = GetTickCount64();
fprintf(stderr, "Time: %I64u s\n", (endTime - startTime) / 1000);
#endif
omp_destroy_lock(&_readCoverageLock);
return ret;
}
int main(int argc, char **argv)
{
fml_opt_t options;
bseq1_t *seqs = NULL;
PONE_READ reads = NULL;
size_t readCount = 0;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
fml_opt_init(&options);
options.n_threads = omp_get_num_procs();
options.ec_k = 31;
utils_allocator_init(options.n_threads);
fprintf(stderr, "Loading reads from %s...\n", argv[1]);
ret = input_get_reads(argv[1], "sam", &reads, &readCount);
if (ret == ERR_SUCCESS) {
fprintf(stderr, "Converting to fermi-lite format...\n");
ret = utils_calloc(readCount, sizeof(bseq1_t), &seqs);
if (ret == ERR_SUCCESS) {
for (size_t i = 0; i < readCount; ++i) {
memset(seqs + i, 0, sizeof(seqs[i]));
seqs[i].l_seq = reads[i].ReadSequenceLen;
read_quality_encode(reads + i);
seqs[i].seq = _copy_string(reads[i].ReadSequence, reads[i].ReadSequenceLen);
if (reads[i].Quality != NULL)
seqs[i].qual = _copy_string(reads[i].Quality, reads[i].QualityLen);
read_quality_decode(reads + i);
}
fml_opt_adjust(&options, readCount, seqs);
fprintf(stderr, "Correcting...\n");
fml_correct(&options, readCount, seqs);
fprintf(stderr, "Fitting unique k-mers...\n");
fml_fltuniq(&options, readCount, seqs);
fprintf(stderr, "Converting back to our format...\n");
for (size_t i = 0; i < readCount; ++i) {
if (reads[i].ReadSequenceLen != seqs[i].l_seq) {
utils_copy_string("*", &reads[i].CIGAR);
reads[i].CIGARLen = 1;
}
reads[i].ReadSequenceLen = seqs[i].l_seq;
reads[i].QualityLen = seqs[i].l_seq;
ret = utils_copy_string(seqs[i].seq, &reads[i].ReadSequence);
if (ret == ERR_SUCCESS)
ret = utils_copy_string(seqs[i].qual, &reads[i].Quality);
for (size_t j = 0; j < reads[i].ReadSequenceLen; ++j)
reads[i].ReadSequence[j] = toupper(reads[i].ReadSequence[j]);
if (reads[i].ReadSequenceLen > 0 && reads[i].QualityLen > 0)
read_write_sam(stdout, reads + i);
read_quality_decode(reads + i);
}
fprintf(stderr, "Freeing fermi-lite resources...\n");
utils_free(seqs);
}
fprintf(stderr, "Freeing our reads...\n");
read_set_destroy(reads, readCount);
}
return 0;
}
