binaries/src/clustalw/src/general/UserParameters.cpp

   1 /**
   2  * Author: Mark Larkin
   3  *
   4  * Copyright (c) 2007 Des Higgins, Julie Thompson and Toby Gibson.
   5  */
   6 /**
   7  * This file contains the implementation of the UserParameter functions
   8  * Mark Larkin Dec 8 2005
   9  *
  10  * Modified: 17 January 2008 Paul McGettigan added in the O aminoacid residue to handle Pyrrolysine
  11  */
  12 #ifdef HAVE_CONFIG_H
  13     #include "config.h"
  14 #endif
  15 #include <stdio.h>
  16 #include <string>
  17 #include <cstdlib>
  18 #include <exception>
  19 #include <iostream>
  20 #include <limits>
  21 #include <climits>
  22 #include <iomanip>
  23 #include <fstream>
  24 #include "UserParameters.h"
  25 #include "clustalw_version.h"
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29 namespace clustalw
  30 {
  31 using namespace std;
  32
  33 UserParameters::UserParameters(bool log)
  34 {
  35    // FIXME: huge parts should be merged/replaced with
  36    // setParamsToDefault (which is not used at all)
  37
  38     gapPos1 = NUMRES - 2; /* code for gaps inserted by clustalw */
  39     gapPos2 = NUMRES - 1; /* code for gaps already in alignment */
  40
  41     //revisionLevel = CLU_SHORT_VERSION_STRING;
  42     revisionLevel = CLUSTALW_VERSION;
  43     interactive = false;
  44
  45     seqName = "";
  46     DNAGapOpen = 15.0;
  47     DNAGapExtend = 6.66;
  48     AAGapOpen = 10.0;
  49     AAGapExtend = 0.2;
  50     gapDist = 4;
  51     outputOrder = ALIGNED; // Note: All macros should be replaced by const
  52     divergenceCutoff = 30;
  53
  54     hydResidues = "GPSNDQEKR";
  55     noWeights = false;
  56     negMatrix = false;
  57     noHydPenalties = false;
  58     noVarPenalties = true;
  59     noPrefPenalties = false;
  60     useEndGaps = false;
  61     endGapPenalties = false;
  62     resetAlignmentsNew = false;
  63     resetAlignmentsAll = false;
  64     outputStructPenalties = OUTSECST;
  65     structPenalties1 = NONE;
  66     structPenalties2 = NONE;
  67     useSS1 = true;
  68     useSS2 = true;
  69     helixPenalty = 4;
  70     strandPenalty = 4;
  71     loopPenalty = 1;
  72     helixEndMinus = 3;
  73     helixEndPlus = 0;
  74     strandEndMinus = 1;
  75     strandEndPlus = 1;
  76     helixEndPenalty = 2;
  77     strandEndPenalty = 2;
  78     useAmbiguities = false;
  79     DNAPWGapOpen = 15.0;
  80     DNAPWGapExtend = 6.66;
  81     AAPWGapOpen = 10.0;
  82     AAPWGapExtend = 0.1;
  83
  84     quickPairAlign = false;
  85     transitionWeight = 0.5;
  86     DNAKtup = 2;
  87     DNAWindowGap = 5;
  88     DNASignif = 4;
  89     DNAWindow = 4;
  90     AAKtup = 1;
  91     AAWindowGap = 3;
  92     AASignif = 5;
  93     AAWindow = 5;
  94     percent = true;
  95     tossgaps = false;
  96     kimura = false;
  97     bootNumTrials = 1000;
  98     bootRanSeed = 111;
  99     debug = 0;
 100     explicitDNAFlag = false;
 101     lowercase = true;
 102     clSeqNumbers = false;
 103     seqRange = false;
 104     outputClustal = true;
 105     outputGcg = false;
 106     outputPhylip = false;
 107     outputNbrf = false;
 108     outputGde = false;
 109     outputNexus = false;
 110     outputFasta = false;
 111     showAlign = true;
 112     saveParameters = false;
 113     outputTreeClustal = false;
 114     outputTreePhylip = true;
 115     outputTreeDistances = false;
 116     outputTreeNexus = false;
 117     outputPim = false;
 118     bootstrapFormat = BS_BRANCH_LABELS;
 119     profile1Name = ""; // Initialise to blank strings
 120     profile2Name = "";
 121     empty = true;
 122     profile1Empty = true;
 123     profile2Empty = true;
 124     outfileName = "";
 125     //profile1NumSeqs = 0; // MARK: Set to default before used.
 126     useTreeFile = false;
 127     newTreeFile = false;
 128     useTree1File = false;
 129     useTree2File = false;
 130     newTree1File = false;
 131     newTree2File = false;
 132     aminoAcidCodes = "ABCDEFGHIKLMNOPQRSTUVWXYZ-";
 133     maxAA = aminoAcidCodes.length() - 2;
 134
 135     // Some variables need the alignment to be read in before they can be set.
 136     // I am putting the default as protein. Note: this should not make a difference
 137     // as they are not used before they have been set a value again!!
 138
 139     gapOpen = AAGapOpen;
 140     gapExtend = AAGapExtend;
 141     PWGapOpen = AAPWGapOpen;
 142     PWGapExtend = AAPWGapExtend;
 143
 144     gapPos1 = NUMRES - 2;
 145     gapPos2 = NUMRES - 1;
 146     profileNum = 0;
 147     menuFlag = false; // MARK: I set to default value.
 148     DNAFlag = false; // MARK: I set to default value.
 149     distanceTree = true; // MARK: I set to default value.
 150     ktup = AAKtup;
 151     window = AAWindow;
 152     windowGap = AAWindowGap;
 153     signif = AASignif;
 154     rangeFrom = -1;
 155     rangeTo = -1;
 156     rangeFromToSet = false;
 157     QTscorePlotScale = 5;
 158     QTresExceptionCutOff = 5;
 159
 160     QTseqWeightCalculated = false;
 161     QTminLenLowScoreSegment = 1;
 162     QTlowScoreDNAMarkingScale = 5;
 163
 164     // Set defaults for iteration variables.
 165     numIterations = 3;
 166     doRemoveFirstIteration = NONE;
 167     maxAllowedSeqLength = INT_MAX;
 168
 169     clusterAlgorithm = NJ;
 170     displayInfo = true;
 171     helpFlag = false;
 172     fullHelpFlag = false;
 173     quiet = false;
 174
 175 }
 176
 177 // FIXME:never used
 178 void UserParameters::setParamsToDefault()
 179 {
 180     DNAGapOpen = 15.0;
 181     DNAGapExtend = 6.66;
 182     AAGapOpen = 10.0;
 183     AAGapExtend = 0.2;
 184     gapDist = 4;
 185     outputOrder = ALIGNED;
 186     divergenceCutoff = 30;
 187
 188     hydResidues = "GPSNDQEKR";
 189     noWeights = false;
 190     negMatrix = false;
 191     noHydPenalties = false;
 192     noVarPenalties = true;
 193     noPrefPenalties = false;
 194     useEndGaps = false;
 195     endGapPenalties = false;
 196     resetAlignmentsNew = false;
 197     resetAlignmentsAll = false;
 198     outputStructPenalties = OUTSECST;
 199     structPenalties1 = NONE;
 200     structPenalties2 = NONE;
 201     useSS1 = true;
 202     useSS2 = true;
 203     helixPenalty = 4;
 204     strandPenalty = 4;
 205     loopPenalty = 1;
 206     helixEndMinus = 3;
 207     helixEndPlus = 0;
 208     strandEndMinus = 1;
 209     strandEndPlus = 1;
 210     helixEndPenalty = 2;
 211     strandEndPenalty = 2;
 212     useAmbiguities = false;
 213     DNAPWGapOpen = 15.0;
 214     DNAPWGapExtend = 6.66;
 215     AAPWGapOpen = 10.0;
 216     AAPWGapExtend = 0.1;
 217     quickPairAlign = false;
 218     transitionWeight = 0.5;
 219     DNAKtup = 2;
 220     DNAWindowGap = 5;
 221     DNASignif = 4;
 222     DNAWindow = 4;
 223     AAKtup = 1;
 224     AAWindowGap = 3;
 225     AASignif = 5;
 226     AAWindow = 5;
 227     percent = true;
 228     tossgaps = false;
 229     kimura = false;
 230     bootNumTrials = 1000;
 231     bootRanSeed = 111;
 232     debug = 0;
 233     lowercase = true;
 234     clSeqNumbers = false;
 235     seqRange = false;
 236     outputClustal = true;
 237     outputGcg = false;
 238     outputPhylip = false;
 239     outputNbrf = false;
 240     outputGde = false;
 241     outputNexus = false;
 242     outputFasta = false;
 243     outputTreeClustal = false;
 244     outputTreePhylip = true;
 245     outputTreeDistances = false;
 246     outputTreeNexus = false;
 247     outputPim = false;
 248     bootstrapFormat = BS_BRANCH_LABELS;
 249     useTreeFile = false;
 250     newTreeFile = false;
 251     useTree1File = false;
 252     useTree2File = false;
 253     newTree1File = false;
 254     newTree2File = false;
 255     rangeFrom = -1;
 256     rangeTo = -1;
 257     rangeFromToSet = false;
 258     QTscorePlotScale = 5;
 259     QTresExceptionCutOff = 5;
 260
 261     QTminLenLowScoreSegment = 1;
 262     QTlowScoreDNAMarkingScale = 5;
 263     distanceTree = true; // MARK: I set to default value.
 264
 265     numIterations = 3;
 266
 267     if(getDNAFlag())
 268     {
 269         setDNAParams();
 270     }
 271     else
 272     {
 273         setProtParams();
 274     }
 275
 276     clusterAlgorithm = NJ;
 277     displayInfo = true;
 278     helpFlag = false;
 279     fullHelpFlag = false;
 280     quiet = false;
 281     doRemoveFirstIteration = NONE;
 282     maxAllowedSeqLength = INT_MAX;
 283 }
 284
 285 /*
 286  * The function createParameterOutput is used to put all the user parameters in
 287  * a file. It is used for testing and for saving parameters.
 288  *
 289  *
 290  * FIXME: AW: Some parameters are missing here (e.g. the new ones like
 291  * clustering, etc)
 292  *
 293  */
 294 void UserParameters::createParameterOutput(void)
 295 {
 296     string parname, temp;
 297     string path;
 298     string message;
 299
 300     utilityObject->getPath(seqName, &path);
 301     parname = path + "par";
 302     if(menuFlag)
 303     {
 304         message = "\nEnter a name for the parameter output file [" + parname + "]";
 305         utilityObject->getStr(message, temp);
 306         if(temp != "")
 307         {
 308             parname = temp;
 309         }
 310     }
 311
 312     ofstream outfile;
 313     outfile.open(parname.c_str(), ofstream::out);
 314
 315     if(!outfile)
 316     {
 317         return; // Failed to open
 318     }
 319
 320     outfile << "clustalw \\\n";
 321     if (!empty && profile1Empty)
 322     {
 323         outfile << "-infile=" << seqName << " \\\n";
 324     }
 325     if (!profile1Empty)
 326     {
 327         outfile << "-profile1=" << profile1Name << "\\\n";
 328     }
 329     if (!profile2Empty)
 330     {
 331         outfile << "-profile2=" << profile2Name << " \\\n";
 332     }
 333     if (DNAFlag == true)
 334     {
 335         outfile << "-type=dna \\\n";
 336     }
 337     else
 338     {
 339         outfile << "-type=protein \\\n";
 340     }
 341     if (quickPairAlign)
 342     {
 343         outfile << "-quicktree \\\n";
 344         outfile << "-ktuple=" << ktup << " \\\n";
 345         outfile << "-window=" << window << " \\\n";
 346         outfile << "-pairgap=" << windowGap << " \\\n";
 347         outfile << "-topdiags=" << signif << " \\\n";
 348         if (percent)
 349         {
 350             outfile << "-score=percent \\\n";
 351         }
 352         else
 353         {
 354             outfile << "-score=absolute \\\n";
 355         }
 356     }
 357     else
 358     {
 359         if (!DNAFlag)
 360         {
 361             //outfile << "-pwmatrix=" << pwMatrixName << " \\\n";
 362             outfile << "-pwgapopen=" << fixed << setprecision(2) << AAPWGapOpen
 363                     << " \\\n";
 364             outfile << "-pwgapext=" << AAPWGapExtend << " \\\n";
 365         }
 366         else
 367         {
 368             outfile << "-pwgapopen=" << fixed << setprecision(2) << PWGapOpen << " \\\n";
 369             outfile << "-pwgapext=" << PWGapExtend << " \\\n";
 370         }
 371     }
 372
 373     if (!DNAFlag)
 374     {
 375         //outfile << "-matrix=" << matrixName << " \\\n";
 376         outfile << "-gapopen=" << fixed << setprecision(2) << AAGapOpen << " \\\n";
 377         outfile << "-gapext=" << AAGapExtend << " \\\n";
 378     }
 379     else
 380     {
 381         outfile << "-gapopen=" << fixed << setprecision(2) << DNAGapOpen << " \\\n";
 382         outfile << "-gapext=" << DNAGapExtend << " \\\n";
 383     }
 384
 385     outfile << "-maxdiv=" << divergenceCutoff << " \\\n";
 386     if (!useEndGaps)
 387     {
 388         outfile << "-endgaps \\\n";
 389     }
 390
 391     if (!DNAFlag)
 392     {
 393         if (negMatrix)
 394         {
 395             outfile << "-negative \\\n";
 396         }
 397         if (noPrefPenalties)
 398         {
 399             outfile << "-nopgap \\\n";
 400         }
 401         if (noHydPenalties)
 402         {
 403             outfile << "-nohgap \\\n";
 404         }
 405         if (noVarPenalties)
 406         {
 407             outfile << "-novgap \\\n";
 408         }
 409         outfile << "-hgapresidues=" << hydResidues << " \\\n";
 410         outfile << "-gapdist=" << gapDist << " \\\n";
 411     }
 412     else
 413     {
 414         outfile << "-transweight=" << transitionWeight << " \\\n";
 415     }
 416
 417     if (outputGcg)
 418     {
 419         outfile << "-output=gcg \\\n";
 420     }
 421     else if (outputGde)
 422     {
 423         outfile << "-output=gde \\\n";
 424     }
 425     else if (outputNbrf)
 426     {
 427         outfile << "-output=pir \\\n";
 428     }
 429     else if (outputPhylip)
 430     {
 431         outfile << "-output=phylip \\\n";
 432     }
 433     else if (outputNexus)
 434     {
 435         outfile << "-output=nexus \\\n";
 436     }
 437     if (outfileName[0]!=EOS)
 438     {
 439         outfile << "-outfile=" << outfileName << " \\\n";
 440     }
 441     if (outputOrder==ALIGNED)
 442     {
 443         outfile << "-outorder=aligned \\\n";
 444     }
 445     else
 446     {
 447         outfile << "-outorder=input \\\n";
 448     }
 449     if (outputGde)
 450     {
 451         if (lowercase)
 452         {
 453             outfile << "-case=lower \\\n";
 454         }
 455         else
 456         {
 457             outfile << "-case=upper \\\n";
 458         }
 459     }
 460
 461
 462     outfile << "-interactive\n";
 463
 464     outfile.close();
 465
 466 }
 467
 468 /*
 469  * The function resIndex returns the index of the character c in the string t.
 470  *
 471  */
 472 int UserParameters::resIndex(string t, char c)
 473 {
 474     register int i;
 475
 476     for (i = 0; t[i] && t[i] != c; i++)
 477         ;
 478     if (t[i])
 479     {
 480         return (i);
 481     }
 482     else
 483     {
 484         return  -1;
 485     }
 486 }
 487
 488 void UserParameters::setDNAMultiGap()
 489 {
 490     gapOpen = DNAGapOpen;
 491     gapExtend = DNAGapExtend;
 492 }
 493
 494 void UserParameters::setProtMultiGap()
 495 {
 496     gapOpen = AAGapOpen;
 497     gapExtend = AAGapExtend;
 498 }
 499
 500 void UserParameters::setDNAParams()
 501 {
 502     gapOpen       = DNAGapOpen;
 503     gapExtend     = DNAGapExtend;
 504     PWGapOpen  = DNAPWGapOpen;
 505     PWGapExtend  = DNAPWGapExtend;
 506     ktup           = DNAKtup;
 507     window         = DNAWindow;
 508     signif         = DNASignif;
 509     windowGap       = DNAWindowGap;
 510 }
 511
 512 void UserParameters::setProtParams()
 513 {
 514     gapOpen       = AAGapOpen;
 515     gapExtend     = AAGapExtend;
 516     PWGapOpen  = AAPWGapOpen;
 517     PWGapExtend  = AAPWGapExtend;
 518     ktup           = AAKtup;
 519     window         = AAWindow;
 520     signif         = AASignif;
 521     windowGap       = AAWindowGap;
 522 }
 523
 524 void UserParameters::setPWParamToProtein()
 525 {
 526     PWGapOpen = AAPWGapOpen;
 527     PWGapExtend = AAPWGapExtend;
 528     ktup = AAKtup;
 529     window = AAWindow;
 530     signif = AASignif;
 531     windowGap = AAWindowGap;
 532 }
 533
 534 void UserParameters::setPWParamToDNA()
 535 {
 536     PWGapOpen = DNAPWGapOpen;
 537     PWGapExtend = DNAPWGapExtend;
 538     ktup = DNAKtup;
 539     window = DNAWindow;
 540     signif = DNASignif;
 541     windowGap = DNAWindowGap;
 542 }
 543
 544 void UserParameters::setPWProteinParam()
 545 {
 546     AAPWGapOpen = PWGapOpen;
 547     AAPWGapExtend = PWGapExtend;
 548     AAKtup = ktup;
 549     AAWindow = window;
 550     AASignif = signif;
 551     AAWindowGap = windowGap;
 552 }
 553
 554 void UserParameters::setPWDNAParam()
 555 {
 556     DNAPWGapOpen = PWGapOpen;
 557     DNAPWGapExtend = PWGapExtend;
 558     DNAKtup = ktup;
 559     DNAWindow = window;
 560     DNASignif = signif;
 561     DNAWindowGap = windowGap;
 562 }
 563 /*
 564  * The rest of the functions are get, set and toggle functions for the variables.
 565  */
 566
 567 string UserParameters::getRevisionLevel()
 568 {
 569     return revisionLevel;
 570 }
 571
 572 void UserParameters::setRevisionLevel(string value)
 573 {
 574     revisionLevel = value;
 575 }
 576
 577 void UserParameters::setInteractive(bool value)
 578 {
 579     interactive = value;
 580 }
 581
 582 void UserParameters::setGapOpen(float value)
 583 {
 584     gapOpen = value;
 585 }
 586
 587 void UserParameters::setGapExtend(float value)
 588 {
 589     gapExtend = value;
 590 }
 591
 592 void UserParameters::setPWGapOpen(float value)
 593 {
 594     PWGapOpen = value;
 595 }
 596
 597 void UserParameters::setPWGapExtend(float value)
 598 {
 599     PWGapExtend = value;
 600 }
 601
 602 void UserParameters::setMaxAA(int value)
 603 {
 604     maxAA = value;
 605 }
 606
 607 void UserParameters::setGapPos1(int value)
 608 {
 609     gapPos1 = value;
 610 }
 611
 612 void UserParameters::setGapPos2(int value)
 613 {
 614     gapPos2 = value;
 615 }
 616
 617 void UserParameters::setProfileNum(int value)
 618 {
 619     profileNum = value;
 620 }
 621
 622 void UserParameters::setMenuFlag(bool value)
 623 {
 624     menuFlag = value;
 625 }
 626
 627 void UserParameters::setDNAFlag(bool value)
 628 {
 629     if(value == true)
 630     {
 631         setDNAParams();
 632     }
 633     else
 634     {
 635         setProtParams();
 636     }
 637     DNAFlag = value;
 638 }
 639
 640 void UserParameters::setDistanceTree(bool value)
 641 {
 642     distanceTree = value;
 643 }
 644
 645 void UserParameters::setSeqName(string value)
 646 {
 647     seqName = value;
 648 }
 649
 650 void UserParameters::setDNAGapOpen(float value)
 651 {
 652     DNAGapOpen = value;
 653 }
 654
 655 void UserParameters::setDNAGapExtend(float value)
 656 {
 657     DNAGapExtend = value;
 658 }
 659
 660 void UserParameters::setProteinGapOpen(float value)
 661 {
 662     AAGapOpen = value;
 663 }
 664
 665 void UserParameters::setProteinGapExtend(float value)
 666 {
 667     AAGapExtend = value;
 668 }
 669
 670 void UserParameters::setGapDist(int value)
 671 {
 672     gapDist = value;
 673 }
 674
 675 void UserParameters::setOutputOrder(int value)
 676 {
 677     outputOrder = value;
 678 }
 679
 680 void UserParameters::toggleOutputOrder()
 681 {
 682     if (outputOrder == INPUT)
 683     {
 684         outputOrder = ALIGNED;
 685     }
 686     else
 687     {
 688         outputOrder = INPUT;
 689     }
 690 }
 691
 692 void UserParameters::setDivergenceCutoff(int value)
 693 {
 694     divergenceCutoff = value;
 695 }
 696
 697 void UserParameters::setHydResidues(string value)
 698 {
 699     //hydResidues = value;
 700     char hydResidue;
 701     string tempHydRes = "";
 702     int inputStringLength = value.length();
 703     if(inputStringLength > 0)
 704     {
 705     // NOTE this was causing an error, but I fixed it. Was giving an
 706     // out of range error.
 707         for (int i = 0; i < MAXHYDRESIDUES && i < inputStringLength; i++)
 708         {
 709             hydResidue = toupper(value.at(i));
 710
 711             if (isalpha(hydResidue))
 712             {
 713                 tempHydRes += hydResidue;
 714             }
 715             else // Not Alphabetic character!
 716             {
 717                 break;
 718             }
 719         }
 720         if(tempHydRes.size() > 0)
 721         {
 722             hydResidues = tempHydRes;
 723         }
 724     }
 725 }
 726
 727 void UserParameters::setNoWeights(bool value)
 728 {
 729     noWeights = value;
 730 }
 731
 732 void UserParameters::setUseNegMatrix(bool value)
 733 {
 734     negMatrix = value;
 735 }
 736
 737 void UserParameters::toggleUseNegMatrix()
 738 {
 739     negMatrix ^= true;
 740 }
 741
 742 void UserParameters::setNoHydPenalties(bool value)
 743 {
 744     noHydPenalties = value;
 745 }
 746
 747 void UserParameters::toggleNoHydPenalties()
 748 {
 749     noHydPenalties ^= true;
 750 }
 751
 752 void UserParameters::setNoVarPenalties(bool value)
 753 {
 754     noVarPenalties = value;
 755 }
 756
 757 void UserParameters::setNoPrefPenalties(bool value)
 758 {
 759     noPrefPenalties = value;
 760 }
 761
 762 void UserParameters::toggleNoPrefPenalties()
 763 {
 764     noPrefPenalties ^= true;
 765 }
 766
 767 void UserParameters::setUseEndGaps(bool value)
 768 {
 769     useEndGaps = value;
 770 }
 771
 772 void UserParameters::toggleUseEndGaps()
 773 {
 774     useEndGaps ^= true;
 775 }
 776
 777 void UserParameters::setEndGapPenalties(bool value)
 778 {
 779     endGapPenalties = value;
 780 }
 781
 782 void UserParameters::toggleResetAlignmentsNew()
 783 {
 784     resetAlignmentsNew ^= true;
 785 }
 786
 787 void UserParameters::setResetAlignmentsNew(bool value)
 788 {
 789     resetAlignmentsNew = value;
 790 }
 791
 792 void UserParameters::setResetAlignmentsAll(bool value)
 793 {
 794     resetAlignmentsAll = value;
 795 }
 796
 797 void UserParameters::setOutputStructPenalties(int value)
 798 {
 799     outputStructPenalties = value;
 800 }
 801
 802 void UserParameters::setStructPenalties1(int value)
 803 {
 804     structPenalties1 = value;
 805 }
 806
 807 void UserParameters::setStructPenalties2(int value)
 808 {
 809     structPenalties2 = value;
 810 }
 811
 812 void UserParameters::setUseSS1(bool value)
 813 {
 814     useSS1 = value;
 815 }
 816
 817 void UserParameters::toggleUseSS1()
 818 {
 819     useSS1 ^= true;
 820 }
 821
 822 void UserParameters::setUseSS2(bool value)
 823 {
 824     useSS2 = value;
 825 }
 826
 827 void UserParameters::toggleUseSS2()
 828 {
 829     useSS2 ^= true;
 830 }
 831
 832 void UserParameters::setHelixPenalty(int value)
 833 {
 834     helixPenalty = value;
 835 }
 836
 837 void UserParameters::setStrandPenalty(int value)
 838 {
 839     strandPenalty = value;
 840 }
 841
 842 void UserParameters::setLoopPenalty(int value)
 843 {
 844     loopPenalty = value;
 845 }
 846
 847 void UserParameters::setHelixEndMinus(int value)
 848 {
 849     helixEndMinus = value;
 850 }
 851
 852 void UserParameters::setHelixEndPlus(int value)
 853 {
 854     helixEndPlus = value;
 855 }
 856
 857 void UserParameters::setStrandEndMinus(int value)
 858 {
 859     strandEndMinus = value;
 860 }
 861
 862 void UserParameters::setStrandEndPlus(int value)
 863 {
 864     strandEndPlus = value;
 865 }
 866
 867 void UserParameters::setHelixEndPenalty(int value)
 868 {
 869     helixEndPenalty = value;
 870 }
 871
 872 void UserParameters::setStrandEndPenalty(int value)
 873 {
 874     strandEndPenalty = value;
 875 }
 876
 877 void UserParameters::setUseAmbiguities(bool value)
 878 {
 879     useAmbiguities = value;
 880 }
 881
 882 void UserParameters::setDNAPWGapOpenPenalty(float value)
 883 {
 884     DNAPWGapOpen = value;
 885 }
 886
 887 void UserParameters::setDNAPWGapExtendPenalty(float value)
 888 {
 889     DNAPWGapExtend = value;
 890 }
 891
 892 void UserParameters::setProteinPWGapOpenPenalty(float value)
 893 {
 894     AAPWGapOpen = value;
 895 }
 896
 897 void UserParameters::setProteinPWGapExtendPenalty(float value)
 898 {
 899     AAPWGapExtend = value;
 900 }
 901
 902 void UserParameters::toggleQuickPairAlign()
 903 {
 904     quickPairAlign ^= true;
 905 }
 906
 907 void UserParameters::setQuickPairAlign(bool value)
 908 {
 909     quickPairAlign = value;
 910 }
 911
 912 void UserParameters::setTransitionWeight(float value)
 913 {
 914     transitionWeight = value;
 915 }
 916
 917 void UserParameters::setDNAKtup(int value)
 918 {
 919     DNAKtup = value;
 920 }
 921
 922 void UserParameters::setDNAWindowGap(int value)
 923 {
 924     DNAWindowGap = value;
 925 }
 926
 927 void UserParameters::setDNASignif(int value)
 928 {
 929     DNASignif = value;
 930 }
 931
 932 void UserParameters::setDNAWindow(int value)
 933 {
 934     DNAWindow = value;
 935 }
 936
 937 void UserParameters::setAAKtup(int value)
 938 {
 939     AAKtup = value;
 940 }
 941
 942 void UserParameters::setAAWindowGap(int value)
 943 {
 944     AAWindowGap = value;
 945 }
 946
 947 void UserParameters::setAASignif(int value)
 948 {
 949     AASignif = value;
 950 }
 951
 952 void UserParameters::setAAWindow(int value)
 953 {
 954     AAWindow = value;
 955 }
 956
 957 void UserParameters::setPercent(bool value)
 958 {
 959     percent = value;
 960 }
 961
 962 void UserParameters::toggleTossGaps()
 963 {
 964     tossgaps ^= true;
 965 }
 966
 967 void UserParameters::setTossGaps(bool value)
 968 {
 969     tossgaps = value;
 970 }
 971
 972 void UserParameters::setKimura(bool value)
 973 {
 974     kimura = value;
 975 }
 976
 977 void UserParameters::toggleKimura()
 978 {
 979     kimura ^= true;
 980 }
 981
 982 void UserParameters::setBootNumTrials(int value)
 983 {
 984     bootNumTrials = value;
 985 }
 986
 987 void UserParameters::setBootRanSeed(unsigned int value)
 988 {
 989     bootRanSeed = value;
 990 }
 991
 992 void UserParameters::setDebug(int value)
 993 {
 994     debug = value;
 995 }
 996
 997 void UserParameters::setExplicitDNAFlag(bool value)
 998 {
 999     explicitDNAFlag = value;
1000 }
1001
1002 void UserParameters::setLowercase(bool value)
1003 {
1004     lowercase = value;
1005 }
1006
1007 void UserParameters::toggleLowercase()
1008 {
1009     lowercase ^= true;
1010 }
1011
1012 void UserParameters::setClSeqNumbers(bool value)
1013 {
1014     clSeqNumbers = value;
1015 }
1016
1017 void UserParameters::toggleClSeqNumbers()
1018 {
1019     clSeqNumbers ^= true;
1020 }
1021
1022 void UserParameters::setSeqRange(bool value)
1023 {
1024     seqRange = value;
1025 }
1026
1027 void UserParameters::toggleSeqRange()
1028 {
1029     seqRange ^= true;
1030 }
1031
1032 void UserParameters::setOutputClustal(bool value)
1033 {
1034     outputClustal = value;
1035 }
1036
1037 void UserParameters::toggleOutputClustal()
1038 {
1039     outputClustal ^= true;
1040 }
1041
1042 void UserParameters::setOutputGCG(bool value)
1043 {
1044     outputGcg = value;
1045 }
1046
1047 void UserParameters::toggleOutputGCG()
1048 {
1049     outputGcg ^= true;
1050 }
1051
1052 void UserParameters::setOutputPhylip(bool value)
1053 {
1054     outputPhylip = value;
1055 }
1056
1057 void UserParameters::toggleOutputPhylip()
1058 {
1059     outputPhylip ^= true;
1060 }
1061
1062 void UserParameters::setOutputNbrf(bool value)
1063 {
1064     outputNbrf = value;
1065 }
1066
1067 void UserParameters::toggleOutputNbrf()
1068 {
1069     outputNbrf ^= true;
1070 }
1071
1072 void UserParameters::setOutputGde(bool value)
1073 {
1074     outputGde = value;
1075 }
1076
1077 void UserParameters::toggleOutputGde()
1078 {
1079     outputGde ^= true;
1080 }
1081
1082 void UserParameters::setOutputNexus(bool value)
1083 {
1084     outputNexus = value;
1085 }
1086
1087 void UserParameters::toggleOutputNexus()
1088 {
1089     outputNexus ^= true;
1090 }
1091
1092 void UserParameters::setOutputFasta(bool value)
1093 {
1094     outputFasta = value;
1095 }
1096
1097 void UserParameters::toggleOutputFasta()
1098 {
1099     outputFasta ^= true;
1100 }
1101
1102 void UserParameters::setShowAlign(bool value)
1103 {
1104     showAlign = value;
1105 }
1106
1107 void UserParameters::toggleShowAlign()
1108 {
1109     showAlign ^= true;
1110 }
1111
1112 void UserParameters::setSaveParameters(bool value)
1113 {
1114     saveParameters = value;
1115 }
1116
1117 void UserParameters::toggleSaveParameters()
1118 {
1119     saveParameters ^= true;
1120 }
1121
1122 void UserParameters::setOutputTreeClustal(bool value)
1123 {
1124     outputTreeClustal = value;
1125 }
1126
1127 void UserParameters::toggleOutputTreeClustal()
1128 {
1129     outputTreeClustal ^= true;
1130 }
1131
1132 void UserParameters::setOutputTreePhylip(bool value)
1133 {
1134     outputTreePhylip = value;
1135 }
1136
1137 void UserParameters::toggleOutputTreePhylip()
1138 {
1139     outputTreePhylip ^= true;
1140 }
1141
1142 void UserParameters::setOutputTreeDistances(bool value)
1143 {
1144     outputTreeDistances = value;
1145 }
1146
1147 void UserParameters::toggleOutputTreeDistances()
1148 {
1149     outputTreeDistances ^= true;
1150 }
1151
1152 void UserParameters::setOutputTreeNexus(bool value)
1153 {
1154     outputTreeNexus = value;
1155 }
1156
1157 void UserParameters::toggleOutputTreeNexus()
1158 {
1159     outputTreeNexus ^= true;
1160 }
1161
1162 void UserParameters::setOutputPim(bool value)
1163 {
1164     outputPim = value;
1165 }
1166
1167 void UserParameters::setBootstrapFormat(int value)
1168 {
1169     bootstrapFormat = value;
1170 }
1171
1172 void UserParameters::toggleBootstrapFormat()
1173 {
1174     if (bootstrapFormat == BS_NODE_LABELS)
1175     {
1176         bootstrapFormat = BS_BRANCH_LABELS;
1177     }
1178     else
1179     {
1180         bootstrapFormat = BS_NODE_LABELS;
1181     }
1182 }
1183
1184 void UserParameters::setProfile1Name(string value)
1185 {
1186     profile1Name = value;
1187 }
1188
1189 void UserParameters::setProfile2Name(string value)
1190 {
1191     profile2Name = value;
1192 }
1193
1194 void UserParameters::setEmpty(bool value)
1195 {
1196     empty = value;
1197 }
1198
1199 void UserParameters::setProfile1Empty(bool value)
1200 {
1201     profile1Empty = value;
1202 }
1203
1204 void UserParameters::setProfile2Empty(bool value)
1205 {
1206     profile2Empty = value;
1207 }
1208
1209 void UserParameters::setOutfileName(string value)
1210 {
1211     outfileName = value;
1212 }
1213
1214 /*void UserParameters::setProfile1NumSeqs(int value)
1215 {
1216     profile1NumSeqs = value;
1217 }*/ // MARK CHANGE Jan 10
1218
1219 void UserParameters::setUseTreeFile(bool value)
1220 {
1221     useTreeFile = value;
1222 }
1223
1224 void UserParameters::setNewTreeFile(bool value)
1225 {
1226     newTreeFile = value;
1227 }
1228
1229 void UserParameters::setUseTree1File(bool value)
1230 {
1231     useTree1File = value;
1232 }
1233
1234 void UserParameters::setUseTree2File(bool value)
1235 {
1236     useTree2File = value;
1237 }
1238
1239 void UserParameters::setNewTree1File(bool value)
1240 {
1241     newTree1File = value;
1242 }
1243
1244 void UserParameters::setNewTree2File(bool value)
1245 {
1246     newTree2File = value;
1247 }
1248
1249 void UserParameters::setAminoAcidCodes(string value)
1250 {
1251     aminoAcidCodes = value;
1252 }
1253
1254 void UserParameters::setKtup(int value)
1255 {
1256     ktup = value;
1257 }
1258
1259 void UserParameters::setWindow(int value)
1260 {
1261     window = value;
1262 }
1263
1264 void UserParameters::setWindowGap(int value)
1265 {
1266     windowGap = value;
1267 }
1268
1269 void UserParameters::setSignif(int value)
1270 {
1271     signif = value;
1272 }
1273
1274 void UserParameters::setRangeFrom(int from)
1275 {
1276     rangeFrom = from;
1277     rangeFromToSet = true;
1278 }
1279
1280 void UserParameters::setRangeTo(int to)
1281 {
1282     rangeTo = to;
1283     rangeFromToSet = true;
1284 }
1285
1286 int UserParameters::getQTScorePlotScale()
1287 {
1288     return QTscorePlotScale;
1289 }
1290
1291 void UserParameters::setQTScorePlotScale(int score)
1292 {
1293     QTscorePlotScale = score;
1294 }
1295
1296 int UserParameters::getQTResExceptionCutOff()
1297 {
1298     return QTresExceptionCutOff;
1299 }
1300
1301 void UserParameters::setQTResExceptionCutOff(int cutOff)
1302 {
1303     QTresExceptionCutOff = cutOff;
1304 }
1305
1306 bool UserParameters::getQTseqWeightCalculated()
1307 {
1308     return QTseqWeightCalculated;
1309 }
1310
1311 void UserParameters::setQTseqWeightCalculated(bool calculated)
1312 {
1313     QTseqWeightCalculated = calculated;
1314 }
1315
1316 int UserParameters::getQTminLenLowScoreSegment()
1317 {
1318     return QTminLenLowScoreSegment;
1319 }
1320
1321 void UserParameters::setQTminLenLowScoreSegment(int minLen)
1322 {
1323     QTminLenLowScoreSegment = minLen;
1324 }
1325
1326 int UserParameters::getQTlowScoreDNAMarkingScale()
1327 {
1328     return QTlowScoreDNAMarkingScale;
1329 }
1330
1331 void UserParameters::setQTlowScoreDNAMarkingScale(int dnaScale)
1332 {
1333     QTlowScoreDNAMarkingScale = dnaScale;
1334 }
1335
1336 bool UserParameters::IterationIsEnabled()
1337 {
1338     if (doRemoveFirstIteration == clustalw::NONE)
1339         return false;
1340     else
1341         return true;
1342 }
1343 }
1344
1345
1346
1347