/***************************************************************************** # 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. # #*****************************************************************************/ #ifndef CONSEDPARAMETERS_INCLUDED #define CONSEDPARAMETERS_INCLUDED #include "rwcstring.h" #include "rwtvalorderedvector.h" #include "sysdepend.h" #include "filename.h" #include "consedResources.h" #include using namespace std; #include "mbtPtrOrderedVector.h" #include "restrictionEnzyme.h" #include "assemblyViewTagTypeAndLine.h" #include "mbtValOrderedVectorOfRWCString.h" #include #include "whatIsRunning.h" class pickPCRPrimers; class library; class listOfLibraries; static const int nDontShowProteinTranslation = 0; static const int nShowProteinTranslationTopStrand = 1; static const int nShowProteinTranslationBottomStrand = -1; // static const int nAutofinishIsRunning = 1; // static const int nConsedIsRunning = 2; // static const int nAddReadsToAceFileIsRunning = 3; // static const int nAutoPCRAmplifyIsRunning = 4; // static const int nAutoEditIsRunning = 5; // static const int nAutoReportIsRunning = 6; // static const int nPrintSingleSignalIsRunning = 7; // static const int nAddReadsWithExistingAlignmentsIsRunning = 8; #define pCP consedParameters::pGetConsedParameters() class consedParameters { public: consedParameters( consedResources* pRes ); // this member function provides read access to the // sole instance // this is used just to get a bunch of space to save and // retrieve saved parameters consedParameters(); static consedParameters* pGetConsedParameters() { return pGlobalConsedParameters_; } void processDoNotFinishTagTypes(); void processDoNotExtendTagTypes(); void postProcessing(); void postProcessingAfterTagTypes(); RWCString soGetDocumentation(); void setDocumentation(); void setParametersForSequencingPrimersNotPCRPrimers( const bool bSequencingNotPCR ); void copyPrimerPickingParametersToSelf( consedParameters* pCPSource ); void makeListOfRestrictionEnzymes(); void readFileToOrderReadsInAlignedReadsWindow(); // data members that are not resources or not standard resources public: RWCString soCommandLine_; bool bWarnUserAboutOverstrikingWithUppercase_; bool bErrorMessageDisplayedAtStartup_; int nAutoFinishLastUsedPrimerNumber_; bool bOKToUseGui_; int nWhatIsRunning_; bool bReadOnly_; bool bCreateSocketToControlConsed_; int nCreateSocketToControlConsedOnThisLocalPort_; int nSocketToControlConsed_; int nSocketSuccessfullyCreatedOnThisLocalPort_; int nShowProteinTranslation_; // top strand, bottom strand, or not at all int nAutoFinishNumberOfCloningSitesFound_; RWCString soSavedReadListOptions_; bool bWillDoExperiments_; int nLastUsedExpID_; int nAutoFinishForwardReverseCalculatedAverageInsertSize_; int nAutoFinishAverageInsertSizeToUse_; int nPrimersALittleLessThanAverageInsertSizeOfASubcloneToUse_; RWTValOrderedVector aAutoFinishTagsToNotFinish_; RWTValOrderedVector aAutoFinishTagsToNotExtend_; FileName filAutoFinishFilenamesFile_; FileName filAutoFinishReversesSummary_; FileName filAutoFinishForwardsSummary_; FileName filAutoFinishCustomPrimersSummary_; FileName filAutoFinishSortedSummary_; FileName filAutoFinishFullOutput_; FileName filAutoFinishCustomNavigation_; FileName filAutoFinishMinilibrariesSummary_; FILE* pAutoFinishFilenamesFile_; FILE* pAutoFinishReversesSummary_; FILE* pAutoFinishForwardsSummary_; FILE* pAutoFinishCustomPrimersSummary_; FILE* pAutoFinishSortedSummary_; // why do I have both of the below? One is pAO and the other pFILE // pFILE is set to stdout for consed and thus the same code can be // used for both consed and autoEdit, autofinish, etc. I still don't // understand, however, why both are needed. (DG, 11/2002) FILE* pAutoFinishFullOutput_; FILE* pOutputForConsedOrAutoFinish_; FILE* pAutoFinishCustomNavigation_; FILE* pAutoFinishMinilibrariesSummary_; RWCString soDocumentation_; double dAutoFinishMinNumberOfErrorsFixedByAnExpToUse_; FileName filFileOfPhdFiles_; // this is for -fileOfPhdFiles command line argument FileName filNewFileOfPhdFilesFullPath_; FileName filFileOfPhdFilesCurrentlyBeingRead_; bool bTerminateAfterStartup_; RWTValOrderedVector aUserDefinedKeys_; RWTValOrderedVector aProgramsForUserDefinedKeys_; RWTValOrderedVector aArgumentsToPassToUserDefinedPrograms_; RWTValOrderedVector aTagsToApplyWithUserDefinedKeys_; pickPCRPrimers* pPickPCRPrimers_; bool bReadyToPickSecondPCRPrimer_; int nPrimersMinimumLengthOfAPrimerToUse_; int nPrimersMaximumLengthOfAPrimerToUse_; int nPrimersMinMeltingTempToUse_; int nPrimersMaxMeltingTempToUse_; int nPrimersWindowSizeInLookingToUse_; int nPrimersMaxMatchElsewhereScoreToUse_; library* pDefaultLibrary_; listOfLibraries* pListOfLibraries_; int nPhdFilesRead_; mbtPtrOrderedVector aRestrictionEnzymes_; RWTValOrderedVector aCommonRestrictionEnzymes_; bool bNeedToSetContigTemplateArrays_; char cFindRestrictionEnzymeSitesLastUsedWholeCloneOrPartOfCloneOrWholeContig_; RWCString soFindRestrictionEnzymeSitesLastUsedUserEnteredContigMap_; int nFindRestrictionEnzymeSitesLastUsedStartUnpaddedConsPos_; int nFindRestrictionEnzymeSitesLastUsedEndUnpaddedConsPos_; RWCString soFindRestrictionEnzymeSitesLastUsedContigAbbreviatedName_; enum { cDELETE_READS = 'd', cPUT_EACH_READ_IN_ITS_OWN_CONTIG = 'p' }; char cRemoveReadsLastUsedDeleteOrJustPutInOwnContig_; RWTValOrderedVector aListOfContigNamesForMiniassembly_; bool bWarnUserAboutAmbiguityCodes_; FILE* pDebugFile_; mbtPtrOrderedVector aAssemblyViewDisplayTheseTagTypes_; RWCString soAssemblyViewContigsToShow_; RWTPtrOrderedVector aShowReadsInAlignedReadsWindowOrderGivenByFile_; mbtValOrderedVectorOfRWCString aAutoReportPatternsOfReadsToIgnore_; bool bAllowTimestampMismatch_; time_t myTime_; int nNumberOfStartupErrors_; bool bLimitNumberOfErrorsReported_; bool bPrintInFigureOutContigOrderAndOrientation_; RWCString soDateTimeDotInMiddle_; // data members that are also resources: public: // In the following, I have annotated the parameters with the following // symbols: // // (YES) freely customize to your own site // (OK) don't change unless you have a specific need and know what you // are doing // (NO) don't change this! // (GREEN LAB) Resources here are just those for Green Lab research and have // no effect on any Consed/Autofinish/AutoReport functions // // // parameters in the (YES) category: // bool bPrintPS_; // print memory // (YES) RWCString soDefaultTagType_; // when swiping the consensus in the Aligned Reads Window to create a // tag, what is the default tag type to be added? // (YES) bool bDefaultTagOnConsensusNotReads_; // when swiping the consensus in the Aligned Reads Window to create a // tag, by default will the consensus be tagged or the reads be tagged? // (YES) double dAutoFinishMinNumberOfErrorsFixedByAnExp_; // if an experiment solves fewer errors than this, it isn't worth doing // so won't be chosen. This parameter controls when Autofinish stops // choosing experiments. // (YES) double dAutoFinishRedundancy_; // This number should be between 1.0 and 2.0 If you want more reads // for each area, increase the number towards 2.0 If you want fewer // reads per area, decrease it towards 1.0. This only affects // universal primer reads--not custom primer reads. // // (YES) int nAutoFinishAverageInsertSize_; // If a template has a forward but no reverse, when deciding whether to // allow this template for a particular primer or reverse, we need to // make an assumption of where is the end of the template. If we have // do not have enough forward/reverse pairs to determine the mean, then // this parameter is used. // (YES) int nPrimersMaxInsertSizeOfASubclone_; // for checking for false-annealing // check +/- this distance from the primer for false-annealing // and check at most this distance for templates for a primer. // Thus if you have more than one library, make this the max of // all libraries. // (YES) int nPrimersMaxMeltingTemp_; // (YES) int nPrimersMaxMeltingTempForPCR_; // Note: the difference between consed.primersMaxMeltingTempForPCR and // consed.primersMinMeltingTempForPCR must be less than or equal to // consed.primersMaxMeltingTempDifferenceForPCR // Otherwise, autofinish may take forever to pick pcr primers. // (YES) bool bPrimersPickTemplatesForPrimers_; // when picking primers for subclone templates, pick templates also. // If there is no suitable template for a primer, do not pick the // primer. If you like to pick your own templates, you might want to // turn this off for a little improvement in speed. // This has no effect on Autofinish--just on interactive primer picking // in Consed. // (YES) RWCString soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_; // vector sequence file if choosing subclone (e.g., M13, plasmid) // templates // (YES) RWCString soPrimersCloneFullPathnameOfFileOfSequencesForScreening_; // vector sequence file if choosing clone (e.g., cosmid, BAC) template // (YES) int nPrimersMinMeltingTemp_; // (YES) int nPrimersMinMeltingTempForPCR_; // (YES) bool bSearchFunctionsUseUnalignedEndsOfReads_; // when navigating by // searchForSingleSubcloneRegions and searchForSingleStrandedRegions, // and the read below has both aligned and unaligned portions, which // bases of the read are considered to cover the region: // uuuuuuuAAAAAAAAAAAAAAAAAAAAAAAAAuuuuuuuu // <--------- if "true" ------------------> // <-----if "false"--------> // where u means an unaligned base and A means an aligned base // (YES) bool bSearchFunctionsUseLowQualityEndsOfReads_; // when navigating by // searchForSingleSubcloneRegions and searchForSingleStrandedRegions, // and the read below has both low quality and high quality portions, // which portions of the read are considered to cover the region: // lllllllAAAAAAAAAAAAAAAAAAAAAAAAAllllllll // <--------- if "true" ------------------> // <-----if "false"--------> // where l means a low quality base and A means a high quality base // (YES) int nInexactSearchForStringMaxPerCentMismatch_; // when using the inexact search for string, allow up to this // % mismatch: the sum of the insertion, deletion, and substitution // differences divided by the length of the query string // (YES) bool bOnlyAllowOneReadWriteConsedAtATime_; // if there is another read-write consed (or Autofinish) process running in the // same directory, and this consed (or Autofinish) is not read-only, // then terminate with an error message // (YES) bool bAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair_; // otherwise, a single serious hqd will cause the template to be rejected. // (YES) RWCString soPrintWindowCommand_; // system command to print out a Consed Window // (YES) FileName filFileOfTagTypes_; // pathname of a file with the following format: // (tag name) (color for displaying) (consensus or read or both) (yes/no) // where "consensus" or "read" or "both" indicates whether the tag // is available for the user to add to the consensus, to reads, or to // both, and "yes" or "no" indicates whether the tag can be created // in Consed by swiping, or whether it only can be created by an // external program and displayed by Consed. // (YES) bool bAssemblyViewShowConsistentFwdRevPairs_; // too many squares! See assemblyViewShowConsistentFwdRevPairDepth // (YES) bool bAssemblyViewShowConsistentFwdRevPairDepth_; // This actually shows more information than // assemblyViewShowConsistentFwdRevPairs and is much easier to read // (YES) bool bAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds_; // Lone links from the end of one contig to the end of another, but not // confirmed by another in order to make the contigs joined into a scaffold. // (YES) bool bAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs_; // This is even more cluttered than assemblyViewShowConsistentFwdRevPairs // (YES) bool bAssemblyViewShowGapSpanningFwdRevPairs_; // This shows gap-spanning fwd/rev pairs that caused the contigs to // be joined into a scaffold. // (YES) RWCString soAssemblyViewShowWhichInconsistentFwdRevPairs_; // choices are: filtered, none, all // "filtered" means that an inconsistent fwd/rev pair is only shown // if it is confirmed by another inconsistent fwd/rev pair // If all, full of red lines. If filtered, then only red lines that are // confirmed by other red lines are shown. // (YES) bool bAssemblyViewShowReadDepth_; // If true, read depth is shown in assemblyView // (YES) bool bAssemblyViewShowMultipleHighQualityDiscrepancies_; // If true, multiple high quality discrepancies (both indel and // non-indel type) are shown in assemblyView // (YES) bool bAssemblyViewShowRestrictionDigestCutSites_; // If true, and you open a Digest Window in Consed and you open // the Assembly View window in Consed, the restriction digest cut // sites will be shown in Assembly View (in addition to showing them in // the Digest Window) // (YES) bool bAssemblyViewFilterSequenceMatchesBySize_; // only show sequence matches if they fall between // consed.assemblyViewSequenceMatchesMinSize and // consed.assemblyViewSequenceMatchesMaxSize // (YES) int nAssemblyViewSequenceMatchesMinSize_; // if consed.assemblyViewFilterSequenceMatchesBySize is true, // then only show sequence matches that are larger than this // (YES) int nAssemblyViewSequenceMatchesMaxSize_; // if consed.assemblyViewFilterSequenceMatchesBySize is true, // then only show sequence matches that are smaller than this // (YES) bool bAssemblyViewAutomaticallyStartWithConsed_; // when consed starts, start assembly view. This only works if you // specify the ace file on the command line. // (YES) RWCString soAssemblyViewDisplayTheseTagTypesOnTheseLines_; // space-separated list of form: // (tagtype) (line number) (tagtype) (line number) // where line number is where in Assembly View the tag will be displayed // (YES) bool bAssemblyViewShowTags_; // If true, and some tag types are selected, these tags // will be shown in assemblyView. If false, no tags // will be shown in assemblyView. // (YES) bool bAutoEditRecalculateHighQualitySegmentsOfReads_; // If true, will recalculate the high quality segments of the reads // (YES) bool bAutoEditConvertCloneEndBasesToXs_; // If true, will convert to X's bases of all reads that protrude beyond a // cloneEnd tag. // (YES) bool bAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads_; // This will find all locations where there are multiple identical // discrepancies with the consensus (and some other conditions) and try // to make most of the reads quality 99 at that location so that phrap, // next time it is run, will not overlap those reads. This will fix // many misassemblies. // (YES) bool bAutoEditTagEditableLowConsensusQualityRegions_; // This will find regions that are low quality, but that a human // finisher could easily determine the correct base and thus // money could be saved by not having Autofinish suggest additional // reads overlapping the region // (YES) bool bAutoEditMakeFakeRead_; // takes a list of reads and makes a false read that consists of the // combination of those reads (using the consensus to fill in between // them) // (YES) RWCString soAutoEditMakeFakeReadFromRead1_; // read 1 from which to make the fake read RWCString soAutoEditMakeFakeReadFromRead2_; // read 2 from which to make the fake read RWCString soAutoEditMakeFakeReadName_; // name of fake read FileName filAutoEditMakeFakeReadFastaFilename_; // name of fasta file to put the read into bool bAutoEditMergeAssembly_; // This is used to take 2 assemblies (each with a single contig) that // have a read in common and merge them into a single assembly with a // single contig as follows: It reads consed.autoEditSecondaryAceFile // into a secondary assembly and finds read // consed.autoEditMakeFakeReadName within that secondary assembly as well // as within the primary assembly. It assumes that these reads have the // same unpadded bases (although they may have different pads). It // equalizes the pads, and then moves the other reads (which are // typically the fwd/rev pair of reads) from the secondary assembly into // the primary assembly. It then deletes the secondary assembly and // deletes consed.autoEditMakeFakeReadName from the primary assembly. // (YES) FileName filAutoEditSecondaryAceFile_; // ace file of the fake read and the forward/reverse pair bool bAutoEditFixRunsInConsensus_; // fixes this: // ccc (cons) // cc* (read1) // *cc (read2) // (YES) bool bShowAllTracesJustShowGoodTraces_; // Just show traces where there is a base at the cursor and // there is trace signal at the cursor and where // there is no "dataNeeded" tag at the cursor as specified by // consed.showAllTracesDoNotShowTraceIfTheseTagsPresent // (YES) int nAddAlignedSequenceQualityOfBases_; // when running consed -addAlignedSequence, what quality should the // bases be? // (YES) bool bMakeLightBackgroundInAlignedReadsWindowAndTracesWindow_; // for printing screens, saves toner // (YES) bool bPutVerticalLineAtCursor_; // for very high depth of coverage regions, a line helps your eye see // follow the column // (YES) bool bPutHorizontalLineAtCursor_; // for very wide monitors, helps to follow a read with your eye // (YES) FileName filHighlightedReadsFile_; // The user can use the "Misc/save highlighted reads to file" function // to save highlighted read names to this file. // (YES) // // // parameters in the (OK) category: // // // bool bAutoReportPrintReadNamesInRegion_; //(OK) RWCString soAutoReportPrintReadNamesInRegionContig_; //(OK) int nAutoReportPrintReadNamesInRegionLeftPos_; //(OK) int nAutoReportPrintReadNamesInRegionRightPos_; //(OK) bool bAutoReportPrintHighlyDiscrepantRegions_; // motivated by solexa reads. Print where many reads disagree with // reference sequence // uses: // consed.qualityThresholdForFindingHighQualityDiscrepancies // ignores bases lower than this // consed.navigateByHighlyDiscrepantPositionsMinDiscrepantReads // consed.navigateByHighlyDiscrepantPositionsMaxDepthOfCoverage // consed.navigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality // consed.navigateByHighlyDiscrepantPositionsJustListIndels // consed.navigateByHighlyDiscrepantPositionsIgnoreIfNOrXInConsensus: false // (OK) bool bAutoReportPrintScaffolds_; // (OK) bool bNumberUnpaddedConsensusAtUserDefined_; // allow user to put a tag on the consensus to specify the number to // start numbering the consensus. // Must use tag consed.tagColorStartNumberingConsensus as the // tag with the number in it. // (OK) bool bAutoReportPrintHighQualityDiscrepancies_; // (OK) bool bAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags_; // used in connection with consed.autoReportPrintHighQualityDiscrepancies // (OK) bool bAutoReportHighQualityDiscrepanciesExcludeMostPads_; // used in connection with consed.autoReportPrintHighQualityDiscrepancies // Excludes high quality discrepancy pads except those in cases such as this: // consensus aa // read 1 *a // read 2 *a // read 3 a* // read 4 a* // (OK) bool bAutoReportPrintLowConsensusQualityRegions_; // (OK) bool bAutoReportPrintSingleSubcloneRegions_; // (OK) bool bAutoReportPrintSingleStrandedRegions_; // (OK) bool bAutoReportPrintLinkingForwardReversePairs_; // (OK) bool bAutoReportPrintFilteredInconsistentForwardReversePairs_; // (OK) bool bAutoReportPrintAssemblySummary_; // (OK) RWCString soShowAllTracesDoNotShowTraceIfTheseTagsPresent_; // See consed.showAllTracesJustShowGoodTraces // (OK) bool bNameOfFakeJoiningReadsIncludesAceFileName_; // This is useful if the user is going to combine the reads // from a number of different ace files together. // (OK) int nWhenUserScrollsOffWindowMillisecondsBetweenScrolling_; // (OK) int nWhenUserScrollsOffWindowBasesToScrollEachTime_; // (OK) bool bCompareContigsUseBandedRatherThanFullSmithWaterman_; // (OK) int nCompareContigsBandSize_; // band size of banded Smith Waterman // (OK) int nAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany_; // (OK) bool bAssemblyViewShowSequenceMatches_; // When false, do not show any sequence matches (repeats) // at all in Assembly View. // Some people like to start out this way since displaying sequence // matches slows down scrolling. // (OK) bool bAssemblyViewOKToShowSequenceMatchesBetweenContigs_; // (OK) bool bAssemblyViewOKToShowSequenceMatchesWithinContigs_; // (OK) bool bAssemblyViewOKToShowDirectSequenceMatches_; // This means in which neither copy must be complemented with respect // to the way it is in the scaffold as created by Consed. // (OK) bool bAssemblyViewOKToShowInvertedSequenceMatches_; // This means that exactly one copy must be complemented with respect // to the way it is in the scaffold as created by Consed. // (OK) bool bAssemblyViewOnlyShowSequenceMatchesToAParticularRegion_; // You must set consed.assemblyViewOnlyShowSequencematchesToThisContig // consed.assemblyViewOnlyShowSequenceMatchesToThisRegionLeft // consed.assemblyViewOnlyShowSequenceMatchesToThisRegionRight // (OK) RWCString soAssemblyViewOnlyShowSequenceMatchesToThisContig_; // You must make // consed.assemblyViewOnlyShowSequenceMatchesToAParticularRegion: true // (OK) int nAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft_; // consed.assemblyViewOnlyShowSequenceMatchesToAParticularRegion: true // (OK) int nAssemblyViewOnlyShowSequenceMatchesToThisRegionRight_; // consed.assemblyViewOnlyShowSequenceMatchesToAParticularRegion: true // (OK) bool bAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs_; // (OK) int nAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar_; // This many base pairs from the end of the contig. // (OK) RWCString soDefaultReadPrefix_; // This is used as the character to prefix reads with when the // read is in consed.readPrefixesFile and the prefix is not specified. // (OK) FileName filReadPrefixesFile_; // This file should contain a list of reads that you would want to // have prefixes in the Aligned Reads Window. Each line should // have the following format: // (read name) (prefix) (color) // The prefix and color are optional. You can have a line like this: // (read name) (prefix) // or this: // (read name) // but not this: // (read name) (color) // If the color is not specified, the color will default to // consed.colorReadPrefixes: blue // If the prefix is not specified, it will default to // (OK) int nMaxCharsDisplayedForReadPrefix_; // It is still ok to have long read prefixes in the file // consed.readPrefixesFile but only this many characters // will be displayed in the Aligned Reads window // (OK) int nAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_; // (OK) int nAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_; // \"unoriented\" pcr reactions means cases in which autofinish is suggesting // a pcr reaction to span a gap, but it doesn't know whether the 2 contig ends // really go together since there are not enough (or no)templates that span // that gap // (OK) int nAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_; // Gap size can be specified in user-defined contigEndPair tags in a // gap_size: field // If the gap size is greater than this number, do not do PCR. // (OK) bool bAutoFinishDoNotDoPCRIfEndIsExtendedByReads_; // If this is true, and autofinish was able to walk off the end of a // contig, do not do PCR with that end of the contig. // // (OK) int nAutoFinishMaxAcceptableErrorsPerMegabase_; // target error rate. This parameter used to be the one that stopped // Autofinish from calling more reads. However, consider a BAC that is // nearly perfect except for one region with 3 quality 10 bases in a // row. In this case the global errors per megabase is very // low--perhaps lower than 1 error per megabase. Despite this, most // labs would like to do one more read to fix this problem. Thus we // set this parameter to zero (to disable it) so Autofinish will use // the parameter consed.autoFinishMinNumberOfErrorsFixedByAnExp to stop // calling more reads--it is a local error rate. // (OK) int nAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_; // If a template has a forward but no reverse, when deciding whether to // allow this template for a particular primer, we need to make an assumption // of where is the end of the template. If the template comes from a library // with insert size 1500, it would be reasonable to assume that the end of // template will be 1500 bases from the forward read. But if this template // has an insert that is shorter than average, the walk may walk into vector. // To be conservative, we may want to assume that the insert is somewhat // shorter than average. By default, we assume that it is 90% as large as // the average. This parameter gives that percentage. This parameter // is used both by Consed and Autofinish. // (OK) int nPrimersNumberOfBasesToBackUpToStartLooking_; // e.g., if this is 50 and you want a read at position 1000, primers // will be searched before base 950 but not in the region 950 to 1000 // This has no effect on Autofinish--just on interactively picking primers. // (OK) int nPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_; // When a PCR product is made, you want it to overlap by this many bases // the high quality part of the existing consensus. Thus choose PCR // primers this many bases back (or more) // (OK) bool bPrimersOKToChoosePrimersInSingleSubcloneRegion_; // (OK) bool bPrimersOKToChoosePrimersWhereHighQualityDiscrepancies_; // (OK) bool bPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion_; // (OK) bool bAutoFinishCallReversesToFlankGaps_; // if there is a forward-reverse pair flanking a gap, print it out // if there is not, suggest reverses to flank the gap // (OK) bool bAutoFinishAllowWholeCloneReads_; // ok to call reads whose template for sequencing reaction is the // entire clone (BAC or cosmid) // (OK) bool bAutoFinishAllowCustomPrimerSubcloneReads_; // ok to call reads with custom primers and subclone template // (OK) bool bAutoFinishAllowResequencingReads_; // This is just universal primer reads to be resequenced using // dye terminator chemistry or special chemistry. (It does not // mean resequencing a custom primer read.) // (OK) bool bAutoFinishAllowResequencingReadsOnlyForRunsAndStops_; // This parameter only has any effect when // consed.autoFinishAllowResequencingReads is set to true. In that // case no resequencing reads will be suggested, unless it is to cross // a run or stop and special chemistry is suggested. // (OK) bool bAutoFinishAllowDeNovoUniversalPrimerSubcloneReads_; // Allows calling reverse when there is just a forward. // Allows calling a forward when there is just a reverse. // (OK) bool bAutoFinishAllowMinilibraries_; // Allows calling minilibraries (shatter libraries or transposon // libraries) of subclone templates for closing gaps // (OK) bool bAutoFinishAllowPCR_; // Allows calling PCR for closing gaps, but only as a last resort // (OK) bool bAutoFinishAllowUnorientedPCRReactions_; // Allows calling PCR amongst contig-ends that have insufficient // fwd/rev pair linkage to any other contig-end. Thus it suggests // pcr amongst all such contig-ends. // To allow this type of pcr, you must also make: // consed.autoFinishAllowPCRForUnorientedContigEnds: true // See also: // consed.autoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions: // which gives you finer control over unoriented pcr. // (OK) bool bAutoFinishAllowResequencingAUniversalPrimerAutofinishRead_; // if Autofinish suggests a de novo universal primer read, // do not allow Autofinish to suggest a resequence of this read // (OK) bool bAutoFinishAlwaysCloseGapsUsingMinilibraries_; // \"Minilibraries\" includes transposing a subclone template or // making a shatter library from a subclone template // (OK) int nAutoFinishMaximumFinishingReadLength_; // Change this only if your finishing reads are typically shorter // than your shotgun reads. Otherwise, leave it unrealistically long, // and Autofinish will set its model read based on your existing // shotgun reads. // (OK) int nAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_; // (OK) bool bAutoFinishSuggestSpecialChemistryForRunsAndStops_; // Suggest special chemistry such as dGTP for reads that cross // mononucleotide or dinucleotide repeats that cause reads to fail or // stops (structure) that cause reads to fail and thus dye terminator // reads won't work. // (OK) int nAutoFinishSuggestThisManyMinilibrariesPerGap_; // (OK) int nPrimersWindowSizeInLooking_; // e.g., if this is 300, with example above, primers will be searched // from base 650 to 950. This has no effect on Autofinish--it is just // used for interactive primer picking in Consed. // (OK) bool bPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified_; // you can put the template type in the phd file in a WR template item // consed will have a list of these and know which are single and // double stranded // (OK) int nAlignedReadsWindowInitialCharsWide_; // initial width of the aligned reads window including the read name and // the bases // (OK) int nAlignedReadsWindowInitialCharsHigh_; // initial height of the aligned reads window area where the consensus // and reads are // (OK) int nAlignedReadsWindowMaxCharsForReadNames_; // how many columns are reserved for read names // (OK) bool bAlignedReadsWindowAutomaticallyExpandRoomForReadNames_; // If true, expand and contract space for read names, but don't // contract less than consed.alignedReadsWindowMaxCharsForReadNames. // If false, then always use // consed.alignedReadsWindowMaxCharsForReadNames // for space reserved for read names. // (OK) bool bAutoFinishAllowResequencingReadsToExtendContigs_; // if false, a resequencing read is not called to extend a contig--only // custom primer reads and de novo universal primer reads are called // for this purpose. // (OK) int nAutoFinishCallHowManyReversesToFlankGaps_; // This has two purposes: 1) it specifies how many forward/reverse // pairs should be present for Consed/Autofinish to be certain of the // order/ orientation of two contigs. If there are this many fwd/rev // pairs flanking a gap, Autofinish will print out the contig ends that // flank the gap. 2) If consed.autoFinishCallReversesToFlankGaps is // set to true, and there are less than this many fwd/rev pairs // flanking a gap, Autofinish will suggest additional reverses until // there are this many. // (OK) bool bAutoFinishCloseGaps_; // this allows you to turn off choosing reads to close gaps // (OK) bool bAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense_; // this allows you to override the checks that autofinish makes on the // read info, such as checking there are not more than 5 or so reads // from the same subclone template // (OK) double dAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_; // compares universal primer subclone reaction, custom primer subclone // reaction, and custom primer clone reaction to decide which to favor // (OK) double dAutoFinishCostOfCustomPrimerSubcloneReaction_; // see above // (OK) double dAutoFinishCostOfCustomPrimerCloneReaction_; // see above // (OK) double dAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_; // cost of reverse where there is only a forward or cost of forward // when there is only a reverse // (OK) double dAutoFinishCostOfMinilibrary_; // cost of making a minilibrary (transposon library or shatter library) // from a subclone template // (OK) bool bAutoFinishCoverSingleSubcloneRegions_; // this allows you to turn off choosing reads to cover single subclone regions // (OK) bool bAutoFinishCoverLowConsensusQualityRegions_; // this allows you to turn off choosing reads to cover low consensus // quality regions // (OK) FileName filAutoFinishDebugUniversalPrimerReadsFile_; // for debugging Autofinish // put a file with this name in the same directory as the ace file // format: // fcalld09 fwd // fgj74f01 rev // (template name) (fwd or rev) // (OK) FileName filAutoFinishDebugCustomPrimerReadsFile_; // for debugging Autofinish // put a file with this name in the same directory as the ace file // format: // cgggacctgg // (primer in 5' to 3' orientation) // (OK) int nAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_; // see consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether // (OK) int nAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_; // see consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether // (OK) RWCString soAutoFinishDoNotFinishWhereTheseTagsAre_; // list of tag types separated by spaces. E.g., // doNotFinish repeat // tells autofinish that you are not interested in finishing in this region // (OK) RWCString soAutoFinishDoNotExtendContigsWhereTheseTagsAre_; // list of tag types separated by spaces. E.g., // doNotFinish repeat // tells autofinish that you do not want to extend the contig near this // tag. If you do not want this feature, just leave the list empty. // (OK) int nAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_; // Uses the list from consed.autoFinishDoNotExtendContigsWhereTheseTagsAre // and checks if any of these tags are within this many bases of the end of // the contig. If they are, does not extend the contig. // (OK) FileName filDumpContigOrderAndOrientationInfoToThisFile_; // In the case of Consed (not autofinish or autoPCRAmplify), send the // output to this file rather than stderr. If this name is blank, // continue (in case of consed), to send output to stderr. // (OK) bool bAutoFinishDumpTemplates_; // for debugging, this allows you to dump all information about the // templates--insert locations // (OK) int nAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_; // (OK) double dAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_; // To exclude contigs that are probably E. coli contamination // \"depth of coverage\" is defined here to mean the sum of the read // lengths (including low quality ends) divided by the contig length. // (OK) int nAutoFinishExcludeContigIfThisManyBasesOrLess_; // consed.autoFinishExcludeContigIfTooShort must be set to true for // this to have any effect // (OK) int nAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_; // this tells autofinish which templates you are planning on using // which is necessary to figure out which regions will still be single // subclone regions // (OK) int nPrimersMinNumberOfTemplatesForPrimers_; // if there are fewer templates than this, the primer is rejected // Pat wanted this 70 on May 5, 2000 to allow for 20 bases of poor // quality at beginning of read and then 50 bases for phrap to // assemble together int nAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_; // when extending the consensus, a read that is too far from the // consensus will not be assembled by phrap with this contig and thus // will not be useful for extending the consensus. This gives the // minimum overlap of a read with the high quality segment of the // consensus. As reads are picked, then additional reads may be picked // further out. // (OK) int nAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_; // used to figure out where the beginning of a reverse will be. Not // important to be accurate because the insert size is so uncertain // (OK) bool bAutoFinishCDNANotGenomic_; // If this is set to true, the whole clone is assumed to be cDNA and, // rather than the normal method of detecting the end of the clone, // Autofinish detects the end of the cDNA as follows: // the user is expected to add whole read items of type 'template', // with 'type: univ fwd' for the 5' end and 'type: univ rev' for the 3' // end of the cDNA. // (OK) int nAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_; // Autofinish computes the per cent of existing reads are aligned at // each base position. Typically, this number starts at around 0% at // base position 1, rises to close to 100% at around base position 300, // and then drops again to 0% at base position 800 or so. This number // specifies how high the number must be for Autofinish to consider an // Autofinish read to cover a single subclone region. // (OK) bool bAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads_; // If this is true, then custom primer reads are printed out like this: // tccagaaaactaattcaaaataatg,56,standard.2,->,2413,2413,3681,Contig1,9,djs74_690 (fwd),10,djs74_1803 (fwd),11,djs74_1861 (fwd) // If this is false, then custom primer reads are printed out like this: // tccagaaaactaattcaaaataatg,56,standard.2,->,2413,2413,3681,Contig1,9,djs74_690,10,djs74_1803,11,djs74_1861 // The difference is the (fwd) or (rev) that indicates which strand of // the subclone template is to be used. This is particularly important if // you use M13 and thus must make the reverse strand. // (OK) bool bAutoFinishPrintMinilibrariesSummaryFile_; // If this is true, Autofinish will print a file with name // xxx.minilibraries just as it prints one as xxx.univReverses and // xxx.univForwards // (OK) bool bAutoFinishNearGapsSuggestEachMissingReadOfReadPairs_; // This is set to true to increase the chance of closing a gap. For // every subclone template that has just one universal primer read // (either just a forward or just a reverse) that might protrude off // the end of the contig, Autofinish suggests the universal primer read // off the opposite end of the subclone template. // If this parameter is set false, then // Autofinish may still choose some of these reads, but it won't // necessarily choose them all. // (OK) int nAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_; // Do not ignore low consensus quality bases if they are this many // bases from the end of the contig. // (OK) bool bCheckIfTooManyWalks_; // this just checks if the number of walks, pcr ends, and unknown reads // exceeds 20% of the total number of reads. If this is exceeded, then // a warning message is given. Typically, such a warning indicates // that you have incorrectly customized determineReadTypes.perl // (OK) int nNumberOfColumnsBeforeReadNameInAlignedReadsWindow_; // this is for displaying information about the whole read items, // both from PHD files and from a file int nCompareContigsAlignsThisManyBasesMax_; // (OK) RWCString soCompressedChromatExtension_; // (OK) bool bDimLowQualityEndsOfReads_; // // (OK) // phil 980713 requested that the default be to not dim // low quality ends of reads and to dim the unaligned ends // of reads bool bDimUnalignedEndsOfReads_; // (OK) bool bFakeReadsSpecifiedByFilenameExtension_; // if this is true, then reads that end with .a[0-9]* or .c[0-9]* will // be considered fake reads. Otherwise, fake reads will be indicated // by a WR item in the PHD file. // (OK) FileName filFullPathnameOfAddReads2ConsedScript_; // (OK) FileName filFullPathnameOfFixContigEndScript_; // (OK) bool bFixContigEndsCleanUpTemporaryFiles_; // -fixContigEnds leaves behind zillions of temporary files from // phrapping. Delete these (except for debugging). // (OK) int nFixContigEndsMinSmithWatermanScoreToMakeJoin_; // when making the join, if the smith-waterman score is less // than this, do not make the join and leave the contig-end as is // (NO) int nFixContigEndsMinNumberOfReadsInContig_; // only fix contigs that have this number of reads or more // (YES) FileName filFullPathnameOfCrossMatch_; // (OK) FileName filFullPathnameOfPhred_; // (OK) FileName filFullPathnameOfMiniassemblyScript_; // If you are up-to-date with phredPhrap, this script serves both // the purpose of assemblying the entire project, as well as making // miniassemblies. The difference is whether phredPhrap has the // -include_chromats option. // (OK) RWCString soGunzipFullPath_; // (OK) FileName filFullPathnameOfFilter454ReadsScript_; // Runs crossmatch between the unpaired reads and puc19 to eliminate those // reads contaminated with puc19 // (OK) FileName filFilter454ReadsAgainstThis_; // used by consed.fullPathnameOfFilter454ReadsAgainstVectorScript // (OK) FileName fil454LinkerSequences_; // the linker sequence for paired-end 454 reads used in // sff2PhdBall // (OK) bool bHideSomeTagTypesAtStartup_; // (OK) int nMaximumNumberOfTracesShown_; // (OK) bool bNavigateAutomaticTracePopup_; // (OK) bool bNavigateAutomaticAllTracesPopup_; // (OK) int nPrimersMinimumLengthOfAPrimer_; // (OK) int nPrimersMaximumLengthOfAPrimer_; // (OK) int nPrimersMinimumLengthOfAPrimerForPCR_; // (OK) int nPrimersMaximumLengthOfAPrimerForPCR_; // (OK) double dPrimersMaxMeltingTempDifferenceForPCR_; // how large can the difference of melting temperatures be between // two primers of a PCR primer pair // (OK) int nPrimersMaxPCRPrimerPairsToDisplay_; // there is a limit here, because there could possibly be millions // (OK) bool bPrimersCheckJustSomePCRPrimerPairsRatherThanAll_; // If there are 1000 1st primers, and 1000 2nd primers, that gives // a million pairs for Consed to check, which takes a long time. So // instead, just check some of the pairs // (OK) int nPrimersNumberOfTemplatesToDisplayInFront_; // this shows the number of templates to show in the interactive primer // picking window // (OK) int nPrimersMaxLengthOfMononucleotideRepeat_; // (OK) FileName filPrimersBadLibrariesFile_; // file of libraries, one per line // If any template is from any one of these libraries, then // consed/autofinish will not use this template for walking or // suggesting any universal primer reads // (OK) FileName filPrimersLibrariesInfoFile_; // file of libraries, with one entry for each library of the following // format: // LIB{ // name: library1 // avgInsertSize: 3000 // maxInsertSize: 5000 // stranded: single // cost: 600.0 // } // (OK) FileName filPrimersBadTemplatesFile_; // file of templates that you've tried, don't work, and you don't want to try // again // (OK) bool bPrimersChooseTemplatesByPositionInsteadOfQuality_; // Templates for subclone custom primer walks can be chosen either on // the basis of the quality of the template (as determined by the quality // of existing reads from that template) or by the location of the end of // the template. If this parameter is false, templates will be chosen // based solely on quality. If this parameter is true, then templates // with forward/reverse pairs will be picked first, followed by templates // that have the beginning of the insert closest to the primer. // (OK) int nPrimersWhenChoosingATemplateMinPotentialReadLength_; // when choosing templates for a custom primer, only choose a template // if the read can be chosen at least this long // (OK) int nPrimersWindowSizeInLookingForPCR_; // will look this many bases back from the pointer when looking for a PCR // primer. Used both interactively and for Autofinish (see // getUnpaddedRangeForMakingPCRPrimers ) // (OK) int nQualityThresholdForFindingHighQualityDiscrepancies_; // high quality discrepancies have this quality or higher // (OK) int nQualityThresholdForNavigateByDepthOfCoverage_; // for high depth of coverage, this is the minimum quality // see consed.navigateByHighDepthOfCoverageNotLow // (OK) bool bNavigateByHighDepthOfCoverageNotLow_; // see consed.qualityThresholdForNavigateByDepthOfCoverage: // (OK) int nMinDepthForNavigateByDepthOfCoverage_; // see consed.qualityThresholdForNavigateByDepthOfCoverage: // (OK) FileName filDefaultVectorPathnameForRestrictionFragments_; // If you want to have the vector cut with the restriction // enzymes, put the vector sequence in a file in fasta format // and put a pathname to it here. // (OK) FileName filFileOfAdditionalRestrictionEnzymes_; // If you want a restriction enzyme that is not in the huge list // that comes with Consed, you can put additional enzymes in a file // and put the full pathname of that file here. The file must be in // the form: // AatI AGGCCT // where AatI is the name of the enzyme and AGGCCT is the recognized // sequence. Do not include the cut site or any other information. // There must be a single space separating them. // (OK) RWCString soCommonRestrictionEnzymes_; // a space-separated list of enzymes. Make sure they match precisely // those that are either defaults or in the file indicated by // consed.fileOfAdditionalRestrictionEnzymes // (OK) RWCString soDefaultSelectedRestrictionEnzymes_; // a space-separated list of enzymes that will initially be // selected when the user pops open the list of restriction enzymes. // Currently these must be from among the consed.commonRestrictionEnzymes // (OK) FileName filRestrictionEnzymesActualFragmentsFile_; // format like this: // >EcoRV // 2385 // 2489 // -1 // >XhoIII // 259 // 3843 // -1 // (OK) int nRestrictionDigestInitialWindowSizeInTextRows_; // (OK) int nRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize_; // In the picture of the real and in-silico // (OK) bool bShowReadsAlphabetically_; // (OK) bool bShowReadsInAlignedReadsWindowOrderedByFile_; // There are now 3 different ways to sort the reads in the Aligned // Reads Window (top to bottom): // 1) alphabetically in which case you should set: // consed.showReadsAlphabetically: true // consed.showReadsInAlignedReadsWindowOrderedByFile: false // 2) by the left end of the reads in which case you should set: // consed.showReadsAlphabetically: false // consed.showReadsInAlignedReadsWindowOrderedByFile: false // 3) by a file that specifies the order of the reads in which case you // should set: // consed.showReadsAlphabetically: false // consed.showReadsInAlignedReadsWindowOrderedByFile: true // It is an error to set: // consed.showReadsAlphabetically: true // consed.showReadsInAlignedReadsWindowOrderedByFile: true // (OK) FileName filShowReadsInAlignedReadsWindowOrderedByThisFile_; // This file has one read name per line. Wildcards ('*') are allowed. // E.g., // ABX* // myFavoriteRead.scf // *.abi // This means that all reads that start with ABX* will come first, // followed by the single read myFavoriteRead.scf and then reads that end // with .abi A read that doesn't meet any of these criteria (e.g., // rs10469282 ) comes last. // (OK) //consed.showReadsSortedByQualityValuesAtCursor: true //bool // deprecated // Note that currently this only applies when the cursor is set // on the consensus position. When scrolling, the reads are // sorted according to consed.showReadsAlphabetically and // consed.showReadsInAlignedReadsWindowOrderedByFile // (OK) RWCString soShowReadsAtCursorSortedHow_; // Note that currently this only applies when the cursor is set // on the consensus position. When scrolling, the reads are // sorted according to consed.showReadsAlphabetically and // consed.showReadsInAlignedReadsWindowOrderedByFile // use the following values: quality, base, none // (OK) bool bShowABIBasesInTraceWindow_; // (OK) int nTracesWindowInitialPixelHeight_; // (OK) int nAssemblyViewWindowInitialPixelHeight_; // (OK) FileName filAssemblyViewFileOfTemplatesToNotShow_; // (OK) int nAssemblyViewCrossMatchMinmatch_; // value of -minmatch to be passed to crossmatch // (OK) int nAssemblyViewCrossMatchMinscore_; // value of -minscore to be passed to crossmatch // (OK) FileName filAssemblyViewFindSequenceMatchesForConsedScript_; // script that generates the file that is used by Assembly View to // show sequence matches // (OK) int nAssemblyViewCrossmatchMinmatch_; // default value of -minmatch for running crossmatch with // findSequenceMatchesForConsed.perl // (OK) int nAssemblyViewCrossmatchMinscore_; // default value of -minscore for running crossmatch with // findSequenceMatchesForConsed.perl // (OK) int nAssemblyViewSequenceMatchesMinimumSimilarity_; // only show sequence matches if their simlarity is at least this // value. This can be changed by the user within consed/assembly view/ // by clicking on "What to show/Sequence Matches" // (OK) int nTracesWindowInitialPixelWidth_; // (OK) int nAssemblyViewWindowInitialPixelWidth_; // (OK) bool bAutomaticallyScaleTraces_; // (OK) double dAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight_; // (OK) int nAutomaticallyScaleTracesSamplePeakPercentile_; // (OK) int nVerticalTraceMagnification_; // (OK) RWCString soUserDefinedKeys_; // make a space-separated list of the decimal ASCII values of the keys // 14 means control-N, 15 means control-O // (OK) RWCString soProgramsForUserDefinedKeys_; // a space-separated list of the full pathnames of the commands to run // This goes with consed.userDefinedKeys // (OK) RWCString soArgumentsToPassToUserDefinedPrograms_; // a space-separated list of the arguments to pass to the user-defined programs // This goes with consed.userDefinedKeys // (OK) RWCString soTagsToApplyWithUserDefinedKeys_; // a space-separate list of the tag types to apply when the user // presses a user-defined key. If a key is to have no associated tag, // then enter "none" for that key. // This goes with consed.userDefinedKeys // (OK) bool bSnpGenomeUseInsertionPolymorphisms_; // used with consed -snpGenome // (OK) RWCString soListOfTagTypesToHide_; // (OK) RWCString soListOfOptionalWordsToSaveInListOfReadNames_; // (OK) bool bExtendConsensusWithHighQuality_; // When using "change consensus" to extend the consensus, make the // read edited high quality. This will cause phrap, the next time // the project is assembled, to similarly extend the consensus. If // this is set to false, then do not change the quality of the read and // extend the consensus with the original read qualities. // (OK) bool bFastStartup_; // If you have used catPhdFiles.perl to create a huge file with all the // xxx.phd.1 files, and you have enough memory on your computer, then // you can startup up consed up to 7 times faster // (OK) FileName filFastStartupFile_; // If you have used catPhdFiles.perl to create a huge file with all the // xxx.phd.1 files, and you have enough memory on your computer, then // you can startup up consed up to 7 times faster. This file gives // the name of the huge file. // (OK) RWCString soAlwaysRunProgramToGetChromats_; // This allows consed to get chromats out of a database, or do some // other pre-processing of a chromat before reading it. If set to true, // consed does not look in ../chromat_dir at all for the chromat, but // rather runs the program listed in consed.programToRunToGetChromats // with argument name-of-read and then reads the chromat out of // consed.uncompressedChromatDirectory and then later deletes the // chromat from consed.uncompressedChromatDirectory // If set to false, it never does this. If set to "last", it does // this as a last resort. // (OK) FileName filProgramToRunToGetChromats_; // Set this to the program or script that you want to use to // get a chromat and put it into /tmp (or whatever you set // consed.uncompressedChromatDirectory to) // (OK) FileName filProgramToRunToGetChromatsOf454Reads_; // This will be run on 454 reads if the read is not found in // chromat_dir. If you don't want this to happen, you can make // this null. // (OK) bool bCreateFakeChromatsForSolexaReads_; // (OK) bool bAutoFinishUseLongModelReadRatherThanShort_; // When calculating the distribution of quality values at high read // positions, should Autofinish assume that the reads that were this // long and longer are representative of finishing reads, or should it // assume that some finishing will not make it out this far in roughly // the same proportion as the existing reads. // (OK) int nAskAgainIfWantToQuitConsedIfThisManyReads_; // If you have to wait a long time for consed to come up, don't // quit out of consed by mistake. // (OK) RWCString soPrintWindowInstructions_; // (OK) bool bAllowMultipleSearchForStringWindows_; // If this is false, and there is already a SearchForString Window up, // and the user clicks on SearchForString, it will be brought to the // front, rather than another one being created. // (OK) int nAutoPCRAmplifyFalseProductsOKIfLargerThanThis_; // If a pcr primer pair matches somewhere else and creates a product // larger than this, the pcr primer pair will still be acceptable // since the product will not easily form in the cycle time. // (OK) bool bAutoPCRAmplifyMakePrimerOutOfFirstRegion_; // I don't expect people will use this. It allows you to amplify a // region using autoPCRAmplify not by allowing Consed to choose each // primer (the normal case) but rather by fixing the first primer to be // the first area bordering the region. I added this to allow // non-specific priming to the transplice leader. // (OK) int nAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_; // ---> ---> // false true match // In such a case, the primer pair will be rejected if the false is // within 5000 bases of true, even if false is a false match of the // other primer. // // <--- ---> // false true match // In this case, the primer pair will not be eliminated. // (OK) bool bAddNewReadsRecalculateConsensusQuality_; // When running consed by // consed -ace old_ace.ace -addReads fileOfPhdFiles.txt -newAceFilename new_ace.ace // consensus quality is recalculated // This also applies to add454Reads.perl and addSolexaReads.perl // (OK) RWCString soAddNewReadsPutReadIntoItsOwnContig_; // choices are: // "always" (just put each read into its own contig) // "ifUnaligned" (put read into a contig if it aligns against the // consensus, otherwise put it into its own contig) // "never" (put read into a contig if it aligns against the consensus; // otherwise do not put it into the assembly) // (OK) bool bAddNewReadsCheckThatCrossMatchRunCorrectly_; // addReads2Consed.perl changed in March 2008 to have -discrep_lists // instead of -alignments. Check that user is using the new // parameters // (OK) int nAssemblyViewNumberOfRowsOfTags_; // (OK) bool bWarnUserWhenTryingToEditAllReads_; // in the Aligned Reads Window, the user may change all reads at once // to a particular base at a particular position. This is dangerous // and the user is warned. This resource allows the user to suppress // this warning. // (OK) FileName filMaybeXKEYSYMDBPath_; // Fixes a problem in X on some versions of linux giving pages of the // following errors: // Warning: translation table syntax error: Unknown keysym name: osfActivate // (OK) FileName filMaybeXKEYSYMDBPath2_; // Fixes a problem in X on some versions of linux giving pages of the // following errors: // Warning: translation table syntax error: Unknown keysym name: osfActivate // (OK) int nAmountToMoveWithBigLeftAndRightArrows_; // allows user to move on a read in the Aligned Reads Window // by more than 1 base at a time // (OK) int nNavigateByHighlyDiscrepantPositionsMinDiscrepantReads_; // ignores low quality reads // (OK) int nNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage_; // (OK) int nNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality_; // (OK) bool bNavigateByHighlyDiscrepantPositionsJustListIndels_; // (OK) bool bNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation_; // If there are, for example, 3 reads that all start at the same // location, use only the first and ignore the second and third // (OK) bool bNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus_; // Do not report this position if there is one of the bases in the consensus // listed in // consed.navigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus // (OK) RWCString soNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus_; // Do not report this position if there is one of these bases in the // consensus and if // consed.navigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus: // is set to true // (OK) FileName filPhdBallDirectory_; // phd balls are assumed to be in here. This is typically where consed // starts, but could be relative to that, such as ../phdball_dir // (OK) FileName filNewAceFileFOF_; // if consed needs to write a new ace file, the name of that is written // to this file // (OK) int nNavigateByHighOrLowDepthCoalesceRegionsIfThisClose_; // for navigate by high or low depth of coverage // (OK) bool bRemoveReadsDeleteNotJustPutInOwnContig_; // used for consed -removeReads and consed -removeContigs // (OK) RWCString soPaired454LeftReadExtension_; // (OK) RWCString soPaired454RightReadExtension_; // (OK) FileName filSnpGenome1MSnps_; // file for development of snpGenome // (OK) bool bDiffChromosomesExcludeDeletions_; // for testing snpGenome moving deletions // (OK) bool bSnpGenomeFilterByWeight_; // if true, only considers polymorphisms with soWeight == "1" // (OK) int nWantReadsUpToThisFarFromSnps_; // for phaster2PhdBall (phaster2Ace.perl ) to take reads, even if they don't overlap the // snp, that are this far away from the snp // (OK) RWCString soPhaster2PhdBallSaveWhichMate_; // for phaster2PhdBall (phaster2Ace.perl) to determine whether // the function of just saving the reads that intersect the snp are // saved, or whether both mates of a read pair are saved if either one // intersects the snp location and has one of the desired alleles // alternative: unmapped which says that just the unmapped read is // saved // (OK) bool bPhaster2PhdBallSaveInPhasterFormat_; // for phaster2PhdBall::maybeSaveBothReads to save the read in // phaster format rather than in phd format. This only applies // if consed.phaster2PhdBallSaveBothMates: is set to true // the phaster lines will be set to the file specified by // -phdBall on the command line // (OK ) bool bPhaster2PhdBallCalculateNewLocationsFile_; // for phaster2PhdBall. Calculates depth of coverage and // makes new locations that have depth of coverage bool bPhdBall2FastaIgnoreLowQualityReads_; // for consed -phdBall2Fasta // if a read has mean quality below a threshold, do not // write it to the fasta file // (OK) int nPhdBall2FastaLowestAverageQuality_; // for consed -phdBall2Fasta // if read has mean quality below this, ignore it // (OK) FileName filNextPhredPipelineControlFile_; // (OK) FileName filNextPhredPipelineTiffPerlScript_; // (OK) FileName filNextPhredPipelinePhasterPerlScript_; // (OK) RWCString soNextPhredPipelineVersion_; // (OK) RWCString soNextPhredPipelineMainDirectory_; // (OK) // // // // parameters in the (NO) category // // int nMaxNumberOfReadsPerPhdBall_; // This is important since cross_match slows down on fasta files of // over a few million reads // (NO) FileName filUserWantsToSaveToThisAceFile_; // (NO) bool bAutoFinishEmulate9_66Behavior_; // Picks univ primer reads and walks in the same phase. This results // in poor redundancy of universal primer reads, may pick custom primer // reads over universal primer reads, but may pick fewer // reads overall. // (NO) int nPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_; // to speed up PCR primer picking and to reduce the number of // PCR primer pairs, group primers into windows of this size // and then just compare window against window // (NO) int nPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_; // to speed up PCR primer picking and to reduce the number of PCr // primer pairs, group primers into windows and then just accept // this many primer pairs from a pair of groups // (NO) double dAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_; // Only applies when consed.autoFinishNearGapsSuggestEachMissingReadOfReadPairs: // is set to true. If m is the mean insert size and d is the standard // deviation and this parameter is p, then consider all templates // within a distance m + p*d from the gap. // (NO) bool bAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent_; // I strongly advise keeping this true. If you change it to false, you // are on your own. If the forward and reverse universal primer reads // look like this: <--- ---->, how is autofinish going // to even know where the template is, huh? Leave it true! // (NO) bool bAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether_; // at higher redundancy, autofinish may pick custom primer reactions // that are only a few bases apart on the same strand. This parameter, // along with // consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases, // says how far apart they can be // (NO) bool bAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether_; // Even at redundancy 1, Autofinish may pick whole clone reads just // a few bases apart. This prevents it. // (NO) double dAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_; // If a template is more than this many standard deviations from the // mean, try to avoid using it, unless there is nothing else. // Rationale: there is something wrong with this template--an insertion // or deletion. // (NO) int nAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_; // If there are at least this many fwd/rev pairs in a library, then // the mean and standard deviation are used for sizing other templates in // the same library. If there are fewer than this, then the default size // specified in the librariesInfo.txt file is used. // (NO) double dAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_; // If you are interested in walking on a template that does not have a // forward/reverse pair, then the precise insert size is uncertain. If // this template comes from a library that has lots of templates with // forward/reverse pairs, then the mean and standard deviation of the // insert sizes from this library is known. For the template in // question, we could just use the mean of this library (this parameter = // 0.0), but we could be conservative and assume the insert size is // somewhat less. This parameter tells how much less. // (NO) int nAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_; // this tells autofinish when it wants to make a new custom primer // read, how far this read must be from any previous custom primer // reads on the same strand // (NO) int nAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_; // if an experiment will only fix less than this number of single // subclone bases, don't do it even if the total number of single // subclone bases in the contig is too high // (NO) int nAutoFinishNumberOfBasesBetweenContigsAssumed_; // gap size--each base in the gap counts as 1 error so autofinish tries // to extend into gaps // (NO) int nAutoFinishPotentialHighQualityPartOfReadStart_; // Phil and Kerrie both suggested upping this from 50 // on March 25, 1999 // nReadUnpaddedConsPosStart + nAutoFinishPotentialHighQualityPartOfReadStart_ // == nReadUnpaddedConsPosStartOfPotentialHighQuality // this is used to evaluate the quality of templates // this no longer has much effect on the reads autofinish chooses // (NO) int nAutoFinishPotentialHighQualityPartOfReadEnd_; // nReadUnpaddedConsPosStart + nAutoFinishPotentialHighQualityPartOfReadEnd_ // == nReadUnpaddedConsPosEndOfPotentialHighQuality // this is used to evaluate the quality of templates // this no longer has much effect on the reads autofinish chooses // (NO) bool bAutoFinishPrintCustomNavigationFileForChosenReads_; // If this is true, then autofinish will print a file of the chosen reads // in the format for consed to navigate (prev and next) to each // location of the proposed new reads // (NO) int nAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_; // Normal case: // --------------------------- (consensus) // ----------- template1 // ----------- template2 // ----------- template3 // Then you probably would want to use template3 since a reverse is // most likely to go in the other contig rather than go into gap. // But suppose that template2 and template3 don't exist. Would you // want to use template1? This parameter tells Autofinish whether you // would want to use it, or pick no reverse at all. // (NO) bool bAutoFinishTagOligosWhenDoExperiments_; // when autofinish is run with -doExperiments, tags the oligos // it chooses // (NO) bool bCountPads_; // (NO) int nDebugging_; // for consed development use // (NO) int nDebugging2_; // for consed development use // (NO) int nDebugging3_; // for consed development use // (NO) RWCString soDebuggingString_; // for consed development use // (NO) int nIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion_; // Phil specified this (changed from 10) on 6/30/98 int nIgnoreUnalignedHighQualitySegmentsShorterThanThis_; // (NO) int nPrimersLookThisFarForForwardVectorInsertJunction_; // don't change this--if no X's this far from beginning of read, then // assume that you are in insert // (NO) double dPrimersDNAConcentrationNanomolar_; // used for melting temperature--don't change this! // (NO) int nPrimersMaxMatchElsewhereScore_; // used for testing false-annealing to template and to vector // (NO) int nPrimersMaxMatchElsewhereScoreForPCR_; // used for testing false-annealing to template and to vector // when used with PCR // (NO) int nPrimersMaxSelfMatchScore_; // cutoff for self-annealing of a primer // (NO) int nPrimersMaxPrimerDimerScoreForPCR_; // careful changing this // (NO) int nPrimersMinQuality_; // you must be sure of the sequence of a primer or it won't anneal to // where you want // (NO) bool bPrimersPrintInfoOnRejectedTemplates_; // whether to print which templates were rejected and why (this output // can be large ) // (NO) double dPrimersSaltConcentrationMillimolar_; // used for melting temperature--don't change this! // (NO) bool bPrimersScreenForVector_; // whether or not to screen primers for annealing to vector // (NO) int nPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_; // different forward reads or different reverse reads // can differ by up to this amount in the starting location // If they differ by more, then there is something wrong // with the template (it is mislabeled?) so don't use it again for // walking // (NO) int nPrimersTooManyVectorBasesInWalkingRead_; // if there are this many x's, then don't walk again on this template // (NO) int nQualityThresholdForLowConsensusQuality_; // Phil had this changed from 20 to 25 on 15 Jul 98 // highest low quality. A base at this quality is considered low // quality. A base higher than this is considered high quality. // (NO) int nTagColorPerCentOfBase_; // (NO) RWCString soUncompressedChromatDirectory_; // (NO) FileName fil454sff2scfDirectory_; // when a user asks to see a 454 trace, and sff2scf runs, the // scf file will be put here. This is hard-coded in sff2scf.c // (NO) int nWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion_; // (NO) int nWriteThisAceFormat_; // (NO) bool bDumpCoreIfBoundsError_; // (NO) int nAutoFinishMinSmithWatermanScoreOfARun_; // (NO) double dAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_; // When autofinish tries to find a compatible set of pcr primers, it // can take billions of tries. This limits the number of tries so that, // if autofinish can't find it in this number of tries, it gives up // rather than running for days, weeks, years! // (NO) int nRestrictionDigestMaximumBasesToCompareToVector_; // (NO) double dRestrictionDigestZoomFactor_; // Amount to zoom in or out in the gel window of the restriction digest // (NO) double dRestrictionDigestZoomFactorForNavigate_; // When looking at restriction gel and navigating to first problem // location, this is the amount to zoom in. // (NO) int nRestrictionDigestToleranceInPositionUnits_; // (NO) int nAutoPCRAmplifyTooManySeriousFalseMatches_; // If a pcr primer pair has a significant false match to this many // other places in the assembly, do not consider for possible pcr // primer pairs. This is just for the purpose of speeding up picking // of primer pairs--the higher the number, the faster the searching, // but the more likely a primer pair will be selected that will // create multiple products. // (NO) double dAssemblyViewZoomFactor_; // amount to zoom in or out // (NO) int nAssemblyViewFilterInconsistentFwdRevPairsIfThisClose_; // If forward/reverse pairs start this close together and end this // close together, they confirm each other. // (NO) double dAssemblyViewGridCellWidthInPixels_; // for keeping track where objects are on screen. If you make it // larger, you get better drawing performance, but lower resolution // of which objects the cursor is pointing at // (NO) int nAssemblyViewCursorSensitivityInPixels_; // square about cursor that will detect objects // (NO) int nAssemblyViewReadDepthQuality_; // (NO) int nShowAllTracesMaxNumberOfTracesToShowAtOnce_; // (NO) int nAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess_; // (NO) bool bJustForPrimateProject_; // (NO) FileName filSolexaFilesAreAssumedToBeHere_; // any solexa files (or links) are assumed to be in this directory. // If you change this, it can have effects in 3 places: 1) add new // reads list of solexa files 2) add new reads where it looks for these // files and 3) subsequent runs of consed it will prepend this to the // path it finds in the ace file under PHD_DIR: on the DS line. There // may be other implications as well. // (NO) int nSolexaAlignmentFilesPerInsertingPadsCycle_; // (NO) int nSolexaAlignmentsPerAlignmentFile_; // (NO) bool bSolexaFastqFilesArePhredQualityNotSolexaQuality_; // (NO) RWCString soSolexa64FastqOrSanger33Fastq_; // valid values are: auto (it figures it out itself), // solexa64 (+64), and sanger33 (+33) // If consed is being fooled, you can set these to force // consed to override what the file appears to be. // (NO) int nMaximumReadsInReadList_; // even if there are millions of reads, don't display them all or // it will eat up memory and time // (NO) int nMaxLengthOfReadsInapLocatedFragment2_; // (NO) int nMaximumStartupErrorsToReport_; // (NO) int n454LinkerAlignmentMatchScore_; // (NO) int n454LinkerAlignmentMismatchScore_; // (NO) int n454LinkerAlignmentIndelScore_; // (NO) bool bFilter454ReadsDeleteCrossMatchOutput_; // This should be changed to false only for troubleshooting. // Otherwise unused files will accumulate on your disk. // (NO) // removed Oct 11, 2010 when removed old method of extending contig ends // when adding new reads //consed.addNewReadsAdditionalConsensusBasesBeyondReads: 500 //int // These additional consensus bases are added for the miniassembly // of the reads on the end of the contig. // (NO) // Resources here are just those for Green Lab research and have // no effect on any Consed/Autofinish/AutoReport functions int nAutoReportAllNeededSpeciesCode_; // if 1, then require PPan|PTro, GGor, PPyg|MMul // if 2, then require PTro, GGor, PPyg, MMul // if 3, then require PTro, GGor, PPyg|MMul // (GREEN LAB) bool bAutoReportUseCommasInBigNumbers_; // (GREEN LAB) bool bAutoReportPrintToCompareToReich_; // (GREEN LAB) bool bAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites_; // in applyFilters. This will guarantee that we can find // deamination mutations. // (GREEN LAB) bool bAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod_; // in checkTreesAndRecordDeaminationMutations // whether it uses PPan, GGor, and PPyg as well, or just human, PTro, and MMul // This helps for comparison with the whole genome analysis which just // had PTro, HSap, and MMul // (GREEN LAB) bool bAutoReportChooseTreesUsingBadData_; // in applyFilters // (GREEN LAB) bool bAutoReportChooseTreesByCountingDeaminationMutations_; // in applyFilters // (GREEN LAB) bool bAutoReportChooseTreesUsingKimura_; // in applyFilters // (GREEN LAB) bool bAutoReportPrintCrudeChimpHumanMutations_; // (GREEN LAB) bool bAutoReportPrintPositionsForGraham_; // used with printFlankedColumns4 // (GREEN LAB) bool bAutoReportPrintAncestralCpGs_; // used with printFlankedColumns4 // (GREEN LAB) bool bAutoReportPrintCpGMutations_; // used with printFlankedColumns4 // (GREEN LAB) bool bAutoReportPrintMutationsWithContext_; // print columns that have mutations with flanking // columns that are conserved //(GREEN LAB) bool bAutoReportCountAllMutationsML_; // counts all types of mutations and uses trees // based on the probability of each tree //(GREEN LAB) bool bAutoReportCountAllMutations_; // counts deamination mutations in pairs of columns that // both pass filters. //(GREEN LAB) bool bAutoReportIgnoreMultipleTrees_; // used with // consed.autoReportCountAllMutations: false // (GREEN LAB) bool bAutoReportCountAcceptableColumnsWithNoneOnLeft_; // count columns that pass all filters, but column to left of it // doesn't pass all filters // (GREEN LAB) bool bAutoReportPrintFlankedColumns4_; // This differs from that below primarily in that it // identifies deamination mutationsx // (GREEN LAB) bool bAutoReportUseAnnotationFormat_; // Used with consed.autoReportPrintFlankedColumns4: // to print things out in a format that can be used for distinguishing // the clades // (GREEN LAB) bool bAutoReportPrintFlankedColumns3_; // This differs from that below primarily in that it // uses n instead of ? and prints trees // (GREEN LAB) bool bAutoReportPrintFlankedColumns2_; // This differs from that below primarily in that it // doesn't require all species, but rather // PPan | PTro && GGor && MMul | PPyg // (GREEN LAB) bool bAutoReportPrintFlankedColumns_; // (GREEN LAB) bool bAutoReportHighQualitySegmentData_; // (GREEN LAB) bool bAutoReportGoodReadsBug_; // (GREEN LAB) bool bAutoReportDiscrepancyRateInFlankedRegions_; // (GREEN LAB) bool bAutoReportDiscrepancyRateInFlankedRegions2_; // (GREEN LAB) bool bAutoReportDiscrepancyRateInFlankedRegions4_; // (GREEN LAB) bool bAutoReportDiscrepancyRateInFlankedRegions5_; // (GREEN LAB) bool bAutoReportSingleSignalOrQuality_; // (GREEN LAB) bool bAutoReportLowQualityBasesInHQS_; // (GREEN LAB) bool bAutoReportCompareHQSWithLQS_; // (GREEN LAB) bool bAutoReportCountColumnsForGroupsOfSpecies_; // (GREEN LAB) bool bAutoReportSingleSignalInfo_; // (GREEN LAB) bool bAutoReportSingleSignalInfo2_; // Just used to print out the # of bases at each quality that are // single signal and the # that are multiple signal. For comparing // 2004 reads with 2005 reads // (GREEN LAB) bool bAutoReportCompareTopAndBottomStrands_; // (GREEN LAB) bool bAutoReportCompareTopAndBottomStrandsNoHuman_; // (GREEN LAB) bool bAutoReportCompareTopAndBottomStrands2_; // (GREEN LAB) bool bAutoReportCompareTopAndBottomStrands3_; // (GREEN LAB) bool bAutoReportCompareTopAndBottomStrands4_; // (GREEN LAB) int nAutoReportTopStrandPinnedPosition_; // for use with consed.autoReportCompareTopAndBottomStrands // given in unpadded read pos in direction of sequencing // (GREEN LAB) int nAutoReportBottomStrandPinnedPosition_; // for use with consed.autoReportCompareTopAndBottomStrands // given in unpadded read pos in direction of sequencing // (GREEN LAB) bool bAutoReportCompareTopAndBottomStrandsWithHuman_; // (GREEN LAB) bool bAutoReportPrintLengthsOfAlignedSegmentsOfReads_; // (GREEN LAB) bool bAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads_; // (GREEN LAB) bool bAutoReportPrintIfReadsAreCorrectlyAligned_; // make sure that .f reads are top strand and .r reads are bottom // strand (Note: this only is true in some projects.) // (GREEN LAB) bool bAutoReportCalculateErrorProbabilitiesByComparingPTroPPan_; // (GREEN LAB) bool bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies_; // (GREEN LAB) bool bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2_; // differs from above in that one or the other of the species bases // must be at least quality 45 // (GREEN LAB) bool bAutoReportFilterSingleSignal_; // Green 2004 data should not be filtered for single signal // Green 2005 data should be // (GREEN LAB) FileName filAutoReportGoodHitReads_; // (GREEN LAB) int nAutoReportQualityWindowLow_; // (GREEN LAB) int nAutoReportQualityWindowHigh_; // (GREEN LAB) bool bAutoReportPrintNumberOfIsolatedPadsForEachSpecies_; // (GREEN LAB) bool bAutoReportPrintNumberOfIsolatedPads_; // (GREEN LAB) RWCString soAutoReportIsolatedPadsOfReadsWithThisPattern_; // (GREEN LAB) int nAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_; // (GREEN LAB) int nAutoReportMaxSizeOfDiscrepantRegion_; // used for printing bases of a discrepant region // (GREEN LAB) int nAutoReportSizeOfDiscrepantRegion_; // size of region between the flanking agreeing region // duplicates parameter above // (GREEN LAB) bool bAutoReportPrintMinimumQualityHistogram_; // (GREEN LAB) bool bAutoReportPrintDiscrepantRegions_; // (GREEN LAB) bool bAutoReportPrintBasesInDiscrepantRegions_; // (GREEN LAB) RWCString soAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_; // (GREEN LAB) RWCString soAutoReportBackboneReadHasThisStringInIt_; // (GREEN LAB) bool bAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold_; // if true, // uses consed.qualityThresholdForFindingHighQualityDiscrepancies // (GREEN LAB) bool bAutoReportPrintSpeciesAlignment_; // (GREEN LAB) bool bAutoReportPrintReadAlignment_; // This differs from consed.autoReportPrintSpeciesAlignment in that // reads that are for the same species are not combined. (This may be // useful for labs other than the Green Lab.) // (GREEN LAB) FileName filAutoReportPrintTheseReads_; // for consed.autoReportPrintReadAlignment // (GREEN LAB) bool bAutoReportPrintReadPositions_; // use with consed.autoReportPrintSpeciesAlignment: // (GREEN LAB) bool bAutoReportPrintChosenReadName_; // use with consed.autoReportPrintSpeciesAlignment: // (GREEN LAB) int nAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_; // if the read name is larger than this, will print this number // of characters at the end of the name. If the read name is shorter, // will just print the read name. // (GREEN LAB) RWCString soAutoReportPrefix_; // normally this will be the chromosome # // (GREEN LAB) bool bAutoReportUseOldCriteriaForDeletingColumnsOfPads_; // I think: // old: delete column of pads unless there is a certain non-pad (single // signal, high quality, hqs, good hit read), aggressive method // new: delete column of pads only if all combined reads are certain // pads (high quality, high quality segment, single signal, good hit) // conservative method // (GREEN LAB) bool bAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues_; // (GREEN LAB) bool bAutoReportFlankingBasesMustBeSingleSignal_; // for use with consed.autoReportPrintMutationsWithContext: // and others // (GREEN LAB) int nAutoReportMinimumQualityOfFlankingBases_; // for use with consed.autoReportPrintMutationsWithContext: // and others // (GREEN LAB) bool bAutoReportFlankingBasesMustBeInHighQualitySegment_; // (GREEN LAB) RWCString soAutoReportSpecies_; // These must match primateSpecies.h constants // nPPan, nPTro, nGGor, nPPyg, and nMMul // (GREEN LAB) private: static consedParameters* pGlobalConsedParameters_; // fail if anyone tries to create a second object. static bool bConsedParametersCreated_; }; #endif