public void processCompletedOutputFiles(String[] outputFilePaths) {
   if (outputFilePaths.length > 1 && !StringUtil.blank(outputFilePaths[1])) {
     ZephyrUtil.copyLogFile(this, "TNT", outputFilePaths[1]);
   }
   if (outputFilePaths.length > 2 && !StringUtil.blank(outputFilePaths[2])) {
     ZephyrUtil.copyOutputText(this, outputFilePaths[2], commands);
   }
 }
  /**
   * A request for the MesquiteModule to perform a command. It is passed two strings, the name of
   * the command and the arguments. This should be overridden by any module that wants to respond to
   * a command.
   */
  public Object doCommand(String commandName, String arguments, CommandChecker checker) {
    if (checker.compare(MesquiteModule.class, null, null, commandName, "paint")) {
      MesquiteInteger io = new MesquiteInteger(0);
      int column = MesquiteInteger.fromString(arguments, io);
      int row = MesquiteInteger.fromString(arguments, io);
      if (MesquiteInteger.isCombinable(row)) {
        if (!MesquiteLong.isCombinable(currentColor)) removeColor(row, true);
        else setColor(row, (int) currentColor);
      }
    } else if (checker.compare(
        this.getClass(),
        "Sets the color to be used to paint cells",
        "[name of color]",
        commandName,
        "setColor")) {
      int bc = ColorDistribution.standardColorNames.indexOf(parser.getFirstToken(arguments));
      if (bc >= 0 && MesquiteLong.isCombinable(bc)) {
        removeColor.setValue(false);
        currentColor = bc;
        savedColor = bc;
        colorString = "Color " + ColorDistribution.standardColorNames.getValue(bc);
      }
    } else if (checker.compare(
        this.getClass(),
        "Sets the color of selected taxa",
        "[name of color]",
        commandName,
        "setColorSelected")) {
      int bc = ColorDistribution.standardColorNames.indexOf(parser.getFirstToken(arguments));
      if (bc >= 0 && MesquiteLong.isCombinable(bc)) {
        for (int it = 0; it < taxa.getNumTaxa(); it++) if (taxa.getSelected(it)) setColor(it, bc);
      }
    } else if (checker.compare(
        this.getClass(), "Removes color from all the cells", null, commandName, "removeAllColor")) {
      removeAllColor(true);
    } else if (checker.compare(
        this.getClass(),
        "Sets the paint brush so that it removes colors from any cells touched",
        null,
        commandName,
        "removeColor")) {
      if (StringUtil.blank(arguments)) removeColor.setValue(!removeColor.getValue());
      else removeColor.toggleValue(parser.getFirstToken(arguments));

      if (removeColor.getValue()) {
        colorString = "Remove color";
        currentColor = MesquiteLong.unassigned;
      } else {
        colorString = "Color " + ColorDistribution.standardColorNames.getValue((int) currentColor);
        currentColor = savedColor;
      }
    } else return super.doCommand(commandName, arguments, checker);
    return null;
  }
 /*.................................................................................................................*/
 public void fromString(String description, MesquiteInteger stringPos, int format) {
   hasDefaultValues = false;
   ParseUtil.getToken(description, stringPos); // RMatrix
   ParseUtil.getToken(description, stringPos); // =
   ParseUtil.getToken(description, stringPos); // (
   for (int i = 0; i < getNumStates(); i++) {
     String s = ParseUtil.getToken(description, stringPos);
     if (s.equalsIgnoreCase(")") || StringUtil.blank(s)) return;
     setStateFreq(i, MesquiteDouble.fromString(s));
   }
   checkNormality(getStateFrequencies());
 }
  public void runFilesAvailable(int fileNum) {
    String[] logFileNames = getLogFileNames();
    if ((progIndicator != null && progIndicator.isAborted()) || logFileNames == null) return;
    String[] outputFilePaths = new String[logFileNames.length];
    outputFilePaths[fileNum] = externalProcRunner.getOutputFilePath(logFileNames[fileNum]);
    String filePath = outputFilePaths[fileNum];

    if (fileNum == 0
        && outputFilePaths.length > 0
        && !StringUtil.blank(outputFilePaths[0])
        && !bootstrapOrJackknife()) { // tree file
      if (ownerModule instanceof NewTreeProcessor) {
        String treeFilePath = filePath;
        if (taxa != null) {
          TaxaSelectionSet outgroupSet =
              (TaxaSelectionSet) taxa.getSpecsSet(outgroupTaxSetString, TaxaSelectionSet.class);
          ((NewTreeProcessor) ownerModule).newTreeAvailable(treeFilePath, outgroupSet);

        } else ((NewTreeProcessor) ownerModule).newTreeAvailable(treeFilePath, null);
      }
    } else if (fileNum == 1
        && outputFilePaths.length > 1
        && !StringUtil.blank(outputFilePaths[1])
        && !bootstrapOrJackknife()) { // log file
      if (MesquiteFile.fileExists(filePath)) {
        String s = MesquiteFile.getFileLastContents(filePath);
        if (!StringUtil.blank(s))
          if (progIndicator != null) {
            parser.setString(s);
            String rep = parser.getFirstToken(); // generation number
            logln("");
            if (MesquiteInteger.isNumber(rep)) {
              int numReps = MesquiteInteger.fromString(rep) + 1;
              progIndicator.setText(
                  "Replicate: " + numReps); // + ", ln L = " + parser.getNextToken());
              if (bootstrapOrJackknife()) {
                logln("Replicate " + numReps + " of " + bootstrapreps);
              }
              logln("Replicate " + numReps + " of " + totalNumHits);

              progIndicator.spin();
              double timePerRep = 0;
              if (MesquiteInteger.isCombinable(numReps) && numReps > 0) {
                timePerRep = timer.timeSinceVeryStartInSeconds() / numReps; // this is time per rep
              }
              int timeLeft = 0;
              if (bootstrapOrJackknife()) {
                timeLeft = (int) ((bootstrapreps - numReps) * timePerRep);
              } else {
                String token = parser.getNextToken(); // algorithm
                token = parser.getNextToken(); // Tree
                token = parser.getNextToken(); // Score
                String best = parser.getNextToken(); // Best
                logln("  Score " + token + "; best found so far " + best);
                timeLeft = (int) ((totalNumHits - numReps) * timePerRep);
              }

              logln(
                  "  Running time so far "
                      + StringUtil.secondsToHHMMSS((int) timer.timeSinceVeryStartInSeconds())
                      + ", approximate time remaining "
                      + StringUtil.secondsToHHMMSS(timeLeft));
            }
          }
        count++;
      } else if (MesquiteTrunk.debugMode) logln("*** File does not exist (" + filePath + ") ***");
    }
  }
  /*.................................................................................................................*/
  void getArguments(
      MultipartEntityBuilder builder,
      StringBuffer sb,
      String fileName,
      String LOCproteinModel,
      String LOCdnaModel,
      String LOCotherOptions,
      int LOCbootstrapreps,
      int LOCbootstrapSeed,
      int LOCnumRuns,
      String LOCoutgroupTaxSetString,
      String LOCMultipleModelFile,
      boolean preflight) {
    if (builder == null) return;
    /*
    if (preflight)
    	arguments += " -n preflight.out ";
    else
    	arguments += " -s " + fileName + " -n file.out ";
    */

    if (isProtein) {
      if (StringUtil.blank(LOCproteinModel))
        addArgument(builder, sb, "vparam.protein_opts_", "PROTGAMMAJTT");
      else addArgument(builder, sb, "vparam.protein_opts_", LOCproteinModel);
    } else if (StringUtil.blank(LOCdnaModel))
      addArgument(builder, sb, "vparam.dna_gtrcat_", "GTRGAMMA");
    else addArgument(builder, sb, "vparam.dna_gtrcat_", "GTRGAMMA");
    //	builder.addTextBody("vparam.dna_gtrcat_",LOCdnaModel);

    /*
    		if (StringUtil.notEmpty(LOCMultipleModelFile))
    			arguments += " -q " + ShellScriptUtil.protectForShellScript(LOCMultipleModelFile);

    		if (!StringUtil.blank(LOCotherOptions))
    			arguments += " " + LOCotherOptions;

    */

    addArgument(builder, sb, "vparam.provide_parsimony_seed_", "1");
    addArgument(builder, sb, "vparam.parsimony_seed_val_", "" + randomIntSeed);

    if (bootstrapOrJackknife()) {
      if (LOCbootstrapreps > 0) {
        addArgument(builder, sb, "vparam.choose_bootstrap_", "b");
        addArgument(builder, sb, "vparam.bootstrap_value_", "" + LOCbootstrapreps);
        addArgument(builder, sb, "vparam.seed_value_", "" + LOCbootstrapSeed);
        //	addArgument(builder, sb, "vparam.bootstrap_",""+LOCbootstrapreps);
        //	addArgument(builder, sb, "vparam.mulparambootstrap_seed_",""+LOCbootstrapSeed);
      } else Debugg.println("TOO FEW BOOTSTRAP REPS");

    } else {
      addArgument(builder, sb, "vparam.specify_runs_", "1");
      addArgument(builder, sb, "vparam.altrun_number_", "" + LOCnumRuns);
      //	if (RAxML814orLater)
      // addArgument(builder, sb, "vparam.mesquite_output_","1");
    }

    TaxaSelectionSet outgroupSet = null;
    if (!StringUtil.blank(LOCoutgroupTaxSetString)) {
      outgroupSet =
          (TaxaSelectionSet) taxa.getSpecsSet(LOCoutgroupTaxSetString, TaxaSelectionSet.class);
      if (outgroupSet != null)
        addArgument(builder, sb, "vparam.outgroup_", outgroupSet.getStringList(",", true));
      arguments += " -o " + outgroupSet.getStringList(",", true);
    }
  }