Map2SamConverter.hpp

Go to the documentation of this file.

// Copyright 2010 Complete Genomics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you
// may not use this file except in compliance with the License. You
// may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the License.

#ifndef CGA_TOOLS_COMMAND_MAP2SAM_CONVERTER_HPP_
#define CGA_TOOLS_COMMAND_MAP2SAM_CONVERTER_HPP_ 1


#include "cgatools/core.hpp"
#include "cgatools/util/RangeSet.hpp"
#include "cgatools/reference/CrrFile.hpp"
#include "MapSamUtils.hpp"

#include <boost/array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <string>
#include <map>

namespace cgatools { namespace mapping {

    class Map2SamConfig {
    public:
        Map2SamConfig() 
            :recordsFrom_(0)
            ,recordsTo_(std::numeric_limits<size_t>::max())
            ,skipNotMapped_(false)
            ,addMateSequenceAndScore_(false)
            ,addUnmappedMateInfo_(false)
            ,mateSvCandidates_(false)
            ,dumpDebugInfo_(true)
        {}

        size_t  recordsFrom_;
        size_t  recordsTo_;
        bool    skipNotMapped_;
        bool    addMateSequenceAndScore_;
        bool    addUnmappedMateInfo_;
        bool    mateSvCandidates_;
        bool    dumpDebugInfo_;

        util::StringVector exportRegions_;

        std::string exportRootDirName_;
        std::string inputReadsBatchId_;
        std::string inputReadsFileName_;
        std::string inputMappingsFileName_;
        std::string referenceFileName_;
        std::string outputFileName_;

        std::string commandLine_;
    };

    class SamStatistics {
        friend std::ostream& operator<< (std::ostream& out, const SamStatistics& r);
    public:
        enum {
            IND_SINGLE_BEST_MATES = 0, // primary mappings
            IND_MULTIPLE_BEST_MATES, // don't qualify for primary
            IND_ONLY_ZERO_WEIGHT_BEST_MATES,
            IND_ONE_ARM_BEST_MAPPINGS_NO_MATES,
            IND_ONE_ARM_ONLY_MAPPED_HAS_BEST,
            IND_ONE_ARM_ONLY_MAPPED,
            IND_READ_NOT_MAPPED,
            IND_PAIRED_SINGLE_ARM_MAPPINGS,
            IND_EVIDENCE_MAPPINGS_FOUND,
            IND_EVIDENCE_MAPPINGS_LOADED,
            IND_DUPLICATE_MAPPINGS_FILTERED,
            IND_TOTAL_VALUES
        };
        SamStatistics() {
            counters_.assign(0);
        }

        typedef boost::array<size_t, IND_TOTAL_VALUES> SamStatCounters;
        SamStatCounters counters_;
    };

    class LibraryData;

    class Map2SamConverter {
    public:
        static const char SAM_SEPARATOR = '\t';
        typedef boost::shared_ptr<std::istream> InStream;
        typedef boost::ptr_vector<SamRecord> SamRecordArray;

        Map2SamConverter(const Map2SamConfig &config, std::ostream &outSamFile);
        virtual ~Map2SamConverter() {}

        virtual void init();
        void run();

    protected:
        SamFileHeaderBlock createHeader();

        //Prefilter mapping records
        virtual void filterMappingRecords(SamRecordArray& records) {}

        //Export mapping record in SAM format
        virtual void writeMappingRecord(const SamRecord &m);

        void processDnbRecord(const ReadsRecord& readsRecord, 
            const mapping::MappingsRecords& mappingsRecords);

        virtual bool alternativeMappingProcessing(
            const mapping::ReadsRecord& readsRecord, SamRecordArray& records) {
                return false;
        }

        reference::Range getMappingRange(const SamRecord &mapping);

        size_t detectPrimaryMapping(MappingsRecords &mappingsRecords, bool oneArmOnly);

        size_t getChunkNumber(const std::string &fileName, size_t formatVersion);

        size_t batchNumber_;
        size_t formatVersion_;
        std::string slide_;
        std::string lane_;
        std::string laneId_;

        InStream readsFileStream_;
        InStream mappingsFileStream_;

        boost::shared_ptr<util::DelimitedFile> readsFile_;
        boost::shared_ptr<util::DelimitedFile> mappingsFile_;

        boost::shared_ptr<LibraryData>              library_;

        reference::CrrFile      reference_;

        std::ostream &          outSamFile_;

        mutable SamStatistics   statistics_;
        const Map2SamConfig &   config_;

        boost::scoped_ptr<util::FastRangeSet>           exportRegions_;
        boost::scoped_ptr<mapping::SamRecordGenerator>  mappingSamRecordGenerator_;
    };


} } // cgatools::mapping

#endif // CGA_TOOLS_COMMAND_MAP2SAM_CONVERTER_HPP_

---