R wrapper for a java method in a jar using rjava

Question

I am trying to access a java program MELTING 5 in R using the rjava package.

I can do it using the system function as follows using the batch file.

path <- "path/to/melting.bat"
sequence = "GTCGTATCCAGTGCAGGGTCCGAGGTATTCGCACTGGATACGACTTCCAC"
hybridisation.type = "dnadna"
OligomerConc = 5e-8
Sodium = 0.05

command=paste("-S", sequence,
              "-H", hybridisation.type,
              "-P", OligomerConc,
              "-E", paste("Na=", Sodium, sep = ""))

system(paste("melting.bat", command))

I am trying to do the same using a wrapper, following the steps in hellowjavaworld without any success.

.jaddClassPath('path/to/melting5.jar')
main <- .jnew("melting/Main")
out <- .jcall(obj = main, returnSig = "V", method = "main", .jarray(list(), "java/lang/String"),
              argument = command)

The java code in melting/Main.java in the melting5.jar that I am trying to access is as follows.

package melting;

import java.text.NumberFormat;

import melting.configuration.OptionManagement;
import melting.configuration.RegisterMethods;
import melting.methodInterfaces.MeltingComputationMethod;
import melting.nearestNeighborModel.NearestNeighborMode;

/**
 * The Melting main class which contains the public static void main(String[] args) method.
 */
public class Main {

    // private static methods

    /**
     * Compute the entropy, enthalpy and the melting temperature and display the results. 
     * @param args : contains the options entered by the user.
     * @param OptionManagement optionManager : the OptionManegement which allows to manage
     * the different options entered by the user.
     */
    private static ThermoResult runMelting(String [] args, OptionManagement optionManager){
        try {
                        ThermoResult results = 
                                        getMeltingResults(args, optionManager);
            displaysMeltingResults(results);
                        return results;

        } catch (Exception e) {
            OptionManagement.logError(e.getMessage());
                        return null;
        }
    }

        /**
         * Compute the entropy, enthalpy and melting temperature, and return 
         * these results.
         * @param args options (entered by the user) that determine the
         *             sequence, hybridization type and other features of the
         *             environment.
         * @param optionManager the {@link 
         *                           melting.configuration.OptionManagement 
         *                           <code>OptionManagement</code>} which
         *                      allows the program to manage the different
         *                      options entered by the user.  
         * @return The results of the Melting computation.
         */
        public static ThermoResult getMeltingResults(String[] args,
                                                OptionManagement optionManager)
        {
            NumberFormat format = NumberFormat.getInstance();
            format.setMaximumFractionDigits(2);

            // Set up the environment from the supplied arguments and get the 
            // results.
            Environment environment = optionManager.createEnvironment(args);
            RegisterMethods register = new RegisterMethods();
            MeltingComputationMethod calculMethod = 
                register.getMeltingComputationMethod(environment.getOptions());
            ThermoResult results = calculMethod.computesThermodynamics();
            results.setCalculMethod(calculMethod);
            environment.setResult(results);

            // Apply corrections to the results.
            results = calculMethod.getRegister().
                                   computeOtherMeltingCorrections(environment);
            environment.setResult(results);
            return environment.getResult();
        }

    /**
     * displays the results of Melting : the computed enthalpy and entropy (in cal/mol and J/mol), and the computed 
     * melting temperature (in degrees).
     * @param results : the ThermoResult containing the computed enthalpy, entropy and
     * melting temperature
     * @param MeltingComputationMethod calculMethod : the melting computation method (Approximative or nearest neighbor computation)
     */
    private static void displaysMeltingResults(ThermoResult results)
        {
        NumberFormat format = NumberFormat.getInstance(); 
        format.setMaximumFractionDigits(2);
                MeltingComputationMethod calculMethod = 
                                                     results.getCalculMethod();

        double enthalpy = results.getEnthalpy();
        double entropy = results.getEntropy();

        OptionManagement.logInfo("\n The MELTING results are : ");
        if (calculMethod instanceof NearestNeighborMode){
            OptionManagement.logInfo("Enthalpy : " + format.format(enthalpy) + " cal/mol ( " + format.format(results.getEnergyValueInJ(enthalpy)) + " J /mol)");
            OptionManagement.logInfo("Entropy : " + format.format(entropy) + " cal/mol-K ( " + format.format(results.getEnergyValueInJ(entropy)) + " J /mol-K)");
        }
        OptionManagement.logInfo("Melting temperature : " + format.format(results.getTm()) + " degrees C.\n");
    }

    // public static main method

    /**
     * @param args : contains the options entered by the user.
     */
    public static void main(String[] args) {

        OptionManagement optionManager = new OptionManagement();

        if (args.length == 0){
            optionManager.initialiseLogger();
            optionManager.readMeltingHelp();
        }
        else if (optionManager.isMeltingInformationOption(args)){
            try {
                optionManager.readOptions(args);

            } catch (Exception e) {
                OptionManagement.logError(e.getMessage());
            }
        }
        else {
            runMelting(args, optionManager);
        }
    }
}

How to pass arguments in command to public static void main in java jar?

Answer 1

