Example #1
0
  public static void main(String[] args) {
    double[][] arg1 = {{1, 1, 1}, {2, 3, 2}, {4, 7, 3}};
    DenseDoubleMatrix2D obj1 = new DenseDoubleMatrix2D(arg1); // rot

    double[][] arg2 = {{5, 5, 5}, {8, 8, 8}, {2, 2, 2}};
    DenseDoubleMatrix2D obj2 = new DenseDoubleMatrix2D(arg2); // grŸn

    double[][] arg3 = {{4, 5, 6}, {3, 2, 1}, {1, 2, 1}};
    DenseDoubleMatrix2D obj3 = new DenseDoubleMatrix2D(arg3); // schwarz

    System.out.println("obj1\n" + obj1);
    System.out.println("obj2\n" + obj2);
    System.out.println("obj3\n" + obj3);

    double[][][] pair21 = {arg1, arg2};
    Transformation trans21 = Kabsch.calculateTransformation(pair21); // grŸn -> rot
    DenseDoubleMatrix2D rot21 = trans21.peekRotation();
    DenseDoubleMatrix1D trl21 = trans21.peekTranslation();
    System.out.println("rot21\n" + rot21);
    System.out.println("trl21\n" + trl21);

    double[][][] pair12 = {arg2, arg1};
    Transformation trans12 = Kabsch.calculateTransformation(pair12); // grŸn -> rot
    DenseDoubleMatrix2D rot12 = trans12.peekRotation();
    DenseDoubleMatrix1D trl12 = trans12.peekTranslation();
    System.out.println("rot12\n" + rot12);
    System.out.println("trl12\n" + trl12);

    double[][][] pair32 = {arg2, arg3};
    Transformation trans32 = Kabsch.calculateTransformation(pair32); // schwarz -> grŸn
    DenseDoubleMatrix2D rot32 = trans32.peekRotation();
    DenseDoubleMatrix1D trl32 = trans32.peekTranslation();
    System.out.println("rot32\n" + rot32);
    System.out.println("trl32\n" + trl32.toString());

    DenseDoubleMatrix2D arg2onarg1 =
        new DenseDoubleMatrix2D(trans21.transform(arg2)); // grŸn -> rot
    System.out.println(arg2onarg1.toString());
    DenseDoubleMatrix2D uni21 = createUniMatrix(rot21, trl21);
    DenseDoubleMatrix2D uni32 = createUniMatrix(rot32, trl32);
    System.out.println("uni21\n" + uni21.toString());
    System.out.println("uni32\n" + uni32.toString());

    Algebra alg = new Algebra();
    DenseDoubleMatrix2D result =
        (DenseDoubleMatrix2D)
            alg.mult(
                DoubleFactory2D.dense.identity(4),
                computeTransitiveTransformation(
                    (DenseDoubleMatrix2D) DoubleFactory2D.dense.identity(4), uni32, uni21));

    System.out.println("action results\n" + result);
    System.out.println("moved points\n" + movePoints(result, obj3).toString());
  }
Example #2
0
  /**
   * main function for calling HubeRDP
   *
   * @param args no args needed
   * @throws Exception
   */
  public static void main(String[] args) {

    // allocate memory
    String pairsString = null, pdbpath = null;
    // get command Line Arguments
    CommandLineParser clp = new CommandLineParser(args);
    pairsString = clp.getStringArg("--pairs");
    pdbpath = clp.getStringArg("--pdb");
    clp = null; // clp -> GC

    // load joblist
    PairFile pairfile = new PairFile(pairsString);
    LinkedList<String[]> joblist = pairfile.getJoblist();

    // set test data
    PDBEntry templateStructure = null;
    PDBEntry targetStructure = null;

    // initialize PDBFileReader
    PDBFileReader fr = new PDBFileReader();

    // construct RDP
    HubeRDP rdp = new HubeRDP();
    // set scoring
    Scoring scoring = new SimpleScoring();
    rdp.setScoring(scoring);
    // add oracles
    rdp.addOracle(new RDPOracle(scoring));

    LocalSequenceGotoh gotoh =
        new LocalSequenceGotoh(-10.0, -2.0, bioinfo.alignment.matrices.QuasarMatrix.DAYHOFF_MATRIX);

    // initialize TM stuff
    TMMain tmmain = new TMMain();

    // initialize output stuff
    Locale.setDefault(Locale.US);
    DecimalFormat df = new DecimalFormat("0.0000");

    System.out.println("RDP-Scr\tRMSD\tGDT\tTM-Scr\tdepth\tGot-Scr\tRMSD\tGDT\tTM-Scr");

    // INNER LOOP
    for (String[] job : joblist) {
      try {
        // load data
        templateStructure = fr.readPDBFromFile(pdbpath + job[0] + ".pdb");
        targetStructure = fr.readPDBFromFile(pdbpath + job[1] + ".pdb");

        // construct rdp tree
        RDPProblem root = new RDPProblem(templateStructure, targetStructure.getSequence());
        RDPSolutionTree t = new RDPSolutionTree(root);
        // construct priority queue
        RDPPriorityQueue pq = new RDPPriorityQueue(t.getRoot());
        // execute rdp algorithm
        rdp.rdp(t, pq);
        // Solutions are now in t.getRoot();

        // get HubeRDP's (first) alignment
        SequenceAlignment rdpAlignment =
            t.getRoot().getTA().get(0).getThreading().asSequenceAlignment();

        SequenceAlignment gotohAlignment =
            gotoh.align(templateStructure.getSequence(), targetStructure.getSequence());

        Transformation rdptmtr =
            tmmain.calculateTransformation(rdpAlignment, templateStructure, targetStructure);

        Transformation gotohtmtr =
            tmmain.calculateTransformation(gotohAlignment, templateStructure, targetStructure);

        System.out.println(
            job[0]
                + "\t"
                + job[1]
                + "\t"
                + df.format(rdpAlignment.getScore())
                + "\t"
                + df.format(rdptmtr.getRmsd())
                + "\t"
                + df.format(rdptmtr.getGdt())
                + "\t"
                + df.format(rdptmtr.getTmscore())
                + "\t"
                + (t.getDepth() / 2)
                + "\t"
                + df.format(gotohAlignment.getScore())
                + "\t"
                + df.format(gotohtmtr.getRmsd())
                + "\t"
                + df.format(gotohtmtr.getGdt())
                + "\t"
                + df.format(gotohtmtr.getTmscore()));
      } catch (Exception e) {
        System.err.println("Error occured: " + e.getLocalizedMessage());
        e.printStackTrace();
      }
    }
  }