/*****************************************************************************
# Copyright (C) 1994-2008 by David Gordon.
# All rights reserved.
#
# This software is part of a beta-test version of the Consed/Autofinish
# package. It should not be redistributed or
# used for any commercial purpose, including commercially funded
# sequencing, without written permission from the author and the
# University of Washington.
#
# This software is provided ``AS IS'' and any express or implied
# warranties, including, but not limited to, the implied warranties of
# merchantability and fitness for a particular purpose, are disclaimed.
# In no event shall the authors or the University of Washington be
# liable for any direct, indirect, incidental, special, exemplary, or
# consequential damages (including, but not limited to, procurement of
# substitute goods or services; loss of use, data, or profits; or
# business interruption) however caused and on any theory of liability,
# whether in contract, strict liability, or tort (including negligence
# or otherwise) arising in any way out of the use of this software, even
# if advised of the possibility of such damage.
#
# Building Consed from source is error prone and not simple which is
# why I provide executables. Due to time limitations I cannot
# provide any assistance in building Consed. Even if you do not
# modify the source, you may introduce errors due to using a
# different version of the compiler, a different version of motif,
# different versions of other libraries than I used, etc. For this
# reason, if you discover Consed bugs, I can only offer help with
# those bugs if you first reproduce those bugs with an executable
# provided by me--not an executable you have built.
#
# Modifying Consed is also difficult. Although Consed is modular,
# some modules are used by many other modules. Thus making a change
# in one place can have unforeseen effects on many other features.
# It may takes months for you to notice these other side-effects
# which may not seen connected at all. It is not feasable for me to
# provide help with modifying Consed sources because of the
# potentially huge amount of time involved.
#
#*****************************************************************************/
#include "consedParameters.h"
#include <stdio.h>
#include "printAutoFinishParameters.h"
#include "fileDefines.h"
void printAutoFinishParameters() {
fprintf( pAO, "PARAMETERS {\n" );
fprintf( pAO, "! If you want to modify any of these parameters, just cut/paste\n" );
fprintf( pAO, "! the relevant line into your ~/.consedrc file\n" );
fprintf( pAO, "! (or into the edit_dir/.consedrc file)\n" );
fprintf( pAO, "! In the following, I have annotated the parameters with the following\n");
fprintf( pAO, "! symbols:\n");
fprintf( pAO, "!\n");
fprintf( pAO, "! (YES) freely customize to your own site\n");
fprintf( pAO, "! (OK) don't change unless you have a specific need and know what you\n");
fprintf( pAO, "! are doing\n");
fprintf( pAO, "! (NO) don't change this!\n");
fprintf( pAO, "! (GREEN LAB) Resources here are just those for Green Lab research and have\n");
fprintf( pAO, "! no effect on any Consed/Autofinish/AutoReport functions\n");
fprintf( pAO, "!\n");
fprintf( pAO, "!\n");
fprintf( pAO, "! parameters in the (YES) category:\n");
fprintf( pAO, "!\n");
fprintf( pAO, "consed.autoFinishMinNumberOfErrorsFixedByAnExp: %.3f\n",
pCP->dAutoFinishMinNumberOfErrorsFixedByAnExp_ );
fprintf( pAO, "! if an experiment solves fewer errors than this, it isn't worth doing\n");
fprintf( pAO, "! so won't be chosen. This parameter controls when Autofinish stops\n");
fprintf( pAO, "! choosing experiments.\n");
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.autoFinishRedundancy: %.3f\n",
pCP->dAutoFinishRedundancy_ );
fprintf( pAO, "! This number should be between 1.0 and 2.0 If you want more reads\n");
fprintf( pAO, "! for each area, increase the number towards 2.0 If you want fewer\n");
fprintf( pAO, "! reads per area, decrease it towards 1.0. This only affects\n");
fprintf( pAO, "! universal primer reads--not custom primer reads.\n");
fprintf( pAO, "!\n");
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.autoFinishAverageInsertSize: %d\n",
pCP->nAutoFinishAverageInsertSize_ );
fprintf( pAO, "! If a template has a forward but no reverse, when deciding whether to\n");
fprintf( pAO, "! allow this template for a particular primer or reverse, we need to\n");
fprintf( pAO, "! make an assumption of where is the end of the template. If we have\n");
fprintf( pAO, "! do not have enough forward/reverse pairs to determine the mean, then\n");
fprintf( pAO, "! this parameter is used.\n");
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.primersMaxInsertSizeOfASubclone: %d\n",
pCP->nPrimersMaxInsertSizeOfASubclone_ );
fprintf( pAO, "! check +/- this distance from the primer for false-annealing\n");
fprintf( pAO, "! and check at most this distance for templates for a primer.\n");
fprintf( pAO, "! Thus if you have more than one library, make this the max of\n");
fprintf( pAO, "! all libraries.\n");
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.primersMaxMeltingTemp: %d\n",
pCP->nPrimersMaxMeltingTemp_ );
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.primersMaxMeltingTempForPCR: %d\n",
pCP->nPrimersMaxMeltingTempForPCR_ );
fprintf( pAO, "! Note: the difference between consed.primersMaxMeltingTempForPCR and\n");
fprintf( pAO, "! consed.primersMinMeltingTempForPCR must be less than or equal to\n");
fprintf( pAO, "! consed.primersMaxMeltingTempDifferenceForPCR\n");
fprintf( pAO, "! Otherwise, autofinish may take forever to pick pcr primers.\n");
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.primersPickTemplatesForPrimers: %s\n",
( ( pCP->bPrimersPickTemplatesForPrimers_ ) ? "true" : "false" ) );
fprintf( pAO, "! when picking primers for subclone templates, pick templates also.\n");
fprintf( pAO, "! If there is no suitable template for a primer, do not pick the\n");
fprintf( pAO, "! primer. If you like to pick your own templates, you might want to\n");
fprintf( pAO, "! turn this off for a little improvement in speed.\n");
fprintf( pAO, "! This has no effect on Autofinish--just on interactive primer picking\n");
fprintf( pAO, "! in Consed.\n");
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.primersSubcloneFullPathnameOfFileOfSequencesForScreening: %s\n",
(char*)pCP->soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_.data() );
fprintf( pAO, "! vector sequence file if choosing subclone (e.g., M13, plasmid)\n");
fprintf( pAO, "! templates\n");
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.primersCloneFullPathnameOfFileOfSequencesForScreening: %s\n",
(char*)pCP->soPrimersCloneFullPathnameOfFileOfSequencesForScreening_.data() );
fprintf( pAO, "! vector sequence file if choosing clone (e.g., cosmid, BAC) template\n");
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.primersMinMeltingTemp: %d\n",
pCP->nPrimersMinMeltingTemp_ );
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.primersMinMeltingTempForPCR: %d\n",
pCP->nPrimersMinMeltingTempForPCR_ );
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.autoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair: %s\n",
( ( pCP->bAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair_ ) ? "true" : "false" ) );
fprintf( pAO, "! otherwise, a single serious hqd will cause the template to be rejected.\n");
fprintf( pAO, "! (YES)\n");
fprintf( pAO, "consed.autoReportPrintReadNamesInRegion: %s\n",
( ( pCP->bAutoReportPrintReadNamesInRegion_ ) ? "true" : "false" ) );
fprintf( pAO, "!(OK)\n");
fprintf( pAO, "consed.autoReportPrintReadNamesInRegionContig: %s\n",
(char*)pCP->soAutoReportPrintReadNamesInRegionContig_.data() );
fprintf( pAO, "!(OK)\n");
fprintf( pAO, "consed.autoReportPrintReadNamesInRegionLeftPos: %d\n",
pCP->nAutoReportPrintReadNamesInRegionLeftPos_ );
fprintf( pAO, "!(OK)\n");
fprintf( pAO, "consed.autoReportPrintReadNamesInRegionRightPos: %d\n",
pCP->nAutoReportPrintReadNamesInRegionRightPos_ );
fprintf( pAO, "!(OK)\n");
fprintf( pAO, "consed.autoReportPrintHighlyDiscrepantRegions: %s\n",
( ( pCP->bAutoReportPrintHighlyDiscrepantRegions_ ) ? "true" : "false" ) );
fprintf( pAO, "! motivated by solexa reads. Print where many reads disagree with\n");
fprintf( pAO, "! reference sequence\n");
fprintf( pAO, "! uses: \n");
fprintf( pAO, "! consed.qualityThresholdForFindingHighQualityDiscrepancies\n");
fprintf( pAO, "! ignores bases lower than this\n");
fprintf( pAO, "! consed.navigateByHighlyDiscrepantPositionsMinDiscrepantReads\n");
fprintf( pAO, "! consed.navigateByHighlyDiscrepantPositionsMaxDepthOfCoverage\n");
fprintf( pAO, "! consed.navigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality\n");
fprintf( pAO, "! consed.navigateByHighlyDiscrepantPositionsJustListIndels\n");
fprintf( pAO, "! consed.navigateByHighlyDiscrepantPositionsIgnoreIfNOrXInConsensus: false\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportPrintScaffolds: %s\n",
( ( pCP->bAutoReportPrintScaffolds_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportPrintHighQualityDiscrepancies: %s\n",
( ( pCP->bAutoReportPrintHighQualityDiscrepancies_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags: %s\n",
( ( pCP->bAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags_ ) ? "true" : "false" ) );
fprintf( pAO, "! used in connection with consed.autoReportPrintHighQualityDiscrepancies\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportHighQualityDiscrepanciesExcludeMostPads: %s\n",
( ( pCP->bAutoReportHighQualityDiscrepanciesExcludeMostPads_ ) ? "true" : "false" ) );
fprintf( pAO, "! used in connection with consed.autoReportPrintHighQualityDiscrepancies\n");
fprintf( pAO, "! Excludes high quality discrepancy pads except those in cases such as this:\n");
fprintf( pAO, "! consensus aa\n");
fprintf( pAO, "! read 1 *a\n");
fprintf( pAO, "! read 2 *a\n");
fprintf( pAO, "! read 3 a*\n");
fprintf( pAO, "! read 4 a*\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportPrintLowConsensusQualityRegions: %s\n",
( ( pCP->bAutoReportPrintLowConsensusQualityRegions_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportPrintSingleSubcloneRegions: %s\n",
( ( pCP->bAutoReportPrintSingleSubcloneRegions_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportPrintSingleStrandedRegions: %s\n",
( ( pCP->bAutoReportPrintSingleStrandedRegions_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportPrintLinkingForwardReversePairs: %s\n",
( ( pCP->bAutoReportPrintLinkingForwardReversePairs_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportPrintFilteredInconsistentForwardReversePairs: %s\n",
( ( pCP->bAutoReportPrintFilteredInconsistentForwardReversePairs_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoReportPrintAssemblySummary: %s\n",
( ( pCP->bAutoReportPrintAssemblySummary_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates: %d\n",
pCP->nAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_ );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions: %d\n",
pCP->nAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_ );
fprintf( pAO, "! \"unoriented\" pcr reactions means cases in which autofinish is suggesting\n");
fprintf( pAO, "! a pcr reaction to span a gap, but it doesn't know whether the 2 contig ends\n");
fprintf( pAO, "! really go together since there are not enough (or no)templates that span \n");
fprintf( pAO, "! that gap \n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis: %d\n",
pCP->nAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_ );
fprintf( pAO, "! Gap size can be specified in user-defined contigEndPair tags in a \n");
fprintf( pAO, "! gap_size: field\n");
fprintf( pAO, "! If the gap size is greater than this number, do not do PCR.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotDoPCRIfEndIsExtendedByReads: %s\n",
( ( pCP->bAutoFinishDoNotDoPCRIfEndIsExtendedByReads_ ) ? "true" : "false" ) );
fprintf( pAO, "! If this is true, and autofinish was able to walk off the end of a\n");
fprintf( pAO, "! contig, do not do PCR with that end of the contig. \n");
fprintf( pAO, "!\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishMaxAcceptableErrorsPerMegabase: %d\n",
pCP->nAutoFinishMaxAcceptableErrorsPerMegabase_ );
fprintf( pAO, "! target error rate. This parameter used to be the one that stopped\n");
fprintf( pAO, "! Autofinish from calling more reads. However, consider a BAC that is\n");
fprintf( pAO, "! nearly perfect except for one region with 3 quality 10 bases in a\n");
fprintf( pAO, "! row. In this case the global errors per megabase is very\n");
fprintf( pAO, "! low--perhaps lower than 1 error per megabase. Despite this, most\n");
fprintf( pAO, "! labs would like to do one more read to fix this problem. Thus we\n");
fprintf( pAO, "! set this parameter to zero (to disable it) so Autofinish will use\n");
fprintf( pAO, "! the parameter consed.autoFinishMinNumberOfErrorsFixedByAnExp to stop\n");
fprintf( pAO, "! calling more reads--it is a local error rate.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize: %d\n",
pCP->nAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_ );
fprintf( pAO, "! If a template has a forward but no reverse, when deciding whether to\n");
fprintf( pAO, "! allow this template for a particular primer, we need to make an assumption\n");
fprintf( pAO, "! of where is the end of the template. If the template comes from a library\n");
fprintf( pAO, "! with insert size 1500, it would be reasonable to assume that the end of\n");
fprintf( pAO, "! template will be 1500 bases from the forward read. But if this template\n");
fprintf( pAO, "! has an insert that is shorter than average, the walk may walk into vector.\n");
fprintf( pAO, "! To be conservative, we may want to assume that the insert is somewhat \n");
fprintf( pAO, "! shorter than average. By default, we assume that it is 90% as large as \n");
fprintf( pAO, "! the average. This parameter gives that percentage. This parameter\n");
fprintf( pAO, "! is used both by Consed and Autofinish.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersNumberOfBasesToBackUpToStartLooking: %d\n",
pCP->nPrimersNumberOfBasesToBackUpToStartLooking_ );
fprintf( pAO, "! e.g., if this is 50 and you want a read at position 1000, primers\n");
fprintf( pAO, "! will be searched before base 950 but not in the region 950 to 1000\n");
fprintf( pAO, "! This has no effect on Autofinish--just on interactively picking primers.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment: %d\n",
pCP->nPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_ );
fprintf( pAO, "! When a PCR product is made, you want it to overlap by this many bases\n");
fprintf( pAO, "! the high quality part of the existing consensus. Thus choose PCR\n");
fprintf( pAO, "! primers this many bases back (or more)\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersOKToChoosePrimersInSingleSubcloneRegion: %s\n",
( ( pCP->bPrimersOKToChoosePrimersInSingleSubcloneRegion_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersOKToChoosePrimersWhereHighQualityDiscrepancies: %s\n",
( ( pCP->bPrimersOKToChoosePrimersWhereHighQualityDiscrepancies_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersOKToChoosePrimersWhereUnalignedHighQualityRegion: %s\n",
( ( pCP->bPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion_ ) ? "true" : "false" ) );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCallReversesToFlankGaps: %s\n",
( ( pCP->bAutoFinishCallReversesToFlankGaps_ ) ? "true" : "false" ) );
fprintf( pAO, "! if there is a forward-reverse pair flanking a gap, print it out\n");
fprintf( pAO, "! if there is not, suggest reverses to flank the gap\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAllowWholeCloneReads: %s\n",
( ( pCP->bAutoFinishAllowWholeCloneReads_ ) ? "true" : "false" ) );
fprintf( pAO, "! ok to call reads whose template for sequencing reaction is the\n");
fprintf( pAO, "! entire clone (BAC or cosmid)\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAllowCustomPrimerSubcloneReads: %s\n",
( ( pCP->bAutoFinishAllowCustomPrimerSubcloneReads_ ) ? "true" : "false" ) );
fprintf( pAO, "! ok to call reads with custom primers and subclone template\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAllowResequencingReads: %s\n",
( ( pCP->bAutoFinishAllowResequencingReads_ ) ? "true" : "false" ) );
fprintf( pAO, "! This is just universal primer reads to be resequenced using\n");
fprintf( pAO, "! dye terminator chemistry or special chemistry. (It does not\n");
fprintf( pAO, "! mean resequencing a custom primer read.)\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAllowResequencingReadsOnlyForRunsAndStops: %s\n",
( ( pCP->bAutoFinishAllowResequencingReadsOnlyForRunsAndStops_ ) ? "true" : "false" ) );
fprintf( pAO, "! This parameter only has any effect when\n");
fprintf( pAO, "! consed.autoFinishAllowResequencingReads is set to true. In that\n");
fprintf( pAO, "! case no resequencing reads will be suggested, unless it is to cross\n");
fprintf( pAO, "! a run or stop and special chemistry is suggested.\n");
fprintf( pAO, "! (OK) \n");
fprintf( pAO, "consed.autoFinishAllowDeNovoUniversalPrimerSubcloneReads: %s\n",
( ( pCP->bAutoFinishAllowDeNovoUniversalPrimerSubcloneReads_ ) ? "true" : "false" ) );
fprintf( pAO, "! Allows calling reverse when there is just a forward.\n");
fprintf( pAO, "! Allows calling a forward when there is just a reverse.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAllowMinilibraries: %s\n",
( ( pCP->bAutoFinishAllowMinilibraries_ ) ? "true" : "false" ) );
fprintf( pAO, "! Allows calling minilibraries (shatter libraries or transposon\n");
fprintf( pAO, "! libraries) of subclone templates for closing gaps\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAllowPCR: %s\n",
( ( pCP->bAutoFinishAllowPCR_ ) ? "true" : "false" ) );
fprintf( pAO, "! Allows calling PCR for closing gaps, but only as a last resort\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAllowUnorientedPCRReactions: %s\n",
( ( pCP->bAutoFinishAllowUnorientedPCRReactions_ ) ? "true" : "false" ) );
fprintf( pAO, "! Allows calling PCR amongst contig-ends that have insufficient\n");
fprintf( pAO, "! fwd/rev pair linkage to any other contig-end. Thus it suggests\n");
fprintf( pAO, "! pcr amongst all such contig-ends. \n");
fprintf( pAO, "! To allow this type of pcr, you must also make:\n");
fprintf( pAO, "! consed.autoFinishAllowPCRForUnorientedContigEnds: true\n");
fprintf( pAO, "! See also:\n");
fprintf( pAO, "! consed.autoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions: \n");
fprintf( pAO, "! which gives you finer control over unoriented pcr.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAllowResequencingAUniversalPrimerAutofinishRead: %s\n",
( ( pCP->bAutoFinishAllowResequencingAUniversalPrimerAutofinishRead_ ) ? "true" : "false" ) );
fprintf( pAO, "! if Autofinish suggests a de novo universal primer read,\n");
fprintf( pAO, "! do not allow Autofinish to suggest a resequence of this read\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAlwaysCloseGapsUsingMinilibraries: %s\n",
( ( pCP->bAutoFinishAlwaysCloseGapsUsingMinilibraries_ ) ? "true" : "false" ) );
fprintf( pAO, "! \"Minilibraries\" includes transposing a subclone template or\n");
fprintf( pAO, "! making a shatter library from a subclone template\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishMaximumFinishingReadLength: %d\n",
pCP->nAutoFinishMaximumFinishingReadLength_ );
fprintf( pAO, "! Change this only if your finishing reads are typically shorter\n");
fprintf( pAO, "! than your shotgun reads. Otherwise, leave it unrealistically long,\n");
fprintf( pAO, "! and Autofinish will set its model read based on your existing\n");
fprintf( pAO, "! shotgun reads.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger: %d\n",
pCP->nAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_ );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishSuggestSpecialChemistryForRunsAndStops: %s\n",
( ( pCP->bAutoFinishSuggestSpecialChemistryForRunsAndStops_ ) ? "true" : "false" ) );
fprintf( pAO, "! Suggest special chemistry such as dGTP for reads that cross\n");
fprintf( pAO, "! mononucleotide or dinucleotide repeats that cause reads to fail or \n");
fprintf( pAO, "! stops (structure) that cause reads to fail and thus dye terminator\n");
fprintf( pAO, "! reads won't work.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishSuggestThisManyMinilibrariesPerGap: %d\n",
pCP->nAutoFinishSuggestThisManyMinilibrariesPerGap_ );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersWindowSizeInLooking: %d\n",
pCP->nPrimersWindowSizeInLooking_ );
fprintf( pAO, "! e.g., if this is 300, with example above, primers will be searched\n");
fprintf( pAO, "! from base 650 to 950. This has no effect on Autofinish--it is just\n");
fprintf( pAO, "! used for interactive primer picking in Consed.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersAssumeTemplatesAreDoubleStrandedUnlessSpecified: %s\n",
( ( pCP->bPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified_ ) ? "true" : "false" ) );
fprintf( pAO, "! you can put the template type in the phd file in a WR template item\n");
fprintf( pAO, "! consed will have a list of these and know which are single and\n");
fprintf( pAO, "! double stranded\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishAllowResequencingReadsToExtendContigs: %s\n",
( ( pCP->bAutoFinishAllowResequencingReadsToExtendContigs_ ) ? "true" : "false" ) );
fprintf( pAO, "! if false, a resequencing read is not called to extend a contig--only\n");
fprintf( pAO, "! custom primer reads and de novo universal primer reads are called\n");
fprintf( pAO, "! for this purpose. \n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCallHowManyReversesToFlankGaps: %d\n",
pCP->nAutoFinishCallHowManyReversesToFlankGaps_ );
fprintf( pAO, "! This has two purposes: 1) it specifies how many forward/reverse\n");
fprintf( pAO, "! pairs should be present for Consed/Autofinish to be certain of the\n");
fprintf( pAO, "! order/ orientation of two contigs. If there are this many fwd/rev\n");
fprintf( pAO, "! pairs flanking a gap, Autofinish will print out the contig ends that\n");
fprintf( pAO, "! flank the gap. 2) If consed.autoFinishCallReversesToFlankGaps is\n");
fprintf( pAO, "! set to true, and there are less than this many fwd/rev pairs\n");
fprintf( pAO, "! flanking a gap, Autofinish will suggest additional reverses until\n");
fprintf( pAO, "! there are this many.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCloseGaps: %s\n",
( ( pCP->bAutoFinishCloseGaps_ ) ? "true" : "false" ) );
fprintf( pAO, "! this allows you to turn off choosing reads to close gaps\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishContinueEvenThoughReadInfoDoesNotMakeSense: %s\n",
( ( pCP->bAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense_ ) ? "true" : "false" ) );
fprintf( pAO, "! this allows you to override the checks that autofinish makes on the\n");
fprintf( pAO, "! read info, such as checking there are not more than 5 or so reads\n");
fprintf( pAO, "! from the same subclone template\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCostOfResequencingUniversalPrimerSubcloneReaction: %.3f\n",
pCP->dAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_ );
fprintf( pAO, "! compares universal primer subclone reaction, custom primer subclone \n");
fprintf( pAO, "! reaction, and custom primer clone reaction to decide which to favor\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCostOfCustomPrimerSubcloneReaction: %.3f\n",
pCP->dAutoFinishCostOfCustomPrimerSubcloneReaction_ );
fprintf( pAO, "! see above\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCostOfCustomPrimerCloneReaction: %.3f\n",
pCP->dAutoFinishCostOfCustomPrimerCloneReaction_ );
fprintf( pAO, "! see above \n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCostOfDeNovoUniversalPrimerSubcloneReaction: %.3f\n",
pCP->dAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_ );
fprintf( pAO, "! cost of reverse where there is only a forward or cost of forward\n");
fprintf( pAO, "! when there is only a reverse\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCostOfMinilibrary: %.3f\n",
pCP->dAutoFinishCostOfMinilibrary_ );
fprintf( pAO, "! cost of making a minilibrary (transposon library or shatter library)\n");
fprintf( pAO, "! from a subclone template\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCoverSingleSubcloneRegions: %s\n",
( ( pCP->bAutoFinishCoverSingleSubcloneRegions_ ) ? "true" : "false" ) );
fprintf( pAO, "! this allows you to turn off choosing reads to cover single subclone regions\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCoverLowConsensusQualityRegions: %s\n",
( ( pCP->bAutoFinishCoverLowConsensusQualityRegions_ ) ? "true" : "false" ) );
fprintf( pAO, "! this allows you to turn off choosing reads to cover low consensus\n");
fprintf( pAO, "! quality regions\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDebugUniversalPrimerReadsFile: %s\n",
(char*)pCP->filAutoFinishDebugUniversalPrimerReadsFile_.data() );
fprintf( pAO, "! for debugging Autofinish\n");
fprintf( pAO, "! put a file with this name in the same directory as the ace file\n");
fprintf( pAO, "! format:\n");
fprintf( pAO, "! fcalld09 fwd\n");
fprintf( pAO, "! fgj74f01 rev\n");
fprintf( pAO, "! (template name) (fwd or rev)\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDebugCustomPrimerReadsFile: %s\n",
(char*)pCP->filAutoFinishDebugCustomPrimerReadsFile_.data() );
fprintf( pAO, "! for debugging Autofinish\n");
fprintf( pAO, "! put a file with this name in the same directory as the ace file\n");
fprintf( pAO, "! format:\n");
fprintf( pAO, "! cgggacctgg\n");
fprintf( pAO, "! (primer in 5' to 3' orientation)\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases: %d\n",
pCP->nAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_ );
fprintf( pAO, "! see consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases: %d\n",
pCP->nAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_ );
fprintf( pAO, "! see consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotFinishWhereTheseTagsAre: %s\n",
(char*)pCP->soAutoFinishDoNotFinishWhereTheseTagsAre_.data() );
fprintf( pAO, "! list of tag types separated by spaces. E.g.,\n");
fprintf( pAO, "! doNotFinish repeat \n");
fprintf( pAO, "! tells autofinish that you are not interested in finishing in this region\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotExtendContigsWhereTheseTagsAre: %s\n",
(char*)pCP->soAutoFinishDoNotExtendContigsWhereTheseTagsAre_.data() );
fprintf( pAO, "! list of tag types separated by spaces. E.g.,\n");
fprintf( pAO, "! doNotFinish repeat\n");
fprintf( pAO, "! tells autofinish that you do not want to extend the contig near this\n");
fprintf( pAO, "! tag. If you do not want this feature, just leave the list empty.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd: %d\n",
pCP->nAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_ );
fprintf( pAO, "! Uses the list from consed.autoFinishDoNotExtendContigsWhereTheseTagsAre\n");
fprintf( pAO, "! and checks if any of these tags are within this many bases of the end of \n");
fprintf( pAO, "! the contig. If they are, does not extend the contig.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDumpTemplates: %s\n",
( ( pCP->bAutoFinishDumpTemplates_ ) ? "true" : "false" ) );
fprintf( pAO, "! for debugging, this allows you to dump all information about the \n");
fprintf( pAO, "! templates--insert locations \n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishExcludeContigIfOnlyThisManyReadsOrLess: %d\n",
pCP->nAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_ );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishExcludeContigIfDepthOfCoverageGreaterThanThis: %.3f\n",
pCP->dAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_ );
fprintf( pAO, "! To exclude contigs that are probably E. coli contamination\n");
fprintf( pAO, "! \"depth of coverage\" is defined here to mean the sum of the read\n");
fprintf( pAO, "! lengths (including low quality ends) divided by the contig length.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishExcludeContigIfThisManyBasesOrLess: %d\n",
pCP->nAutoFinishExcludeContigIfThisManyBasesOrLess_ );
fprintf( pAO, "! consed.autoFinishExcludeContigIfTooShort must be set to true for\n");
fprintf( pAO, "! this to have any effect\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions: %d\n",
pCP->nAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_ );
fprintf( pAO, "! this tells autofinish which templates you are planning on using\n");
fprintf( pAO, "! which is necessary to figure out which regions will still be single\n");
fprintf( pAO, "! subclone regions\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersMinNumberOfTemplatesForPrimers: %d\n",
pCP->nPrimersMinNumberOfTemplatesForPrimers_ );
fprintf( pAO, "! if there are fewer templates than this, the primer is rejected\n");
fprintf( pAO, "consed.autoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus: %d\n",
pCP->nAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_ );
fprintf( pAO, "! when extending the consensus, a read that is too far from the\n");
fprintf( pAO, "! consensus will not be assembled by phrap with this contig and thus\n");
fprintf( pAO, "! will not be useful for extending the consensus. This gives the\n");
fprintf( pAO, "! minimum overlap of a read with the high quality segment of the\n");
fprintf( pAO, "! consensus. As reads are picked, then additional reads may be picked\n");
fprintf( pAO, "! further out.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead: %d\n",
pCP->nAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_ );
fprintf( pAO, "! used to figure out where the beginning of a reverse will be. Not\n");
fprintf( pAO, "! important to be accurate because the insert size is so uncertain\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishCDNANotGenomic: %s\n",
( ( pCP->bAutoFinishCDNANotGenomic_ ) ? "true" : "false" ) );
fprintf( pAO, "! If this is set to true, the whole clone is assumed to be cDNA and,\n");
fprintf( pAO, "! rather than the normal method of detecting the end of the clone,\n");
fprintf( pAO, "! Autofinish detects the end of the cDNA as follows:\n");
fprintf( pAO, "! the user is expected to add whole read items of type 'template',\n");
fprintf( pAO, "! with 'type: univ fwd' for the 5' end and 'type: univ rev' for the 3'\n");
fprintf( pAO, "! end of the cDNA. \n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishConfidenceThatReadWillCoverSingleSubcloneRegion: %d\n",
pCP->nAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_ );
fprintf( pAO, "! Autofinish computes the per cent of existing reads are aligned at\n");
fprintf( pAO, "! each base position. Typically, this number starts at around 0% at\n");
fprintf( pAO, "! base position 1, rises to close to 100% at around base position 300,\n");
fprintf( pAO, "! and then drops again to 0% at base position 800 or so. This number\n");
fprintf( pAO, "! specifies how high the number must be for Autofinish to consider an\n");
fprintf( pAO, "! Autofinish read to cover a single subclone region.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads: %s\n",
( ( pCP->bAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads_ ) ? "true" : "false" ) );
fprintf( pAO, "! If this is true, then custom primer reads are printed out like this:\n");
fprintf( pAO, "! tccagaaaactaattcaaaataatg,56,standard.2,->,2413,2413,3681,Contig1,9,djs74_690 (fwd),10,djs74_1803 (fwd),11,djs74_1861 (fwd)\n");
fprintf( pAO, "! If this is false, then custom primer reads are printed out like this:\n");
fprintf( pAO, "! tccagaaaactaattcaaaataatg,56,standard.2,->,2413,2413,3681,Contig1,9,djs74_690,10,djs74_1803,11,djs74_1861\n");
fprintf( pAO, "! The difference is the (fwd) or (rev) that indicates which strand of\n");
fprintf( pAO, "! the subclone template is to be used. This is particularly important if\n");
fprintf( pAO, "! you use M13 and thus must make the reverse strand.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishPrintMinilibrariesSummaryFile: %s\n",
( ( pCP->bAutoFinishPrintMinilibrariesSummaryFile_ ) ? "true" : "false" ) );
fprintf( pAO, "! If this is true, Autofinish will print a file with name\n");
fprintf( pAO, "! xxx.minilibraries just as it prints one as xxx.univReverses and\n");
fprintf( pAO, "! xxx.univForwards\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishNearGapsSuggestEachMissingReadOfReadPairs: %s\n",
( ( pCP->bAutoFinishNearGapsSuggestEachMissingReadOfReadPairs_ ) ? "true" : "false" ) );
fprintf( pAO, "! This is set to true to increase the chance of closing a gap. For\n");
fprintf( pAO, "! every subclone template that has just one universal primer read\n");
fprintf( pAO, "! (either just a forward or just a reverse) that might protrude off\n");
fprintf( pAO, "! the end of the contig, Autofinish suggests the universal primer read\n");
fprintf( pAO, "! off the opposite end of the subclone template.\n");
fprintf( pAO, "! If this parameter is set false, then\n");
fprintf( pAO, "! Autofinish may still choose some of these reads, but it won't\n");
fprintf( pAO, "! necessarily choose them all.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger: %d\n",
pCP->nAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_ );
fprintf( pAO, "! Do not ignore low consensus quality bases if they are this many \n");
fprintf( pAO, "! bases from the end of the contig. \n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersMinimumLengthOfAPrimer: %d\n",
pCP->nPrimersMinimumLengthOfAPrimer_ );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersMaximumLengthOfAPrimer: %d\n",
pCP->nPrimersMaximumLengthOfAPrimer_ );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersMinimumLengthOfAPrimerForPCR: %d\n",
pCP->nPrimersMinimumLengthOfAPrimerForPCR_ );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersMaximumLengthOfAPrimerForPCR: %d\n",
pCP->nPrimersMaximumLengthOfAPrimerForPCR_ );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersMaxMeltingTempDifferenceForPCR: %.3f\n",
pCP->dPrimersMaxMeltingTempDifferenceForPCR_ );
fprintf( pAO, "! how large can the difference of melting temperatures be between\n");
fprintf( pAO, "! two primers of a PCR primer pair\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersMaxPCRPrimerPairsToDisplay: %d\n",
pCP->nPrimersMaxPCRPrimerPairsToDisplay_ );
fprintf( pAO, "! there is a limit here, because there could possibly be millions\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersCheckJustSomePCRPrimerPairsRatherThanAll: %s\n",
( ( pCP->bPrimersCheckJustSomePCRPrimerPairsRatherThanAll_ ) ? "true" : "false" ) );
fprintf( pAO, "! If there are 1000 1st primers, and 1000 2nd primers, that gives\n");
fprintf( pAO, "! a million pairs for Consed to check, which takes a long time. So\n");
fprintf( pAO, "! instead, just check some of the pairs\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersNumberOfTemplatesToDisplayInFront: %d\n",
pCP->nPrimersNumberOfTemplatesToDisplayInFront_ );
fprintf( pAO, "! this shows the number of templates to show in the interactive primer\n");
fprintf( pAO, "! picking window\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersMaxLengthOfMononucleotideRepeat: %d\n",
pCP->nPrimersMaxLengthOfMononucleotideRepeat_ );
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersBadLibrariesFile: %s\n",
(char*)pCP->filPrimersBadLibrariesFile_.data() );
fprintf( pAO, "! file of libraries, one per line\n");
fprintf( pAO, "! If any template is from any one of these libraries, then\n");
fprintf( pAO, "! consed/autofinish will not use this template for walking or\n");
fprintf( pAO, "! suggesting any universal primer reads\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersLibrariesInfoFile: %s\n",
(char*)pCP->filPrimersLibrariesInfoFile_.data() );
fprintf( pAO, "! file of libraries, with one entry for each library of the following\n");
fprintf( pAO, "! format:\n");
fprintf( pAO, "! LIB{\n");
fprintf( pAO, "! name: library1\n");
fprintf( pAO, "! avgInsertSize: 3000\n");
fprintf( pAO, "! maxInsertSize: 5000\n");
fprintf( pAO, "! stranded: single\n");
fprintf( pAO, "! cost: 600.0\n");
fprintf( pAO, "! }\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersBadTemplatesFile: %s\n",
(char*)pCP->filPrimersBadTemplatesFile_.data() );
fprintf( pAO, "! file of templates that you've tried, don't work, and you don't want to try\n");
fprintf( pAO, "! again\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersChooseTemplatesByPositionInsteadOfQuality: %s\n",
( ( pCP->bPrimersChooseTemplatesByPositionInsteadOfQuality_ ) ? "true" : "false" ) );
fprintf( pAO, "! Templates for subclone custom primer walks can be chosen either on\n");
fprintf( pAO, "! the basis of the quality of the template (as determined by the quality \n");
fprintf( pAO, "! of existing reads from that template) or by the location of the end of \n");
fprintf( pAO, "! the template. If this parameter is false, templates will be chosen\n");
fprintf( pAO, "! based solely on quality. If this parameter is true, then templates\n");
fprintf( pAO, "! with forward/reverse pairs will be picked first, followed by templates \n");
fprintf( pAO, "! that have the beginning of the insert closest to the primer.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersWhenChoosingATemplateMinPotentialReadLength: %d\n",
pCP->nPrimersWhenChoosingATemplateMinPotentialReadLength_ );
fprintf( pAO, "! when choosing templates for a custom primer, only choose a template\n");
fprintf( pAO, "! if the read can be chosen at least this long\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.primersWindowSizeInLookingForPCR: %d\n",
pCP->nPrimersWindowSizeInLookingForPCR_ );
fprintf( pAO, "! will look this many bases back from the pointer when looking for a PCR\n");
fprintf( pAO, "! primer. Used both interactively and for Autofinish (see\n");
fprintf( pAO, "! getUnpaddedRangeForMakingPCRPrimers )\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.qualityThresholdForFindingHighQualityDiscrepancies: %d\n",
pCP->nQualityThresholdForFindingHighQualityDiscrepancies_ );
fprintf( pAO, "! high quality discrepancies have this quality or higher \n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishUseLongModelReadRatherThanShort: %s\n",
( ( pCP->bAutoFinishUseLongModelReadRatherThanShort_ ) ? "true" : "false" ) );
fprintf( pAO, "! When calculating the distribution of quality values at high read \n");
fprintf( pAO, "! positions, should Autofinish assume that the reads that were this\n");
fprintf( pAO, "! long and longer are representative of finishing reads, or should it\n");
fprintf( pAO, "! assume that some finishing will not make it out this far in roughly\n");
fprintf( pAO, "! the same proportion as the existing reads.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoPCRAmplifyFalseProductsOKIfLargerThanThis: %d\n",
pCP->nAutoPCRAmplifyFalseProductsOKIfLargerThanThis_ );
fprintf( pAO, "! If a pcr primer pair matches somewhere else and creates a product\n");
fprintf( pAO, "! larger than this, the pcr primer pair will still be acceptable\n");
fprintf( pAO, "! since the product will not easily form in the cycle time.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoPCRAmplifyMakePrimerOutOfFirstRegion: %s\n",
( ( pCP->bAutoPCRAmplifyMakePrimerOutOfFirstRegion_ ) ? "true" : "false" ) );
fprintf( pAO, "! I don't expect people will use this. It allows you to amplify a\n");
fprintf( pAO, "! region using autoPCRAmplify not by allowing Consed to choose each\n");
fprintf( pAO, "! primer (the normal case) but rather by fixing the first primer to be\n");
fprintf( pAO, "! the first area bordering the region. I added this to allow\n");
fprintf( pAO, "! non-specific priming to the transplice leader.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct: %d\n",
pCP->nAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_ );
fprintf( pAO, "! ---> --->\n");
fprintf( pAO, "! false true match\n");
fprintf( pAO, "! In such a case, the primer pair will be rejected if the false is\n");
fprintf( pAO, "! within 5000 bases of true, even if false is a false match of the\n");
fprintf( pAO, "! other primer.\n");
fprintf( pAO, "!\n");
fprintf( pAO, "! <--- --->\n");
fprintf( pAO, "! false true match\n");
fprintf( pAO, "! In this case, the primer pair will not be eliminated.\n");
fprintf( pAO, "! (OK)\n");
fprintf( pAO, "consed.autoFinishEmulate9_66Behavior: %s\n",
( ( pCP->bAutoFinishEmulate9_66Behavior_ ) ? "true" : "false" ) );
fprintf( pAO, "! Picks univ primer reads and walks in the same phase. This results\n");
fprintf( pAO, "! in poor redundancy of universal primer reads, may pick custom primer\n");
fprintf( pAO, "! reads over universal primer reads, but may pick fewer\n");
fprintf( pAO, "! reads overall.\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersPCRPrimersGroupedIntoWindowOfThisManyBases: %d\n",
pCP->nPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_ );
fprintf( pAO, "! to speed up PCR primer picking and to reduce the number of \n");
fprintf( pAO, "! PCR primer pairs, group primers into windows of this size\n");
fprintf( pAO, "! and then just compare window against window\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersLookForThisManyPCRPrimerPairsPerPairOfGroups: %d\n",
pCP->nPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_ );
fprintf( pAO, "! to speed up PCR primer picking and to reduce the number of PCr\n");
fprintf( pAO, "! primer pairs, group primers into windows and then just accept\n");
fprintf( pAO, "! this many primer pairs from a pair of groups\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs: %.3f\n",
pCP->dAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_ );
fprintf( pAO, "! Only applies when consed.autoFinishNearGapsSuggestEachMissingReadOfReadPairs:\n");
fprintf( pAO, "! is set to true. If m is the mean insert size and d is the standard\n");
fprintf( pAO, "! deviation and this parameter is p, then consider all templates\n");
fprintf( pAO, "! within a distance m + p*d from the gap.\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishCheckThatReadsFromTheSameTemplateAreConsistent: %s\n",
( ( pCP->bAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent_ ) ? "true" : "false" ) );
fprintf( pAO, "! I strongly advise keeping this true. If you change it to false, you\n");
fprintf( pAO, "! are on your own. If the forward and reverse universal primer reads\n");
fprintf( pAO, "! look like this: <--- ---->, how is autofinish going\n");
fprintf( pAO, "! to even know where the template is, huh? Leave it true!\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether: %s\n",
( ( pCP->bAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether_ ) ? "true" : "false" ) );
fprintf( pAO, "! at higher redundancy, autofinish may pick custom primer reactions\n");
fprintf( pAO, "! that are only a few bases apart on the same strand. This parameter,\n");
fprintf( pAO, "! along with\n");
fprintf( pAO, "! consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases,\n");
fprintf( pAO, "! says how far apart they can be\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether: %s\n",
( ( pCP->bAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether_ ) ? "true" : "false" ) );
fprintf( pAO, "! Even at redundancy 1, Autofinish may pick whole clone reads just\n");
fprintf( pAO, "! a few bases apart. This prevents it.\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean: %.3f\n",
pCP->dAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_ );
fprintf( pAO, "! If a template is more than this many standard deviations from the\n");
fprintf( pAO, "! mean, try to avoid using it, unless there is nothing else.\n");
fprintf( pAO, "! Rationale: there is something wrong with this template--an insertion\n");
fprintf( pAO, "! or deletion.\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize: %d\n",
pCP->nAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_ );
fprintf( pAO, "! If there are at least this many fwd/rev pairs in a library, then \n");
fprintf( pAO, "! the mean and standard deviation are used for sizing other templates in\n");
fprintf( pAO, "! the same library. If there are fewer than this, then the default size \n");
fprintf( pAO, "! specified in the librariesInfo.txt file is used.\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize: %.3f\n",
pCP->dAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_ );
fprintf( pAO, "! If you are interested in walking on a template that does not have a\n");
fprintf( pAO, "! forward/reverse pair, then the precise insert size is uncertain. If\n");
fprintf( pAO, "! this template comes from a library that has lots of templates with\n");
fprintf( pAO, "! forward/reverse pairs, then the mean and standard deviation of the\n");
fprintf( pAO, "! insert sizes from this library is known. For the template in\n");
fprintf( pAO, "! question, we could just use the mean of this library (this parameter =\n");
fprintf( pAO, "! 0.0), but we could be conservative and assume the insert size is\n");
fprintf( pAO, "! somewhat less. This parameter tells how much less.\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead: %d\n",
pCP->nAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_ );
fprintf( pAO, "! this tells autofinish when it wants to make a new custom primer\n");
fprintf( pAO, "! read, how far this read must be from any previous custom primer\n");
fprintf( pAO, "! reads on the same strand\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp: %d\n",
pCP->nAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_ );
fprintf( pAO, "! if an experiment will only fix less than this number of single\n");
fprintf( pAO, "! subclone bases, don't do it even if the total number of single\n");
fprintf( pAO, "! subclone bases in the contig is too high\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishNumberOfBasesBetweenContigsAssumed: %d\n",
pCP->nAutoFinishNumberOfBasesBetweenContigsAssumed_ );
fprintf( pAO, "! gap size--each base in the gap counts as 1 error so autofinish tries\n");
fprintf( pAO, "! to extend into gaps\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishPotentialHighQualityPartOfReadStart: %d\n",
pCP->nAutoFinishPotentialHighQualityPartOfReadStart_ );
fprintf( pAO, "! nReadUnpaddedConsPosStart + nAutoFinishPotentialHighQualityPartOfReadStart_\n");
fprintf( pAO, "! == nReadUnpaddedConsPosStartOfPotentialHighQuality\n");
fprintf( pAO, "! this is used to evaluate the quality of templates\n");
fprintf( pAO, "! this no longer has much effect on the reads autofinish chooses\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishPotentialHighQualityPartOfReadEnd: %d\n",
pCP->nAutoFinishPotentialHighQualityPartOfReadEnd_ );
fprintf( pAO, "! nReadUnpaddedConsPosStart + nAutoFinishPotentialHighQualityPartOfReadEnd_\n");
fprintf( pAO, "! == nReadUnpaddedConsPosEndOfPotentialHighQuality\n");
fprintf( pAO, "! this is used to evaluate the quality of templates\n");
fprintf( pAO, "! this no longer has much effect on the reads autofinish chooses\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishPrintCustomNavigationFileForChosenReads: %s\n",
( ( pCP->bAutoFinishPrintCustomNavigationFileForChosenReads_ ) ? "true" : "false" ) );
fprintf( pAO, "! If this is true, then autofinish will print a file of the chosen reads\n");
fprintf( pAO, "! in the format for consed to navigate (prev and next) to each\n");
fprintf( pAO, "! location of the proposed new reads\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch: %d\n",
pCP->nAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_ );
fprintf( pAO, "! Normal case:\n");
fprintf( pAO, "! --------------------------- (consensus)\n");
fprintf( pAO, "! ----------- template1\n");
fprintf( pAO, "! ----------- template2\n");
fprintf( pAO, "! ----------- template3\n");
fprintf( pAO, "! Then you probably would want to use template3 since a reverse is\n");
fprintf( pAO, "! most likely to go in the other contig rather than go into gap.\n");
fprintf( pAO, "! But suppose that template2 and template3 don't exist. Would you\n");
fprintf( pAO, "! want to use template1? This parameter tells Autofinish whether you\n");
fprintf( pAO, "! would want to use it, or pick no reverse at all.\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishTagOligosWhenDoExperiments: %s\n",
( ( pCP->bAutoFinishTagOligosWhenDoExperiments_ ) ? "true" : "false" ) );
fprintf( pAO, "! when autofinish is run with -doExperiments, tags the oligos\n");
fprintf( pAO, "! it chooses\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersLookThisFarForForwardVectorInsertJunction: %d\n",
pCP->nPrimersLookThisFarForForwardVectorInsertJunction_ );
fprintf( pAO, "! don't change this--if no X's this far from beginning of read, then\n");
fprintf( pAO, "! assume that you are in insert\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersDNAConcentrationNanomolar: %.3f\n",
pCP->dPrimersDNAConcentrationNanomolar_ );
fprintf( pAO, "! used for melting temperature--don't change this!\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersMaxMatchElsewhereScore: %d\n",
pCP->nPrimersMaxMatchElsewhereScore_ );
fprintf( pAO, "! used for testing false-annealing to template and to vector\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersMaxMatchElsewhereScoreForPCR: %d\n",
pCP->nPrimersMaxMatchElsewhereScoreForPCR_ );
fprintf( pAO, "! used for testing false-annealing to template and to vector\n");
fprintf( pAO, "! when used with PCR\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersMaxSelfMatchScore: %d\n",
pCP->nPrimersMaxSelfMatchScore_ );
fprintf( pAO, "! cutoff for self-annealing of a primer\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersMaxPrimerDimerScoreForPCR: %d\n",
pCP->nPrimersMaxPrimerDimerScoreForPCR_ );
fprintf( pAO, "! careful changing this\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersMinQuality: %d\n",
pCP->nPrimersMinQuality_ );
fprintf( pAO, "! you must be sure of the sequence of a primer or it won't anneal to\n");
fprintf( pAO, "! where you want\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersPrintInfoOnRejectedTemplates: %s\n",
( ( pCP->bPrimersPrintInfoOnRejectedTemplates_ ) ? "true" : "false" ) );
fprintf( pAO, "! whether to print which templates were rejected and why (this output\n");
fprintf( pAO, "! can be large )\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersSaltConcentrationMillimolar: %.3f\n",
pCP->dPrimersSaltConcentrationMillimolar_ );
fprintf( pAO, "! used for melting temperature--don't change this!\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersScreenForVector: %s\n",
( ( pCP->bPrimersScreenForVector_ ) ? "true" : "false" ) );
fprintf( pAO, "! whether or not to screen primers for annealing to vector\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersToleranceForDifferentBeginningLocationOfUniversalPrimerReads: %d\n",
pCP->nPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_ );
fprintf( pAO, "! different forward reads or different reverse reads \n");
fprintf( pAO, "! can differ by up to this amount in the starting location\n");
fprintf( pAO, "! If they differ by more, then there is something wrong\n");
fprintf( pAO, "! with the template (it is mislabeled?) so don't use it again for\n");
fprintf( pAO, "! walking\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.primersTooManyVectorBasesInWalkingRead: %d\n",
pCP->nPrimersTooManyVectorBasesInWalkingRead_ );
fprintf( pAO, "! if there are this many x's, then don't walk again on this template\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoFinishMinSmithWatermanScoreOfARun: %d\n",
pCP->nAutoFinishMinSmithWatermanScoreOfARun_ );
fprintf( pAO, "! (NO) \n");
fprintf( pAO, "consed.autoFinishDoNotComparePCRPrimersMoreThanThisManyTimes: %.3f\n",
pCP->dAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_ );
fprintf( pAO, "! When autofinish tries to find a compatible set of pcr primers, it\n");
fprintf( pAO, "! can take billions of tries. This limits the number of tries so that,\n");
fprintf( pAO, "! if autofinish can't find it in this number of tries, it gives up\n");
fprintf( pAO, "! rather than running for days, weeks, years!\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoPCRAmplifyTooManySeriousFalseMatches: %d\n",
pCP->nAutoPCRAmplifyTooManySeriousFalseMatches_ );
fprintf( pAO, "! If a pcr primer pair has a significant false match to this many\n");
fprintf( pAO, "! other places in the assembly, do not consider for possible pcr\n");
fprintf( pAO, "! primer pairs. This is just for the purpose of speeding up picking\n");
fprintf( pAO, "! of primer pairs--the higher the number, the faster the searching,\n");
fprintf( pAO, "! but the more likely a primer pair will be selected that will\n");
fprintf( pAO, "! create multiple products.\n");
fprintf( pAO, "! (NO)\n");
fprintf( pAO, "consed.autoReportAllNeededSpeciesCode: %d\n",
pCP->nAutoReportAllNeededSpeciesCode_ );
fprintf( pAO, "! if 1, then require PPan|PTro, GGor, PPyg|MMul\n");
fprintf( pAO, "! if 2, then require PTro, GGor, PPyg, MMul\n");
fprintf( pAO, "! if 3, then require PTro, GGor, PPyg|MMul\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportUseCommasInBigNumbers: %s\n",
( ( pCP->bAutoReportUseCommasInBigNumbers_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintToCompareToReich: %s\n",
( ( pCP->bAutoReportPrintToCompareToReich_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportOnlyAllowSitesThatAreBetweenAcceptableSites: %s\n",
( ( pCP->bAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites_ ) ? "true" : "false" ) );
fprintf( pAO, "! in applyFilters. This will guarantee that we can find \n");
fprintf( pAO, "! deamination mutations.\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportDeaminationMutationsDeterminedByMoreAccurateMethod: %s\n",
( ( pCP->bAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod_ ) ? "true" : "false" ) );
fprintf( pAO, "! in checkTreesAndRecordDeaminationMutations\n");
fprintf( pAO, "! whether it uses PPan, GGor, and PPyg as well, or just human, PTro, and MMul\n");
fprintf( pAO, "! This helps for comparison with the whole genome analysis which just\n");
fprintf( pAO, "! had PTro, HSap, and MMul\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportChooseTreesUsingBadData: %s\n",
( ( pCP->bAutoReportChooseTreesUsingBadData_ ) ? "true" : "false" ) );
fprintf( pAO, "! in applyFilters\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportChooseTreesByCountingDeaminationMutations: %s\n",
( ( pCP->bAutoReportChooseTreesByCountingDeaminationMutations_ ) ? "true" : "false" ) );
fprintf( pAO, "! in applyFilters\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportChooseTreesUsingKimura: %s\n",
( ( pCP->bAutoReportChooseTreesUsingKimura_ ) ? "true" : "false" ) );
fprintf( pAO, "! in applyFilters\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintCrudeChimpHumanMutations: %s\n",
( ( pCP->bAutoReportPrintCrudeChimpHumanMutations_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintPositionsForGraham: %s\n",
( ( pCP->bAutoReportPrintPositionsForGraham_ ) ? "true" : "false" ) );
fprintf( pAO, "! used with printFlankedColumns4\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintAncestralCpGs: %s\n",
( ( pCP->bAutoReportPrintAncestralCpGs_ ) ? "true" : "false" ) );
fprintf( pAO, "! used with printFlankedColumns4\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintCpGMutations: %s\n",
( ( pCP->bAutoReportPrintCpGMutations_ ) ? "true" : "false" ) );
fprintf( pAO, "! used with printFlankedColumns4\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintMutationsWithContext: %s\n",
( ( pCP->bAutoReportPrintMutationsWithContext_ ) ? "true" : "false" ) );
fprintf( pAO, "! print columns that have mutations with flanking\n");
fprintf( pAO, "! columns that are conserved\n");
fprintf( pAO, "!(GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCountAllMutationsML: %s\n",
( ( pCP->bAutoReportCountAllMutationsML_ ) ? "true" : "false" ) );
fprintf( pAO, "! counts all types of mutations and uses trees\n");
fprintf( pAO, "! based on the probability of each tree\n");
fprintf( pAO, "!(GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCountAllMutations: %s\n",
( ( pCP->bAutoReportCountAllMutations_ ) ? "true" : "false" ) );
fprintf( pAO, "! counts deamination mutations in pairs of columns that\n");
fprintf( pAO, "! both pass filters.\n");
fprintf( pAO, "!(GREEN LAB)\n");
fprintf( pAO, "consed.autoReportIgnoreMultipleTrees: %s\n",
( ( pCP->bAutoReportIgnoreMultipleTrees_ ) ? "true" : "false" ) );
fprintf( pAO, "! used with\n");
fprintf( pAO, "! consed.autoReportCountAllMutations: false\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCountAcceptableColumnsWithNoneOnLeft: %s\n",
( ( pCP->bAutoReportCountAcceptableColumnsWithNoneOnLeft_ ) ? "true" : "false" ) );
fprintf( pAO, "! count columns that pass all filters, but column to left of it\n");
fprintf( pAO, "! doesn't pass all filters\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintFlankedColumns4: %s\n",
( ( pCP->bAutoReportPrintFlankedColumns4_ ) ? "true" : "false" ) );
fprintf( pAO, "! This differs from that below primarily in that it \n");
fprintf( pAO, "! identifies deamination mutationsx\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportUseAnnotationFormat: %s\n",
( ( pCP->bAutoReportUseAnnotationFormat_ ) ? "true" : "false" ) );
fprintf( pAO, "! Used with consed.autoReportPrintFlankedColumns4: \n");
fprintf( pAO, "! to print things out in a format that can be used for distinguishing\n");
fprintf( pAO, "! the clades\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintFlankedColumns3: %s\n",
( ( pCP->bAutoReportPrintFlankedColumns3_ ) ? "true" : "false" ) );
fprintf( pAO, "! This differs from that below primarily in that it \n");
fprintf( pAO, "! uses n instead of ? and prints trees\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintFlankedColumns2: %s\n",
( ( pCP->bAutoReportPrintFlankedColumns2_ ) ? "true" : "false" ) );
fprintf( pAO, "! This differs from that below primarily in that it \n");
fprintf( pAO, "! doesn't require all species, but rather\n");
fprintf( pAO, "! PPan | PTro && GGor && MMul | PPyg \n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintFlankedColumns: %s\n",
( ( pCP->bAutoReportPrintFlankedColumns_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportHighQualitySegmentData: %s\n",
( ( pCP->bAutoReportHighQualitySegmentData_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportGoodReadsBug: %s\n",
( ( pCP->bAutoReportGoodReadsBug_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportDiscrepancyRateInFlankedRegions: %s\n",
( ( pCP->bAutoReportDiscrepancyRateInFlankedRegions_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportDiscrepancyRateInFlankedRegions2: %s\n",
( ( pCP->bAutoReportDiscrepancyRateInFlankedRegions2_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportDiscrepancyRateInFlankedRegions4: %s\n",
( ( pCP->bAutoReportDiscrepancyRateInFlankedRegions4_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportDiscrepancyRateInFlankedRegions5: %s\n",
( ( pCP->bAutoReportDiscrepancyRateInFlankedRegions5_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportSingleSignalOrQuality: %s\n",
( ( pCP->bAutoReportSingleSignalOrQuality_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportLowQualityBasesInHQS: %s\n",
( ( pCP->bAutoReportLowQualityBasesInHQS_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCompareHQSWithLQS: %s\n",
( ( pCP->bAutoReportCompareHQSWithLQS_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCountColumnsForGroupsOfSpecies: %s\n",
( ( pCP->bAutoReportCountColumnsForGroupsOfSpecies_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportSingleSignalInfo: %s\n",
( ( pCP->bAutoReportSingleSignalInfo_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportSingleSignalInfo2: %s\n",
( ( pCP->bAutoReportSingleSignalInfo2_ ) ? "true" : "false" ) );
fprintf( pAO, "! Just used to print out the # of bases at each quality that are\n");
fprintf( pAO, "! single signal and the # that are multiple signal. For comparing\n");
fprintf( pAO, "! 2004 reads with 2005 reads\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCompareTopAndBottomStrands: %s\n",
( ( pCP->bAutoReportCompareTopAndBottomStrands_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCompareTopAndBottomStrandsNoHuman: %s\n",
( ( pCP->bAutoReportCompareTopAndBottomStrandsNoHuman_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCompareTopAndBottomStrands2: %s\n",
( ( pCP->bAutoReportCompareTopAndBottomStrands2_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCompareTopAndBottomStrands3: %s\n",
( ( pCP->bAutoReportCompareTopAndBottomStrands3_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCompareTopAndBottomStrands4: %s\n",
( ( pCP->bAutoReportCompareTopAndBottomStrands4_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportTopStrandPinnedPosition: %d\n",
pCP->nAutoReportTopStrandPinnedPosition_ );
fprintf( pAO, "! for use with consed.autoReportCompareTopAndBottomStrands\n");
fprintf( pAO, "! given in unpadded read pos in direction of sequencing\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportBottomStrandPinnedPosition: %d\n",
pCP->nAutoReportBottomStrandPinnedPosition_ );
fprintf( pAO, "! for use with consed.autoReportCompareTopAndBottomStrands\n");
fprintf( pAO, "! given in unpadded read pos in direction of sequencing\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCompareTopAndBottomStrandsWithHuman: %s\n",
( ( pCP->bAutoReportCompareTopAndBottomStrandsWithHuman_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintLengthsOfAlignedSegmentsOfReads: %s\n",
( ( pCP->bAutoReportPrintLengthsOfAlignedSegmentsOfReads_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads: %s\n",
( ( pCP->bAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintIfReadsAreCorrectlyAligned: %s\n",
( ( pCP->bAutoReportPrintIfReadsAreCorrectlyAligned_ ) ? "true" : "false" ) );
fprintf( pAO, "! make sure that .f reads are top strand and .r reads are bottom\n");
fprintf( pAO, "! strand (Note: this only is true in some projects.)\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportCalculateErrorProbabilitiesByComparingPTroPPan: %s\n",
( ( pCP->bAutoReportCalculateErrorProbabilitiesByComparingPTroPPan_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies: %s\n",
( ( pCP->bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies2: %s\n",
( ( pCP->bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2_ ) ? "true" : "false" ) );
fprintf( pAO, "! differs from above in that one or the other of the species bases\n");
fprintf( pAO, "! must be at least quality 45\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportFilterSingleSignal: %s\n",
( ( pCP->bAutoReportFilterSingleSignal_ ) ? "true" : "false" ) );
fprintf( pAO, "! Green 2004 data should not be filtered for single signal\n");
fprintf( pAO, "! Green 2005 data should be\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportGoodHitReads: %s\n",
(char*)pCP->filAutoReportGoodHitReads_.data() );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportQualityWindowLow: %d\n",
pCP->nAutoReportQualityWindowLow_ );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportQualityWindowHigh: %d\n",
pCP->nAutoReportQualityWindowHigh_ );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintNumberOfIsolatedPadsForEachSpecies: %s\n",
( ( pCP->bAutoReportPrintNumberOfIsolatedPadsForEachSpecies_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintNumberOfIsolatedPads: %s\n",
( ( pCP->bAutoReportPrintNumberOfIsolatedPads_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportIsolatedPadsOfReadsWithThisPattern: %s\n",
(char*)pCP->soAutoReportIsolatedPadsOfReadsWithThisPattern_.data() );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy: %d\n",
pCP->nAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_ );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportMaxSizeOfDiscrepantRegion: %d\n",
pCP->nAutoReportMaxSizeOfDiscrepantRegion_ );
fprintf( pAO, "! used for printing bases of a discrepant region\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportSizeOfDiscrepantRegion: %d\n",
pCP->nAutoReportSizeOfDiscrepantRegion_ );
fprintf( pAO, "! size of region between the flanking agreeing region\n");
fprintf( pAO, "! duplicates parameter above\n");
fprintf( pAO, "! (GREEN LAB) \n");
fprintf( pAO, "consed.autoReportPrintMinimumQualityHistogram: %s\n",
( ( pCP->bAutoReportPrintMinimumQualityHistogram_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintDiscrepantRegions: %s\n",
( ( pCP->bAutoReportPrintDiscrepantRegions_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintBasesInDiscrepantRegions: %s\n",
( ( pCP->bAutoReportPrintBasesInDiscrepantRegions_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis: %s\n",
(char*)pCP->soAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_.data() );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportBackboneReadHasThisStringInIt: %s\n",
(char*)pCP->soAutoReportBackboneReadHasThisStringInIt_.data() );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold: %s\n",
( ( pCP->bAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold_ ) ? "true" : "false" ) );
fprintf( pAO, "! if true, \n");
fprintf( pAO, "! uses consed.qualityThresholdForFindingHighQualityDiscrepancies \n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintSpeciesAlignment: %s\n",
( ( pCP->bAutoReportPrintSpeciesAlignment_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintReadAlignment: %s\n",
( ( pCP->bAutoReportPrintReadAlignment_ ) ? "true" : "false" ) );
fprintf( pAO, "! This differs from consed.autoReportPrintSpeciesAlignment in that\n");
fprintf( pAO, "! reads that are for the same species are not combined. (This may be\n");
fprintf( pAO, "! useful for labs other than the Green Lab.)\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintTheseReads: %s\n",
(char*)pCP->filAutoReportPrintTheseReads_.data() );
fprintf( pAO, "! for consed.autoReportPrintReadAlignment\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintReadPositions: %s\n",
( ( pCP->bAutoReportPrintReadPositions_ ) ? "true" : "false" ) );
fprintf( pAO, "! use with consed.autoReportPrintSpeciesAlignment:\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrintChosenReadName: %s\n",
( ( pCP->bAutoReportPrintChosenReadName_ ) ? "true" : "false" ) );
fprintf( pAO, "! use with consed.autoReportPrintSpeciesAlignment:\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportNumbersOfCharactersOfChosenReadNameToBePrinted: %d\n",
pCP->nAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_ );
fprintf( pAO, "! if the read name is larger than this, will print this number \n");
fprintf( pAO, "! of characters at the end of the name. If the read name is shorter,\n");
fprintf( pAO, "! will just print the read name.\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportPrefix: %s\n",
(char*)pCP->soAutoReportPrefix_.data() );
fprintf( pAO, "! normally this will be the chromosome #\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportUseOldCriteriaForDeletingColumnsOfPads: %s\n",
( ( pCP->bAutoReportUseOldCriteriaForDeletingColumnsOfPads_ ) ? "true" : "false" ) );
fprintf( pAO, "! I think:\n");
fprintf( pAO, "! old: delete column of pads unless there is a certain non-pad (single\n");
fprintf( pAO, "! signal, high quality, hqs, good hit read), aggressive method\n");
fprintf( pAO, "! new: delete column of pads only if all combined reads are certain\n");
fprintf( pAO, "! pads (high quality, high quality segment, single signal, good hit)\n");
fprintf( pAO, "! conservative method\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues: %s\n",
( ( pCP->bAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportFlankingBasesMustBeSingleSignal: %s\n",
( ( pCP->bAutoReportFlankingBasesMustBeSingleSignal_ ) ? "true" : "false" ) );
fprintf( pAO, "! for use with consed.autoReportPrintMutationsWithContext:\n");
fprintf( pAO, "! and others\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportMinimumQualityOfFlankingBases: %d\n",
pCP->nAutoReportMinimumQualityOfFlankingBases_ );
fprintf( pAO, "! for use with consed.autoReportPrintMutationsWithContext:\n");
fprintf( pAO, "! and others\n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportFlankingBasesMustBeInHighQualitySegment: %s\n",
( ( pCP->bAutoReportFlankingBasesMustBeInHighQualitySegment_ ) ? "true" : "false" ) );
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed.autoReportSpecies: %s\n",
(char*)pCP->soAutoReportSpecies_.data() );
fprintf( pAO, "! These must match primateSpecies.h constants \n");
fprintf( pAO, "! nPPan, nPTro, nGGor, nPPyg, and nMMul \n");
fprintf( pAO, "! (GREEN LAB)\n");
fprintf( pAO, "consed will use the following instead of consed.autoFinishMinNumberOfErrorsFixedByAnExp: %.3f\n",
pCP->dAutoFinishMinNumberOfErrorsFixedByAnExpToUse_ );
fprintf( pAO, "}\n(END OF PARAMETERS)\n\n" );
}