Better func names. (5060f2d4) · Commits · github_fork / Chromap

src/chromap.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -29,7 +29,7 @@
		#include "temp_mapping.h"
		#include "utils.h"

		#define CHROMAP_VERSION "0.2.3-r449"
		#define CHROMAP_VERSION "0.2.3-r450"

		namespace chromap {

src/hit_utils.h

0 → 100644

+27 −0

Original line number	Diff line number	Diff line
		#ifndef HIT_UTILS_H_
		#define HIT_UTILS_H_

		#include "strand.h"

		namespace chromap {

		inline static uint32_t HitToSequenceIndex(uint64_t hit) { return (hit >> 33); }

		inline static uint32_t HitToSequencePosition(uint64_t hit) {
		return (hit >> 1);
		}

		inline static Strand HitToStrand(uint64_t hit) {
		if ((hit & 1) == 0) {
		return kPositive;
		}
		return kNegative;
		}

		inline static bool AreTwoHitsOnTheSameStrand(uint64_t hit1, uint64_t hit2) {
		return ((hit1 & 1) == (hit2 & 1));
		}

		} // namespace chromap

		#endif // HIT_UTILS_H_

src/index.cc

+24 −25

Original line number	Diff line number	Diff line
		@@ -290,7 +290,7 @@ int Index::GenerateCandidatePositions(
		const uint32_t num_occurrences =
		GenerateNumOccurrenceInOccurrenceTable(lookup_value);
		if (!generating_config.IsFrequentSeed(num_occurrences)) {
		const uint32_t read_position = GenerateSequencePosition(read_seed_hit);
		const uint32_t read_position = HitToSequencePosition(read_seed_hit);
		const uint32_t occ_offset = GenerateOffsetInOccurrenceTable(lookup_value);
		for (uint32_t oi = 0; oi < num_occurrences; ++oi) {
		const uint64_t reference_seed_hit = occurrence_table_[occ_offset + oi];
		@@ -298,7 +298,7 @@ int Index::GenerateCandidatePositions(
		reference_seed_hit, read_seed_hit);
		if (AreTwoHitsOnTheSameStrand(reference_seed_hit, read_seed_hit)) {
		const uint32_t reference_position =
		GenerateSequencePosition(reference_seed_hit);
		HitToSequencePosition(reference_seed_hit);
		if (reference_position < read_position) {
		is_candidate_position_list_sorted = false;
		}
		@@ -310,7 +310,7 @@ int Index::GenerateCandidatePositions(
		}

		if (generating_config.IsRepetitiveSeed(num_occurrences)) {
		const uint32_t read_position = GenerateSequencePosition(read_seed_hit);
		const uint32_t read_position = HitToSequencePosition(read_seed_hit);
		UpdateRepetitiveSeedStats(read_position, repetitive_seed_stats);
		}
		}
		@@ -434,32 +434,31 @@ int Index::GenerateCandidatePositionsFromRepetitiveReadWithMateInfoOnOneStrand(
		const uint64_t reference_seed_hit = kh_value(lookup_table_, khash_iterator);

		const uint64_t read_seed_hit = minimizers[mi].GetHit();
		const uint32_t read_position = GenerateSequencePosition(read_seed_hit);
		const Strand read_strand = GenerateSequenceStrand(read_seed_hit);
		const uint32_t read_position = HitToSequencePosition(read_seed_hit);
		const Strand read_strand = HitToStrand(read_seed_hit);

		const bool is_reference_minimizer_single =
		(kh_key(lookup_table_, khash_iterator) & 1) > 0;

		if (is_reference_minimizer_single) {
		const uint64_t reference_id = GenerateSequenceIndex(reference_seed_hit);
		const uint64_t reference_id = HitToSequenceIndex(reference_seed_hit);
		const uint32_t reference_position =
		GenerateSequencePosition(reference_seed_hit);
		const Strand reference_strand =
		GenerateSequenceStrand(reference_seed_hit);
		HitToSequencePosition(reference_seed_hit);
		const Strand reference_strand = HitToStrand(reference_seed_hit);

		if (read_strand == reference_strand) {
		if (strand == kPositive) {
		const uint32_t candidate_position =
		reference_position - read_position;
		const uint64_t seed_hit =
		GenerateCandidatePosition(reference_id, candidate_position);
		const uint64_t seed_hit = SequenceIndexAndPositionToCandidatePosition(
		reference_id, candidate_position);
		hits.push_back(seed_hit);
		}
		} else if (strand == kNegative) {
		const uint32_t candidate_position =
		reference_position + read_position - kmer_size_ + 1;
		const uint64_t seed_hit =
		GenerateCandidatePosition(reference_id, candidate_position);
		const uint64_t seed_hit = SequenceIndexAndPositionToCandidatePosition(
		reference_id, candidate_position);
		hits.push_back(seed_hit);
		}

		@@ -499,25 +498,25 @@ int Index::GenerateCandidatePositionsFromRepetitiveReadWithMateInfoOnOneStrand(
		break;
		}

		const uint64_t reference_id = GenerateSequenceIndex(reference_seed_hit);
		const uint64_t reference_id = HitToSequenceIndex(reference_seed_hit);
		const uint32_t reference_position =
		GenerateSequencePosition(reference_seed_hit);
		const Strand reference_strand =
		GenerateSequenceStrand(reference_seed_hit);
		HitToSequencePosition(reference_seed_hit);
		const Strand reference_strand = HitToStrand(reference_seed_hit);

		if (read_strand == reference_strand) {
		if (strand == kPositive) {
		const uint32_t candidate_position =
		reference_position - read_position;
		const uint64_t seed_hit =
		GenerateCandidatePosition(reference_id, candidate_position);
		SequenceIndexAndPositionToCandidatePosition(reference_id,
		candidate_position);
		hits.push_back(seed_hit);
		}
		} else if (strand == kNegative) {
		const uint32_t candidate_position =
		reference_position + read_position - kmer_size_ + 1;
		const uint64_t seed_hit =
		GenerateCandidatePosition(reference_id, candidate_position);
		const uint64_t seed_hit = SequenceIndexAndPositionToCandidatePosition(
		reference_id, candidate_position);
		hits.push_back(seed_hit);
		}
		}
		@@ -554,9 +553,8 @@ int Index::GenerateCandidatePositionsFromRepetitiveReadWithMateInfoOnOneStrand(

		uint64_t Index::GenerateCandidatePositionFromHits(
		uint64_t reference_seed_hit, uint64_t read_seed_hit) const {
		const uint32_t reference_position =
		GenerateSequencePosition(reference_seed_hit);
		const uint32_t read_position = GenerateSequencePosition(read_seed_hit);
		const uint32_t reference_position = HitToSequencePosition(reference_seed_hit);
		const uint32_t read_position = HitToSequencePosition(read_seed_hit);
		// For now we can't see the reference here. So let us don't validate this
		// candidate position. Instead, we do it later some time when we check the
		// candidates.
		@@ -564,9 +562,10 @@ uint64_t Index::GenerateCandidatePositionFromHits(
		AreTwoHitsOnTheSameStrand(reference_seed_hit, read_seed_hit)
		? reference_position - read_position
		: reference_position + read_position - kmer_size_ + 1;
		const uint64_t reference_id = GenerateSequenceIndex(reference_seed_hit);
		const uint64_t reference_id = HitToSequenceIndex(reference_seed_hit);
		const uint64_t candidate_position =
		GenerateCandidatePosition(reference_id, mapping_start_position);
		SequenceIndexAndPositionToCandidatePosition(reference_id,
		mapping_start_position);
		return candidate_position;
		}

src/index_utils.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -41,8 +41,8 @@ inline static uint32_t GenerateNumOccurrenceInOccurrenceTable(
		return static_cast<uint32_t>(lookup_table_entry_value);
		}

		inline static uint64_t GenerateCandidatePosition(uint64_t sequence_id,
		uint32_t sequence_position) {
		inline static uint64_t SequenceIndexAndPositionToCandidatePosition(
		uint64_t sequence_id, uint32_t sequence_position) {
		return (sequence_id << 32) \| sequence_position;
		}

src/minimizer.h

+4 −8

Original line number	Diff line number	Diff line
		@@ -3,7 +3,7 @@

		#include <utility>

		#include "minimizer_utils.h"
		#include "hit_utils.h"
		#include "strand.h"

		namespace chromap {
		@@ -23,17 +23,13 @@ class Minimizer {

		inline uint64_t GetHit() const { return hit_; }

		inline uint32_t GetSequenceIndex() const {
		return GenerateSequenceIndex(hit_);
		}
		inline uint32_t GetSequenceIndex() const { return HitToSequenceIndex(hit_); }

		inline uint32_t GetSequencePosition() const {
		return GenerateSequencePosition(hit_);
		return HitToSequencePosition(hit_);
		}

		inline Strand GetSequenceStrand() const {
		return GenerateSequenceStrand(hit_);
		}
		inline Strand GetSequenceStrand() const { return HitToStrand(hit_); }

		inline bool operator<(const Minimizer &m) const {
		if (hash_ < m.hash_) {

Admin message