Over at https://github.com/hrbrmstr/melting5jars I made a pkg wrapper for the MELTING 5 jar (melting5.jar) and also put the Data/ directory in it so you don't have to deal with jar-file management. It can be installed via devtools::install_github("hrbrmstr/melting5jars"),

BEFORE you load that library, you need to set the NN_PATH since the Data/ dir is not where the jar expects it to be by default and you may run into issues setting it afterwards (YMMV).

NOTE: I don't work with this Java library and am not in your field, so please double check the results with the command-line you're used to running!

So, the first things to do to try to get this to work are:

Sys.setenv("NN_PATH"=system.file("extdata", "Data", package="melting5jars"))

library(melting5jars) # devtools::install_github("hrbrmstr/melting5jars")

Now, one of the cooler parts of rJava is that you get to work in R (code) if you want to vs Java (code). We can recreate the core parts of that Main class right in R.

First, get a new melting.Main object and a new OptionManagement object just like the Java code does:

melting <- new(J("melting.Main"))
optionManager <- new(J("melting.configuration.OptionManagement"))

Next, we setup your options. I left Sodium the way it is just to ensure I didn't mess anything up.

Sodium <- 0.05

opts <- c(
  "-S", "GTCGTATCCAGTGCAGGGTCCGAGGTATTCGCACTGGATACGACTTCCAC",
  "-H", "dnadna",
  "-P", 5e-8,
  "-E", paste("Na=", Sodium, sep = "")
)

Now, we can call getMeltingResults() from that Main class directly:

results <- melting$getMeltingResults(opts, optionManager)

and then perform the same calls on those results:

calculMethod <- results$getCalculMethod()

enthalpy <- results$getEnthalpy()
entropy <- results$getEntropy()

if (.jinstanceof(calculMethod, J("melting.nearestNeighborModel.NearestNeighborMode"))) {
  enthalpy <- results$getEnergyValueInJ(enthalpy)
  entropy <- results$getEnergyValueInJ(entropy)
}

melting_temperature <- results$getTm()

enthalpy
## [1] -1705440

entropy
## [1] -4566.232

melting_temperature
## [1] 72.04301

We can wrap all that up into a function that will make it easier to call in the future:

get_melting_results <- function(opts = c()) {

  stopifnot(length(opts) > 2) # a sanity check that could be improved

  Sys.setenv("NN_PATH"=system.file("extdata", "Data", package="melting5jars"))

  require(melting5jars)

  melting <- new(J("melting.Main"))
  optionManager <- new(J("melting.configuration.OptionManagement"))

  results <- melting$getMeltingResults(opts, optionManager)

  calculMethod <- results$getCalculMethod()

  enthalpy_cal <- results$getEnthalpy()
  entropy_cal <- results$getEntropy()

  enthalpy_J <- entropy_J <- NULL

  if (.jinstanceof(calculMethod, J("melting.nearestNeighborModel.NearestNeighborMode"))) {
    enthalpy_J <- results$getEnergyValueInJ(enthalpy_cal)
    entropy_J <- results$getEnergyValueInJ(entropy_cal)
  }

  melting_temp_C <- results$getTm()

  list(
    enthalpy_cal = enthalpy_cal,
    entropy_cal = entropy_cal,
    enthalpy_J = enthalpy_J,
    entropy_J = entropy_J,
    melting_temp_C = melting_temp_C
  ) -> out

  class(out) <- c("melting_res")

  out

}

That also has separate values for enthalpy and entropy depending on the method result.

We can also make a print helper function since we classed the list() we're returning:

print.melting_res <- function(x, ...) {

  cat(
    "The MELTING results are:\n\n",
    "  - Enthalpy: ", prettyNum(x$enthalpy_cal), " cal/mol",
    {if (!is.null(x$enthalpy_J)) paste0(" (", prettyNum(x$enthalpy_J), " J /mol)", collapse="") else ""}, "\n",
    "  - Entropy: ", prettyNum(x$entropy_cal), " cal/mol-K",
    {if (!is.null(x$entropy_J)) paste0(" (", prettyNum(x$entropy_J), " J /mol-K)", collapse="") else ""}, "\n",
    "  - Meltng temperature: ", prettyNum(x$melting_temp_C), " degress C\n",
    sep=""
  )

}

(I made an assumption you're used to seeing the MELTING 5 command line output)

And, finally, re-run the computation:

Sodium <- 0.05

opts <- c(
  "-S", "GTCGTATCCAGTGCAGGGTCCGAGGTATTCGCACTGGATACGACTTCCAC",
  "-H", "dnadna",
  "-P", 5e-8,
  "-E", paste("Na=", Sodium, sep = "")
)

res <- get_melting_results(opts)

res
## The MELTING results are:
## 
##   - Enthalpy: -408000 cal/mol (-1705440 J /mol)
##   - Entropy: -1092.4 cal/mol-K (-4566.232 J /mol-K)
##   - Meltng temperature: 72.04301 degress C

str(res)
## List of 5
##  $ enthalpy_cal  : num -408000
##  $ entropy_cal   : num -1092
##  $ enthalpy_J    : num -1705440
##  $ entropy_J     : num -4566
##  $ melting_temp_C: num 72
##  - attr(*, "class")= chr "melting_res"

You should be able to use the above methodology to wrap other components (if any) in the MELTING library.