X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=website%2Farchive%2Fbinaries%2Fmac%2Fsrc%2Fclustalw%2Fsrc%2Fgeneral%2FUserParameters.cpp;fp=website%2Farchive%2Fbinaries%2Fmac%2Fsrc%2Fclustalw%2Fsrc%2Fgeneral%2FUserParameters.cpp;h=3630e3de099954afb16f9b3883723f29a3a7c46e;hb=dbde3fb6f00b9bb770343631a517c0e599db8528;hp=0000000000000000000000000000000000000000;hpb=85f830bbd51a7277994bd4233141016304e210c9;p=jabaws.git diff --git a/website/archive/binaries/mac/src/clustalw/src/general/UserParameters.cpp b/website/archive/binaries/mac/src/clustalw/src/general/UserParameters.cpp new file mode 100644 index 0000000..3630e3d --- /dev/null +++ b/website/archive/binaries/mac/src/clustalw/src/general/UserParameters.cpp @@ -0,0 +1,1347 @@ +/** + * Author: Mark Larkin + * + * Copyright (c) 2007 Des Higgins, Julie Thompson and Toby Gibson. + */ +/** + * This file contains the implementation of the UserParameter functions + * Mark Larkin Dec 8 2005 + * + * Modified: 17 January 2008 Paul McGettigan added in the O aminoacid residue to handle Pyrrolysine + */ +#ifdef HAVE_CONFIG_H + #include "config.h" +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "UserParameters.h" +#include "clustalw_version.h" +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +namespace clustalw +{ +using namespace std; + +UserParameters::UserParameters(bool log) +{ + // FIXME: huge parts should be merged/replaced with + // setParamsToDefault (which is not used at all) + + gapPos1 = NUMRES - 2; /* code for gaps inserted by clustalw */ + gapPos2 = NUMRES - 1; /* code for gaps already in alignment */ + + //revisionLevel = CLU_SHORT_VERSION_STRING; + revisionLevel = CLUSTALW_VERSION; + interactive = false; + + seqName = ""; + DNAGapOpen = 15.0; + DNAGapExtend = 6.66; + AAGapOpen = 10.0; + AAGapExtend = 0.2; + gapDist = 4; + outputOrder = ALIGNED; // Note: All macros should be replaced by const + divergenceCutoff = 30; + + hydResidues = "GPSNDQEKR"; + noWeights = false; + negMatrix = false; + noHydPenalties = false; + noVarPenalties = true; + noPrefPenalties = false; + useEndGaps = false; + endGapPenalties = false; + resetAlignmentsNew = false; + resetAlignmentsAll = false; + outputStructPenalties = OUTSECST; + structPenalties1 = NONE; + structPenalties2 = NONE; + useSS1 = true; + useSS2 = true; + helixPenalty = 4; + strandPenalty = 4; + loopPenalty = 1; + helixEndMinus = 3; + helixEndPlus = 0; + strandEndMinus = 1; + strandEndPlus = 1; + helixEndPenalty = 2; + strandEndPenalty = 2; + useAmbiguities = false; + DNAPWGapOpen = 15.0; + DNAPWGapExtend = 6.66; + AAPWGapOpen = 10.0; + AAPWGapExtend = 0.1; + + quickPairAlign = false; + transitionWeight = 0.5; + DNAKtup = 2; + DNAWindowGap = 5; + DNASignif = 4; + DNAWindow = 4; + AAKtup = 1; + AAWindowGap = 3; + AASignif = 5; + AAWindow = 5; + percent = true; + tossgaps = false; + kimura = false; + bootNumTrials = 1000; + bootRanSeed = 111; + debug = 0; + explicitDNAFlag = false; + lowercase = true; + clSeqNumbers = false; + seqRange = false; + outputClustal = true; + outputGcg = false; + outputPhylip = false; + outputNbrf = false; + outputGde = false; + outputNexus = false; + outputFasta = false; + showAlign = true; + saveParameters = false; + outputTreeClustal = false; + outputTreePhylip = true; + outputTreeDistances = false; + outputTreeNexus = false; + outputPim = false; + bootstrapFormat = BS_BRANCH_LABELS; + profile1Name = ""; // Initialise to blank strings + profile2Name = ""; + empty = true; + profile1Empty = true; + profile2Empty = true; + outfileName = ""; + //profile1NumSeqs = 0; // MARK: Set to default before used. + useTreeFile = false; + newTreeFile = false; + useTree1File = false; + useTree2File = false; + newTree1File = false; + newTree2File = false; + aminoAcidCodes = "ABCDEFGHIKLMNOPQRSTUVWXYZ-"; + maxAA = aminoAcidCodes.length() - 2; + + // Some variables need the alignment to be read in before they can be set. + // I am putting the default as protein. Note: this should not make a difference + // as they are not used before they have been set a value again!! + + gapOpen = AAGapOpen; + gapExtend = AAGapExtend; + PWGapOpen = AAPWGapOpen; + PWGapExtend = AAPWGapExtend; + + gapPos1 = NUMRES - 2; + gapPos2 = NUMRES - 1; + profileNum = 0; + menuFlag = false; // MARK: I set to default value. + DNAFlag = false; // MARK: I set to default value. + distanceTree = true; // MARK: I set to default value. + ktup = AAKtup; + window = AAWindow; + windowGap = AAWindowGap; + signif = AASignif; + rangeFrom = -1; + rangeTo = -1; + rangeFromToSet = false; + QTscorePlotScale = 5; + QTresExceptionCutOff = 5; + + QTseqWeightCalculated = false; + QTminLenLowScoreSegment = 1; + QTlowScoreDNAMarkingScale = 5; + + // Set defaults for iteration variables. + numIterations = 3; + doRemoveFirstIteration = NONE; + maxAllowedSeqLength = INT_MAX; + + clusterAlgorithm = NJ; + displayInfo = true; + helpFlag = false; + fullHelpFlag = false; + quiet = false; + +} + +// FIXME:never used +void UserParameters::setParamsToDefault() +{ + DNAGapOpen = 15.0; + DNAGapExtend = 6.66; + AAGapOpen = 10.0; + AAGapExtend = 0.2; + gapDist = 4; + outputOrder = ALIGNED; + divergenceCutoff = 30; + + hydResidues = "GPSNDQEKR"; + noWeights = false; + negMatrix = false; + noHydPenalties = false; + noVarPenalties = true; + noPrefPenalties = false; + useEndGaps = false; + endGapPenalties = false; + resetAlignmentsNew = false; + resetAlignmentsAll = false; + outputStructPenalties = OUTSECST; + structPenalties1 = NONE; + structPenalties2 = NONE; + useSS1 = true; + useSS2 = true; + helixPenalty = 4; + strandPenalty = 4; + loopPenalty = 1; + helixEndMinus = 3; + helixEndPlus = 0; + strandEndMinus = 1; + strandEndPlus = 1; + helixEndPenalty = 2; + strandEndPenalty = 2; + useAmbiguities = false; + DNAPWGapOpen = 15.0; + DNAPWGapExtend = 6.66; + AAPWGapOpen = 10.0; + AAPWGapExtend = 0.1; + quickPairAlign = false; + transitionWeight = 0.5; + DNAKtup = 2; + DNAWindowGap = 5; + DNASignif = 4; + DNAWindow = 4; + AAKtup = 1; + AAWindowGap = 3; + AASignif = 5; + AAWindow = 5; + percent = true; + tossgaps = false; + kimura = false; + bootNumTrials = 1000; + bootRanSeed = 111; + debug = 0; + lowercase = true; + clSeqNumbers = false; + seqRange = false; + outputClustal = true; + outputGcg = false; + outputPhylip = false; + outputNbrf = false; + outputGde = false; + outputNexus = false; + outputFasta = false; + outputTreeClustal = false; + outputTreePhylip = true; + outputTreeDistances = false; + outputTreeNexus = false; + outputPim = false; + bootstrapFormat = BS_BRANCH_LABELS; + useTreeFile = false; + newTreeFile = false; + useTree1File = false; + useTree2File = false; + newTree1File = false; + newTree2File = false; + rangeFrom = -1; + rangeTo = -1; + rangeFromToSet = false; + QTscorePlotScale = 5; + QTresExceptionCutOff = 5; + + QTminLenLowScoreSegment = 1; + QTlowScoreDNAMarkingScale = 5; + distanceTree = true; // MARK: I set to default value. + + numIterations = 3; + + if(getDNAFlag()) + { + setDNAParams(); + } + else + { + setProtParams(); + } + + clusterAlgorithm = NJ; + displayInfo = true; + helpFlag = false; + fullHelpFlag = false; + quiet = false; + doRemoveFirstIteration = NONE; + maxAllowedSeqLength = INT_MAX; +} + +/* + * The function createParameterOutput is used to put all the user parameters in + * a file. It is used for testing and for saving parameters. + * + * + * FIXME: AW: Some parameters are missing here (e.g. the new ones like + * clustering, etc) + * + */ +void UserParameters::createParameterOutput(void) +{ + string parname, temp; + string path; + string message; + + utilityObject->getPath(seqName, &path); + parname = path + "par"; + if(menuFlag) + { + message = "\nEnter a name for the parameter output file [" + parname + "]"; + utilityObject->getStr(message, temp); + if(temp != "") + { + parname = temp; + } + } + + ofstream outfile; + outfile.open(parname.c_str(), ofstream::out); + + if(!outfile) + { + return; // Failed to open + } + + outfile << "clustalw \\\n"; + if (!empty && profile1Empty) + { + outfile << "-infile=" << seqName << " \\\n"; + } + if (!profile1Empty) + { + outfile << "-profile1=" << profile1Name << "\\\n"; + } + if (!profile2Empty) + { + outfile << "-profile2=" << profile2Name << " \\\n"; + } + if (DNAFlag == true) + { + outfile << "-type=dna \\\n"; + } + else + { + outfile << "-type=protein \\\n"; + } + if (quickPairAlign) + { + outfile << "-quicktree \\\n"; + outfile << "-ktuple=" << ktup << " \\\n"; + outfile << "-window=" << window << " \\\n"; + outfile << "-pairgap=" << windowGap << " \\\n"; + outfile << "-topdiags=" << signif << " \\\n"; + if (percent) + { + outfile << "-score=percent \\\n"; + } + else + { + outfile << "-score=absolute \\\n"; + } + } + else + { + if (!DNAFlag) + { + //outfile << "-pwmatrix=" << pwMatrixName << " \\\n"; + outfile << "-pwgapopen=" << fixed << setprecision(2) << AAPWGapOpen + << " \\\n"; + outfile << "-pwgapext=" << AAPWGapExtend << " \\\n"; + } + else + { + outfile << "-pwgapopen=" << fixed << setprecision(2) << PWGapOpen << " \\\n"; + outfile << "-pwgapext=" << PWGapExtend << " \\\n"; + } + } + + if (!DNAFlag) + { + //outfile << "-matrix=" << matrixName << " \\\n"; + outfile << "-gapopen=" << fixed << setprecision(2) << AAGapOpen << " \\\n"; + outfile << "-gapext=" << AAGapExtend << " \\\n"; + } + else + { + outfile << "-gapopen=" << fixed << setprecision(2) << DNAGapOpen << " \\\n"; + outfile << "-gapext=" << DNAGapExtend << " \\\n"; + } + + outfile << "-maxdiv=" << divergenceCutoff << " \\\n"; + if (!useEndGaps) + { + outfile << "-endgaps \\\n"; + } + + if (!DNAFlag) + { + if (negMatrix) + { + outfile << "-negative \\\n"; + } + if (noPrefPenalties) + { + outfile << "-nopgap \\\n"; + } + if (noHydPenalties) + { + outfile << "-nohgap \\\n"; + } + if (noVarPenalties) + { + outfile << "-novgap \\\n"; + } + outfile << "-hgapresidues=" << hydResidues << " \\\n"; + outfile << "-gapdist=" << gapDist << " \\\n"; + } + else + { + outfile << "-transweight=" << transitionWeight << " \\\n"; + } + + if (outputGcg) + { + outfile << "-output=gcg \\\n"; + } + else if (outputGde) + { + outfile << "-output=gde \\\n"; + } + else if (outputNbrf) + { + outfile << "-output=pir \\\n"; + } + else if (outputPhylip) + { + outfile << "-output=phylip \\\n"; + } + else if (outputNexus) + { + outfile << "-output=nexus \\\n"; + } + if (outfileName[0]!=EOS) + { + outfile << "-outfile=" << outfileName << " \\\n"; + } + if (outputOrder==ALIGNED) + { + outfile << "-outorder=aligned \\\n"; + } + else + { + outfile << "-outorder=input \\\n"; + } + if (outputGde) + { + if (lowercase) + { + outfile << "-case=lower \\\n"; + } + else + { + outfile << "-case=upper \\\n"; + } + } + + + outfile << "-interactive\n"; + + outfile.close(); + +} + +/* + * The function resIndex returns the index of the character c in the string t. + * + */ +int UserParameters::resIndex(string t, char c) +{ + register int i; + + for (i = 0; t[i] && t[i] != c; i++) + ; + if (t[i]) + { + return (i); + } + else + { + return -1; + } +} + +void UserParameters::setDNAMultiGap() +{ + gapOpen = DNAGapOpen; + gapExtend = DNAGapExtend; +} + +void UserParameters::setProtMultiGap() +{ + gapOpen = AAGapOpen; + gapExtend = AAGapExtend; +} + +void UserParameters::setDNAParams() +{ + gapOpen = DNAGapOpen; + gapExtend = DNAGapExtend; + PWGapOpen = DNAPWGapOpen; + PWGapExtend = DNAPWGapExtend; + ktup = DNAKtup; + window = DNAWindow; + signif = DNASignif; + windowGap = DNAWindowGap; +} + +void UserParameters::setProtParams() +{ + gapOpen = AAGapOpen; + gapExtend = AAGapExtend; + PWGapOpen = AAPWGapOpen; + PWGapExtend = AAPWGapExtend; + ktup = AAKtup; + window = AAWindow; + signif = AASignif; + windowGap = AAWindowGap; +} + +void UserParameters::setPWParamToProtein() +{ + PWGapOpen = AAPWGapOpen; + PWGapExtend = AAPWGapExtend; + ktup = AAKtup; + window = AAWindow; + signif = AASignif; + windowGap = AAWindowGap; +} + +void UserParameters::setPWParamToDNA() +{ + PWGapOpen = DNAPWGapOpen; + PWGapExtend = DNAPWGapExtend; + ktup = DNAKtup; + window = DNAWindow; + signif = DNASignif; + windowGap = DNAWindowGap; +} + +void UserParameters::setPWProteinParam() +{ + AAPWGapOpen = PWGapOpen; + AAPWGapExtend = PWGapExtend; + AAKtup = ktup; + AAWindow = window; + AASignif = signif; + AAWindowGap = windowGap; +} + +void UserParameters::setPWDNAParam() +{ + DNAPWGapOpen = PWGapOpen; + DNAPWGapExtend = PWGapExtend; + DNAKtup = ktup; + DNAWindow = window; + DNASignif = signif; + DNAWindowGap = windowGap; +} +/* + * The rest of the functions are get, set and toggle functions for the variables. + */ + +string UserParameters::getRevisionLevel() +{ + return revisionLevel; +} + +void UserParameters::setRevisionLevel(string value) +{ + revisionLevel = value; +} + +void UserParameters::setInteractive(bool value) +{ + interactive = value; +} + +void UserParameters::setGapOpen(float value) +{ + gapOpen = value; +} + +void UserParameters::setGapExtend(float value) +{ + gapExtend = value; +} + +void UserParameters::setPWGapOpen(float value) +{ + PWGapOpen = value; +} + +void UserParameters::setPWGapExtend(float value) +{ + PWGapExtend = value; +} + +void UserParameters::setMaxAA(int value) +{ + maxAA = value; +} + +void UserParameters::setGapPos1(int value) +{ + gapPos1 = value; +} + +void UserParameters::setGapPos2(int value) +{ + gapPos2 = value; +} + +void UserParameters::setProfileNum(int value) +{ + profileNum = value; +} + +void UserParameters::setMenuFlag(bool value) +{ + menuFlag = value; +} + +void UserParameters::setDNAFlag(bool value) +{ + if(value == true) + { + setDNAParams(); + } + else + { + setProtParams(); + } + DNAFlag = value; +} + +void UserParameters::setDistanceTree(bool value) +{ + distanceTree = value; +} + +void UserParameters::setSeqName(string value) +{ + seqName = value; +} + +void UserParameters::setDNAGapOpen(float value) +{ + DNAGapOpen = value; +} + +void UserParameters::setDNAGapExtend(float value) +{ + DNAGapExtend = value; +} + +void UserParameters::setProteinGapOpen(float value) +{ + AAGapOpen = value; +} + +void UserParameters::setProteinGapExtend(float value) +{ + AAGapExtend = value; +} + +void UserParameters::setGapDist(int value) +{ + gapDist = value; +} + +void UserParameters::setOutputOrder(int value) +{ + outputOrder = value; +} + +void UserParameters::toggleOutputOrder() +{ + if (outputOrder == INPUT) + { + outputOrder = ALIGNED; + } + else + { + outputOrder = INPUT; + } +} + +void UserParameters::setDivergenceCutoff(int value) +{ + divergenceCutoff = value; +} + +void UserParameters::setHydResidues(string value) +{ + //hydResidues = value; + char hydResidue; + string tempHydRes = ""; + int inputStringLength = value.length(); + if(inputStringLength > 0) + { + // NOTE this was causing an error, but I fixed it. Was giving an + // out of range error. + for (int i = 0; i < MAXHYDRESIDUES && i < inputStringLength; i++) + { + hydResidue = toupper(value.at(i)); + + if (isalpha(hydResidue)) + { + tempHydRes += hydResidue; + } + else // Not Alphabetic character! + { + break; + } + } + if(tempHydRes.size() > 0) + { + hydResidues = tempHydRes; + } + } +} + +void UserParameters::setNoWeights(bool value) +{ + noWeights = value; +} + +void UserParameters::setUseNegMatrix(bool value) +{ + negMatrix = value; +} + +void UserParameters::toggleUseNegMatrix() +{ + negMatrix ^= true; +} + +void UserParameters::setNoHydPenalties(bool value) +{ + noHydPenalties = value; +} + +void UserParameters::toggleNoHydPenalties() +{ + noHydPenalties ^= true; +} + +void UserParameters::setNoVarPenalties(bool value) +{ + noVarPenalties = value; +} + +void UserParameters::setNoPrefPenalties(bool value) +{ + noPrefPenalties = value; +} + +void UserParameters::toggleNoPrefPenalties() +{ + noPrefPenalties ^= true; +} + +void UserParameters::setUseEndGaps(bool value) +{ + useEndGaps = value; +} + +void UserParameters::toggleUseEndGaps() +{ + useEndGaps ^= true; +} + +void UserParameters::setEndGapPenalties(bool value) +{ + endGapPenalties = value; +} + +void UserParameters::toggleResetAlignmentsNew() +{ + resetAlignmentsNew ^= true; +} + +void UserParameters::setResetAlignmentsNew(bool value) +{ + resetAlignmentsNew = value; +} + +void UserParameters::setResetAlignmentsAll(bool value) +{ + resetAlignmentsAll = value; +} + +void UserParameters::setOutputStructPenalties(int value) +{ + outputStructPenalties = value; +} + +void UserParameters::setStructPenalties1(int value) +{ + structPenalties1 = value; +} + +void UserParameters::setStructPenalties2(int value) +{ + structPenalties2 = value; +} + +void UserParameters::setUseSS1(bool value) +{ + useSS1 = value; +} + +void UserParameters::toggleUseSS1() +{ + useSS1 ^= true; +} + +void UserParameters::setUseSS2(bool value) +{ + useSS2 = value; +} + +void UserParameters::toggleUseSS2() +{ + useSS2 ^= true; +} + +void UserParameters::setHelixPenalty(int value) +{ + helixPenalty = value; +} + +void UserParameters::setStrandPenalty(int value) +{ + strandPenalty = value; +} + +void UserParameters::setLoopPenalty(int value) +{ + loopPenalty = value; +} + +void UserParameters::setHelixEndMinus(int value) +{ + helixEndMinus = value; +} + +void UserParameters::setHelixEndPlus(int value) +{ + helixEndPlus = value; +} + +void UserParameters::setStrandEndMinus(int value) +{ + strandEndMinus = value; +} + +void UserParameters::setStrandEndPlus(int value) +{ + strandEndPlus = value; +} + +void UserParameters::setHelixEndPenalty(int value) +{ + helixEndPenalty = value; +} + +void UserParameters::setStrandEndPenalty(int value) +{ + strandEndPenalty = value; +} + +void UserParameters::setUseAmbiguities(bool value) +{ + useAmbiguities = value; +} + +void UserParameters::setDNAPWGapOpenPenalty(float value) +{ + DNAPWGapOpen = value; +} + +void UserParameters::setDNAPWGapExtendPenalty(float value) +{ + DNAPWGapExtend = value; +} + +void UserParameters::setProteinPWGapOpenPenalty(float value) +{ + AAPWGapOpen = value; +} + +void UserParameters::setProteinPWGapExtendPenalty(float value) +{ + AAPWGapExtend = value; +} + +void UserParameters::toggleQuickPairAlign() +{ + quickPairAlign ^= true; +} + +void UserParameters::setQuickPairAlign(bool value) +{ + quickPairAlign = value; +} + +void UserParameters::setTransitionWeight(float value) +{ + transitionWeight = value; +} + +void UserParameters::setDNAKtup(int value) +{ + DNAKtup = value; +} + +void UserParameters::setDNAWindowGap(int value) +{ + DNAWindowGap = value; +} + +void UserParameters::setDNASignif(int value) +{ + DNASignif = value; +} + +void UserParameters::setDNAWindow(int value) +{ + DNAWindow = value; +} + +void UserParameters::setAAKtup(int value) +{ + AAKtup = value; +} + +void UserParameters::setAAWindowGap(int value) +{ + AAWindowGap = value; +} + +void UserParameters::setAASignif(int value) +{ + AASignif = value; +} + +void UserParameters::setAAWindow(int value) +{ + AAWindow = value; +} + +void UserParameters::setPercent(bool value) +{ + percent = value; +} + +void UserParameters::toggleTossGaps() +{ + tossgaps ^= true; +} + +void UserParameters::setTossGaps(bool value) +{ + tossgaps = value; +} + +void UserParameters::setKimura(bool value) +{ + kimura = value; +} + +void UserParameters::toggleKimura() +{ + kimura ^= true; +} + +void UserParameters::setBootNumTrials(int value) +{ + bootNumTrials = value; +} + +void UserParameters::setBootRanSeed(unsigned int value) +{ + bootRanSeed = value; +} + +void UserParameters::setDebug(int value) +{ + debug = value; +} + +void UserParameters::setExplicitDNAFlag(bool value) +{ + explicitDNAFlag = value; +} + +void UserParameters::setLowercase(bool value) +{ + lowercase = value; +} + +void UserParameters::toggleLowercase() +{ + lowercase ^= true; +} + +void UserParameters::setClSeqNumbers(bool value) +{ + clSeqNumbers = value; +} + +void UserParameters::toggleClSeqNumbers() +{ + clSeqNumbers ^= true; +} + +void UserParameters::setSeqRange(bool value) +{ + seqRange = value; +} + +void UserParameters::toggleSeqRange() +{ + seqRange ^= true; +} + +void UserParameters::setOutputClustal(bool value) +{ + outputClustal = value; +} + +void UserParameters::toggleOutputClustal() +{ + outputClustal ^= true; +} + +void UserParameters::setOutputGCG(bool value) +{ + outputGcg = value; +} + +void UserParameters::toggleOutputGCG() +{ + outputGcg ^= true; +} + +void UserParameters::setOutputPhylip(bool value) +{ + outputPhylip = value; +} + +void UserParameters::toggleOutputPhylip() +{ + outputPhylip ^= true; +} + +void UserParameters::setOutputNbrf(bool value) +{ + outputNbrf = value; +} + +void UserParameters::toggleOutputNbrf() +{ + outputNbrf ^= true; +} + +void UserParameters::setOutputGde(bool value) +{ + outputGde = value; +} + +void UserParameters::toggleOutputGde() +{ + outputGde ^= true; +} + +void UserParameters::setOutputNexus(bool value) +{ + outputNexus = value; +} + +void UserParameters::toggleOutputNexus() +{ + outputNexus ^= true; +} + +void UserParameters::setOutputFasta(bool value) +{ + outputFasta = value; +} + +void UserParameters::toggleOutputFasta() +{ + outputFasta ^= true; +} + +void UserParameters::setShowAlign(bool value) +{ + showAlign = value; +} + +void UserParameters::toggleShowAlign() +{ + showAlign ^= true; +} + +void UserParameters::setSaveParameters(bool value) +{ + saveParameters = value; +} + +void UserParameters::toggleSaveParameters() +{ + saveParameters ^= true; +} + +void UserParameters::setOutputTreeClustal(bool value) +{ + outputTreeClustal = value; +} + +void UserParameters::toggleOutputTreeClustal() +{ + outputTreeClustal ^= true; +} + +void UserParameters::setOutputTreePhylip(bool value) +{ + outputTreePhylip = value; +} + +void UserParameters::toggleOutputTreePhylip() +{ + outputTreePhylip ^= true; +} + +void UserParameters::setOutputTreeDistances(bool value) +{ + outputTreeDistances = value; +} + +void UserParameters::toggleOutputTreeDistances() +{ + outputTreeDistances ^= true; +} + +void UserParameters::setOutputTreeNexus(bool value) +{ + outputTreeNexus = value; +} + +void UserParameters::toggleOutputTreeNexus() +{ + outputTreeNexus ^= true; +} + +void UserParameters::setOutputPim(bool value) +{ + outputPim = value; +} + +void UserParameters::setBootstrapFormat(int value) +{ + bootstrapFormat = value; +} + +void UserParameters::toggleBootstrapFormat() +{ + if (bootstrapFormat == BS_NODE_LABELS) + { + bootstrapFormat = BS_BRANCH_LABELS; + } + else + { + bootstrapFormat = BS_NODE_LABELS; + } +} + +void UserParameters::setProfile1Name(string value) +{ + profile1Name = value; +} + +void UserParameters::setProfile2Name(string value) +{ + profile2Name = value; +} + +void UserParameters::setEmpty(bool value) +{ + empty = value; +} + +void UserParameters::setProfile1Empty(bool value) +{ + profile1Empty = value; +} + +void UserParameters::setProfile2Empty(bool value) +{ + profile2Empty = value; +} + +void UserParameters::setOutfileName(string value) +{ + outfileName = value; +} + +/*void UserParameters::setProfile1NumSeqs(int value) +{ + profile1NumSeqs = value; +}*/ // MARK CHANGE Jan 10 + +void UserParameters::setUseTreeFile(bool value) +{ + useTreeFile = value; +} + +void UserParameters::setNewTreeFile(bool value) +{ + newTreeFile = value; +} + +void UserParameters::setUseTree1File(bool value) +{ + useTree1File = value; +} + +void UserParameters::setUseTree2File(bool value) +{ + useTree2File = value; +} + +void UserParameters::setNewTree1File(bool value) +{ + newTree1File = value; +} + +void UserParameters::setNewTree2File(bool value) +{ + newTree2File = value; +} + +void UserParameters::setAminoAcidCodes(string value) +{ + aminoAcidCodes = value; +} + +void UserParameters::setKtup(int value) +{ + ktup = value; +} + +void UserParameters::setWindow(int value) +{ + window = value; +} + +void UserParameters::setWindowGap(int value) +{ + windowGap = value; +} + +void UserParameters::setSignif(int value) +{ + signif = value; +} + +void UserParameters::setRangeFrom(int from) +{ + rangeFrom = from; + rangeFromToSet = true; +} + +void UserParameters::setRangeTo(int to) +{ + rangeTo = to; + rangeFromToSet = true; +} + +int UserParameters::getQTScorePlotScale() +{ + return QTscorePlotScale; +} + +void UserParameters::setQTScorePlotScale(int score) +{ + QTscorePlotScale = score; +} + +int UserParameters::getQTResExceptionCutOff() +{ + return QTresExceptionCutOff; +} + +void UserParameters::setQTResExceptionCutOff(int cutOff) +{ + QTresExceptionCutOff = cutOff; +} + +bool UserParameters::getQTseqWeightCalculated() +{ + return QTseqWeightCalculated; +} + +void UserParameters::setQTseqWeightCalculated(bool calculated) +{ + QTseqWeightCalculated = calculated; +} + +int UserParameters::getQTminLenLowScoreSegment() +{ + return QTminLenLowScoreSegment; +} + +void UserParameters::setQTminLenLowScoreSegment(int minLen) +{ + QTminLenLowScoreSegment = minLen; +} + +int UserParameters::getQTlowScoreDNAMarkingScale() +{ + return QTlowScoreDNAMarkingScale; +} + +void UserParameters::setQTlowScoreDNAMarkingScale(int dnaScale) +{ + QTlowScoreDNAMarkingScale = dnaScale; +} + +bool UserParameters::IterationIsEnabled() +{ + if (doRemoveFirstIteration == clustalw::NONE) + return false; + else + return true; +} +} + + + +