import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
@Test
public void testGetProgramRecord() {
    final ReadToolsProgram program = new TestProgram();
    final String programName = "ReadTools TestProgram";

    // test the program record for an empty header
    final SAMFileHeader header = new SAMFileHeader();
    SAMProgramRecord pg0 = program.getProgramRecord(header);
    Assert.assertEquals(pg0.getId(), programName);
    Assert.assertEquals(pg0.getProgramName(), programName);

    // test adding more program records
    for (int i = 1; i < 5; i++) {
        header.addProgramRecord(pg0);
        pg0 = program.getProgramRecord(header);
        Assert.assertEquals(pg0.getId(), programName + "." + i);
        Assert.assertEquals(pg0.getProgramName(), programName);
    }
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
@DataProvider(name = "outputWriterProvider")
public Object[][] getOutputWriterData() {
    final File testDir = createTestTempDir(this.getClass().getSimpleName());
    final SAMProgramRecord record = new SAMProgramRecord("test");
    record.setCommandLine("command line");
    return new Object[][] {
            // TODO: test cram
            // {new File(testDir, "example.empty.cram"), null},
            // {new File(testDir, "example.cram"), record},
            // test bam
            {new File(testDir, "example.empty.bam"), null, false},
            {new File(testDir, "example.empty2.bam"), null, true},
            {new File(testDir, "example.bam"), record, false},
            {new File(testDir, "example2.bam"), record, true},
            // test sam
            {new File(testDir, "example.empty.sam"), null, false},
            {new File(testDir, "example.empty2.sam"), null, true},
            {new File(testDir, "example.sam"), record, false},
            {new File(testDir, "example2.sam"), record, true},
    };
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
@Test(dataProvider = "outputWriterProvider")
public void testWritingHeader(final File outputFile, final SAMProgramRecord record,
        final boolean addProgramGroup) throws Exception {
    Assert.assertFalse(outputFile.exists(),
            "broken test: test output file exists " + outputFile);
    final RTOutputBamArgumentCollection args = new RTOutputBamArgumentCollection();
    args.outputName = outputFile.getAbsolutePath();
    args.addOutputSAMProgramRecord = addProgramGroup;
    final GATKReadWriter writer =
            args.outputWriter(new SAMFileHeader(), (record == null) ? null : () -> record, true,
                    null
            );
    writer.close();
    Assert.assertTrue(outputFile.exists(), "not output written");
    final SAMFileHeader writtenHeader =
            SamReaderFactory.makeDefault().getFileHeader(outputFile);
    final SAMFileHeader expectedHeader = new SAMFileHeader();
    expectedHeader.setSortOrder(SAMFileHeader.SortOrder.unsorted);
    if (addProgramGroup && record != null) {
        expectedHeader.addProgramRecord(record);
    }
    Assert.assertEquals(writtenHeader, expectedHeader);
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
private boolean compareProgramRecord(final SAMProgramRecord programRecord1, final SAMProgramRecord programRecord2) {
    if (programRecord1 == null && programRecord2 == null) {
        return true;
    }
    if (programRecord1 == null) {
        reportDifference("null", programRecord2.getProgramGroupId(), "Program Record");
        return false;
    }
    if (programRecord2 == null) {
        reportDifference(programRecord1.getProgramGroupId(), "null", "Program Record");
        return false;
    }
    boolean ret = compareValues(programRecord1.getProgramGroupId(), programRecord2.getProgramGroupId(),
            "Program Name");
    final String[] attributes = {"VN", "CL"};
    for (final String attribute : attributes) {
        ret = compareValues(programRecord1.getAttribute(attribute), programRecord2.getAttribute(attribute),
                attribute + " Program Record attribute") && ret;
    }
    return ret;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
private boolean compareProgramRecords(final SAMFileHeader h1, final SAMFileHeader h2) throws Exception {
  final List<SAMProgramRecord> l1 = h1.getProgramRecords();
  final List<SAMProgramRecord> l2 = h2.getProgramRecords();
  if (!compareValues(l1.size(), l2.size(), "Number of program records")) {
      return false;
  }
  boolean ret = true;
  for (SAMProgramRecord pr1 : l1) {
    for (SAMProgramRecord pr2 : l2) {
      if (pr1.getId().equals(pr2.getId())) {
        ret = compareProgramRecord(pr1, pr2) && ret;
      }
    }
  }

  return ret;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
private boolean compareProgramRecord(final SAMProgramRecord programRecord1, final SAMProgramRecord programRecord2) throws Exception {
  if (programRecord1 == null && programRecord2 == null) {
      return true;
  }
  if (programRecord1 == null) {
      reportDifference("null", programRecord2.getProgramGroupId(), "Program Record");
      return false;
  }
  if (programRecord2 == null) {
      reportDifference(programRecord1.getProgramGroupId(), "null", "Program Record");
      return false;
  }
  boolean ret = compareValues(programRecord1.getProgramGroupId(), programRecord2.getProgramGroupId(),
          "Program Name");
  final String[] attributes = {"VN", "CL"};
  for (final String attribute : attributes) {
      ret = compareValues(programRecord1.getAttribute(attribute), programRecord2.getAttribute(attribute),
              attribute + " Program Record attribute") && ret;
  }
  return ret;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
/**
 * Create a new HaplotypeBAMDestination
 *
 * @param sourceHeader SAMFileHeader used to seed the output SAMFileHeader for this destination.
 * @param haplotypeReadGroupID read group ID used when writing haplotypes as reads
 */
protected HaplotypeBAMDestination(SAMFileHeader sourceHeader, final String haplotypeReadGroupID) {
    Utils.nonNull(sourceHeader, "sourceHeader cannot be null");
    Utils.nonNull(haplotypeReadGroupID, "haplotypeReadGroupID cannot be null");
    this.haplotypeReadGroupID = haplotypeReadGroupID;

    bamOutputHeader = new SAMFileHeader();
    bamOutputHeader.setSequenceDictionary(sourceHeader.getSequenceDictionary());
    bamOutputHeader.setSortOrder(SAMFileHeader.SortOrder.coordinate);

    final List<SAMReadGroupRecord> readGroups = new ArrayList<>();
    readGroups.addAll(sourceHeader.getReadGroups()); // include the original read groups

    // plus an artificial read group for the haplotypes
    final SAMReadGroupRecord rgRec = new SAMReadGroupRecord(getHaplotypeReadGroupID());
    rgRec.setSample(haplotypeSampleTag);
    rgRec.setSequencingCenter("BI");
    readGroups.add(rgRec);
    bamOutputHeader.setReadGroups(readGroups);

    bamOutputHeader.addProgramRecord(new SAMProgramRecord("HalpotypeBAMWriter"));
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
private static SAMFileHeader mergeHeaders(List<RecordSource> sources) {
	SAMFileHeader header = new SAMFileHeader();
	for (RecordSource source : sources) {
		SAMFileHeader h = source.reader.getFileHeader();

		for (SAMSequenceRecord seq : h.getSequenceDictionary().getSequences()) {
			if (header.getSequenceDictionary().getSequence(seq.getSequenceName()) == null)
				header.addSequence(seq);
		}

		for (SAMProgramRecord pro : h.getProgramRecords()) {
			if (header.getProgramRecord(pro.getProgramGroupId()) == null)
				header.addProgramRecord(pro);
		}

		for (String comment : h.getComments())
			header.addComment(comment);

		for (SAMReadGroupRecord rg : h.getReadGroups()) {
			if (header.getReadGroup(rg.getReadGroupId()) == null)
				header.addReadGroup(rg);
		}
	}

	return header;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
private void fillHeader(XMLEventReader r,SAMProgramRecord prog) throws XMLStreamException,JAXBException
{
while(r.hasNext())
	{
	XMLEvent evt=r.peek();

	if(!(evt.isStartElement()))
		{
		r.next();
		continue;
		}
	StartElement E=evt.asStartElement();
	String name=E.getName().getLocalPart();
	if(name.equals("BlastOutput_iterations")) break;
	r.next();
	if(name.equals("BlastOutput_program"))
		{
		prog.setProgramName(r.getElementText());
		}
	else if(name.equals("BlastOutput_version"))
		{
		prog.setProgramVersion(r.getElementText().replace(' ', '_'));
		}
	}
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
private Tab createProgramRecordPane(final SAMFileHeader header)
{
final TableView<SAMProgramRecord> table=new TableView<>(header==null?
		FXCollections.observableArrayList():
		FXCollections.observableArrayList(header.getProgramRecords())
		);
table.getColumns().add(makeColumn("ID", G->G.getId()));
table.getColumns().add(makeColumn("PG-ID", G->G.getProgramGroupId()));
table.getColumns().add(makeColumn("Prev-PG-ID", G->G.getPreviousProgramGroupId()));
table.getColumns().add(makeColumn("Version", G->G.getProgramVersion()));
table.getColumns().add(makeColumn("Command", G->G.getCommandLine()));
   
final Tab tab=new Tab("PG", table);
tab.setClosable(false);
table.setPlaceholder(new Label("No Program-Group."));
return tab;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
/**
 * Creates a program record for the program, adds it to the list of program records (@PG tags) in the bam file and sets
 * up the writer with the header and presorted status.
 *
 * @param originalHeader      original header
 * @param programRecord       the program record for this program
 */
public static SAMFileHeader setupWriter(final SAMFileHeader originalHeader, final SAMProgramRecord programRecord) {
    final SAMFileHeader header = originalHeader.clone();
    final List<SAMProgramRecord> oldRecords = header.getProgramRecords();
    final List<SAMProgramRecord> newRecords = new ArrayList<SAMProgramRecord>(oldRecords.size()+1);
    for ( SAMProgramRecord record : oldRecords )
        if ( (programRecord != null && !record.getId().startsWith(programRecord.getId())))
            newRecords.add(record);

    if (programRecord != null) {
        newRecords.add(programRecord);
        header.setProgramRecords(newRecords);
    }
    return header;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
/**
 * Returns the program group ID that will be used in the SAM writer.
 * Starts with {@link #getToolName} and looks for the first available ID by appending
 * consecutive integers.
 */
private final String createProgramGroupID(final SAMFileHeader header) {
    final String toolName = getToolName();

    String pgID = toolName;
    SAMProgramRecord record = header.getProgramRecord(pgID);
    int count = 1;
    while (record != null) {
        pgID = toolName + "." + String.valueOf(count++);
        record = header.getProgramRecord(pgID);
    }
    return pgID;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
/**
 * Updates the header with the program record if {@link #addOutputSAMProgramRecord} is
 * {@code true} and the supplier is not {@code null}.
 */
@Override
protected final void updateHeader(final SAMFileHeader header,
        final Supplier<SAMProgramRecord> programRecord) {
    if (addOutputSAMProgramRecord && programRecord != null) {
        header.addProgramRecord(programRecord.get());
    }
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
public static SAMProgramRecord buildSAMProgramRecord(String prog, List<SAMProgramRecord> records) {
    String pgTemplate = "ngsutilsj:" + prog + "-";
    String pgID = pgTemplate;
    boolean found = true;
    int i = 0;
    
    SAMProgramRecord mostRecent = null;
    
    while (found) {
        found = false;
        i++;
        pgID = pgTemplate + i;
        if (records!=null) {
            for (SAMProgramRecord record: records) {
                if (mostRecent == null && (record.getPreviousProgramGroupId() == null || record.getPreviousProgramGroupId().equals(""))) {
                   mostRecent = record;
                }
                
                if (record.getId().equals(pgID)) {
                    found = true;
                }
            }
        }
    }

    SAMProgramRecord programRecord = new SAMProgramRecord(pgID);
    programRecord.setProgramName("ngsutilsj:"+prog);
    programRecord.setProgramVersion(NGSUtils.getVersion());
    programRecord.setCommandLine("ngsutilsj " + NGSUtils.getArgs());
    if (mostRecent!=null) {
        programRecord.setPreviousProgramGroupId(mostRecent.getId());
    }
    return programRecord;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
public static SAMProgramRecord suffixAddSAMProgramRecord(SAMProgramRecord existing, String suffix) {
    SAMProgramRecord pg = new SAMProgramRecord(existing.getId()+suffix);
    for (Entry<String, String> k: existing.getAttributes()) {
        if (k.getKey().equals(SAMProgramRecord.PREVIOUS_PROGRAM_GROUP_ID_TAG)) {
            pg.setAttribute(k.getKey(), k.getValue()+suffix);
        } else {
            pg.setAttribute(k.getKey(), k.getValue());
        }
    }
    return pg;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
private boolean compareProgramRecords(final SAMFileHeader h1, final SAMFileHeader h2) {
    final List<SAMProgramRecord> l1 = h1.getProgramRecords();
    final List<SAMProgramRecord> l2 = h2.getProgramRecords();
    if (!compareValues(l1.size(), l2.size(), "Number of program records")) {
        return false;
    }
    boolean ret = true;
    for (int i = 0; i < l1.size(); ++i) {
        ret = compareProgramRecord(l1.get(i), l2.get(i)) && ret;
    }
    return ret;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
/**
 * We have to re-chain the program groups based on this algorithm.  This returns the map from existing program group ID
 * to new program group ID.
 */
protected Map<String, String> getChainedPgIds(final SAMFileHeader outputHeader) {
    final Map<String, String> chainedPgIds;
    // Generate new PG record(s)
    if (PROGRAM_RECORD_ID != null) {
        final SAMFileHeader.PgIdGenerator pgIdGenerator = new SAMFileHeader.PgIdGenerator(outputHeader);
        if (PROGRAM_GROUP_VERSION == null) {
            PROGRAM_GROUP_VERSION = this.getVersion();
        }
        if (PROGRAM_GROUP_COMMAND_LINE == null) {
            PROGRAM_GROUP_COMMAND_LINE = this.getCommandLine();
        }
        chainedPgIds = new HashMap<>();
        for (final String existingId : this.pgIdsSeen) {
            final String newPgId = pgIdGenerator.getNonCollidingId(PROGRAM_RECORD_ID);
            chainedPgIds.put(existingId, newPgId);
            final SAMProgramRecord programRecord = new SAMProgramRecord(newPgId);
            programRecord.setProgramVersion(PROGRAM_GROUP_VERSION);
            programRecord.setCommandLine(PROGRAM_GROUP_COMMAND_LINE);
            programRecord.setProgramName(PROGRAM_GROUP_NAME);
            programRecord.setPreviousProgramGroupId(existingId);
            outputHeader.addProgramRecord(programRecord);
        }
    } else {
        chainedPgIds = null;
    }
    return chainedPgIds;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
/**
 * Returns the SAM header suitable for writing SAM/BAM/CRAM files produced by this tool.
 *
 * The default implementation calls {@link #getHeaderForReads} (and makes an empty header if that call returns null)
 * and optionally adds program tag to the header with a program version {@link #getVersion()}, program name {@link #getToolName()}
 * and command line {@link #getCommandLine()}.
 *
 * Subclasses may override.
 *
 * @return SAM header for the SAM writer with (optionally, if {@link #addOutputSAMProgramRecord} is true) program record appropriately.
 */
protected SAMFileHeader getHeaderForSAMWriter(){
    final SAMFileHeader header = getHeaderForReads() == null ? new SAMFileHeader(): getHeaderForReads();
    if (addOutputSAMProgramRecord) {
        final SAMProgramRecord programRecord = new SAMProgramRecord(createProgramGroupID(header));
        programRecord.setProgramVersion(getVersion());
        programRecord.setCommandLine(getCommandLine());
        programRecord.setProgramName(getToolName());
        header.addProgramRecord(programRecord);
    }
    return header;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
/**
 * Returns the program group ID that will be used in the SAM writer.
 * Starts with {@link #getToolName} and looks for the first available ID by appending consecutive integers.
 */
private String createProgramGroupID(final SAMFileHeader header) {
    final String toolName = getToolName();

    String pgID = toolName;
    SAMProgramRecord record = header.getProgramRecord(pgID);
    int count = 1;
    while (record != null){
        pgID = toolName + "." + String.valueOf(count++);
        record = header.getProgramRecord(pgID);
    }
    return pgID;
}
 

import htsjdk.samtools.SAMProgramRecord; //导入依赖的package包/类
public void reAlign(String[] inputFiles, String[] outputFiles) throws Exception {
	
	this.inputSams = inputFiles;
	
	logStartupInfo(outputFiles);
			
	String tempDir = init();
	
	c2r = new CompareToReference2();
	c2r.init(this.reference);
	
	chromosomeChunker = new ChromosomeChunker(c2r);
	chromosomeChunker.init();

	Logger.info("Reading Input SAM Header and identifying read length");
	getSamHeaderAndReadLength();
	
	Logger.info("Read length: " + readLength);
	
	Logger.info("Loading target regions");
	loadRegions();
	loadJunctions();
	
	Clock clock = new Clock("Realignment");
	clock.start();
	
	if (contigFile != null) {
		contigWriter = new BufferedWriter(new FileWriter(contigFile, false));
	}
			
	for (int i=0; i<inputSams.length; i++) {
		
		SAMProgramRecord pg = new SAMProgramRecord("ABRA2");
		pg.setProgramVersion(this.version);
		pg.setCommandLine(cl);
		samHeaders[i].addProgramRecord(pg);			
	}
	
	writer = new SortedSAMWriter(outputFiles, tempDir.toString(), samHeaders, isKeepTmp, chromosomeChunker,
			finalCompressionLevel, shouldSort, maxRealignDist, shouldUnsetDuplicates, shouldCreateIndex, shouldUseGkl, maxReadsInRamForSort);

	// Spawn thread for each chromosome
	// TODO: Validate identical sequence dictionary for each input file
	
	for (int i=0; i<this.chromosomeChunker.getChunks().size(); i++) {
		spawnChromosomeThread(i);
	}
	
	Logger.info("Waiting for processing threads to complete");
	threadManager.waitForAllThreadsToComplete();
	
	if (contigWriter != null) {
		contigWriter.close();
	}
	
	clock.stopAndPrint();
	
	clock = new Clock("Sort and cleanup");
	clock.start();
	
	// Cut num threads in half to allow for async writer thread
	threadManager = new ThreadManager(Math.max(numThreads / 2, 1));
	
	for (int i=0; i<outputFiles.length; i++) {
		SortedSAMWriterRunnable thread = new SortedSAMWriterRunnable(threadManager, writer, i, inputSams[i]);
		threadManager.spawnThread(thread);
	}
	
	Logger.info("Waiting for writer threads to complete");
	threadManager.waitForAllThreadsToComplete();
	
	clock.stopAndPrint();
	
	Logger.info("Done.");
}