/***************************************************************************** # 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 #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" ); }