Examples with Atom ffx.potential.bonded.Atom used on opensource projects

Example 51 with Atom

use of ffx.potential.bonded.Atom in project ffx by mjschnie.

the class DualTopologyEnergy method packGradient.

private void packGradient(double[] x, double[] g) {
    if (g == null) {
        g = new double[nVariables];
    }
    int indexCommon = 0;
    int indexUnique = nShared * 3;
    /**
     * Coordinate Gradient from Topology 1.
     */
    int index = 0;
    for (int i = 0; i < nActive1; i++) {
        Atom a = activeAtoms1[i];
        if (!doUnpin.test(a)) {
            g[indexCommon++] = f1L * g1[index] + f2L * rg1[index++];
            g[indexCommon++] = f1L * g1[index] + f2L * rg1[index++];
            g[indexCommon++] = f1L * g1[index] + f2L * rg1[index++];
        } else {
            g[indexUnique++] = f1L * g1[index] + f2L * rg1[index++];
            g[indexUnique++] = f1L * g1[index] + f2L * rg1[index++];
            g[indexUnique++] = f1L * g1[index] + f2L * rg1[index++];
        }
    }
    /**
     * Coordinate Gradient from Topology 2.
     */
    indexCommon = 0;
    index = 0;
    for (int i = 0; i < nActive2; i++) {
        Atom a = activeAtoms2[i];
        if (!doUnpin.test(a)) {
            g[indexCommon++] += f2L * g2[index] + f1L * rg2[index++];
            g[indexCommon++] += f2L * g2[index] + f1L * rg2[index++];
            g[indexCommon++] += f2L * g2[index] + f1L * rg2[index++];
        } else {
            g[indexUnique++] = f2L * g2[index] + f1L * rg2[index++];
            g[indexUnique++] = f2L * g2[index] + f1L * rg2[index++];
            g[indexUnique++] = f2L * g2[index] + f1L * rg2[index++];
        }
    }
    if (scaling != null) {
        int len = x.length;
        for (int i = 0; i < len; i++) {
            x[i] *= scaling[i];
            g[i] /= scaling[i];
        }
    }
}

Example 52 with Atom

use of ffx.potential.bonded.Atom in project ffx by mjschnie.

the class DualTopologyEnergy method setVelocity.

@Override
public void setVelocity(double[] velocity) {
    double[] vel = new double[3];
    int indexCommon = 0;
    int indexUnique = 3 * nShared;
    for (int i = 0; i < nActive1; i++) {
        Atom atom = activeAtoms1[i];
        if (!doUnpin.test(atom)) {
            vel[0] = velocity[indexCommon++];
            vel[1] = velocity[indexCommon++];
            vel[2] = velocity[indexCommon++];
        } else {
            vel[0] = velocity[indexUnique++];
            vel[1] = velocity[indexUnique++];
            vel[2] = velocity[indexUnique++];
        }
        atom.setVelocity(vel);
    }
    indexCommon = 0;
    for (int i = 0; i < nActive2; i++) {
        Atom atom = activeAtoms2[i];
        if (!doUnpin.test(atom)) {
            vel[0] = velocity[indexCommon++];
            vel[1] = velocity[indexCommon++];
            vel[2] = velocity[indexCommon++];
        } else {
            vel[0] = velocity[indexUnique++];
            vel[1] = velocity[indexUnique++];
            vel[2] = velocity[indexUnique++];
        }
        atom.setVelocity(vel);
    }
}

Example 53 with Atom

use of ffx.potential.bonded.Atom in project ffx by mjschnie.

the class DualTopologyEnergy method getdEdXdL.

@Override
public void getdEdXdL(double[] g) {
    if (g == null) {
        g = new double[nVariables];
    }
    int index = 0;
    int indexCommon = 0;
    int indexUnique = nShared * 3;
    /**
     * Coordinate Gradient from Topology 1.
     */
    for (int i = 0; i < nActive1; i++) {
        Atom a = activeAtoms1[i];
        if (!doUnpin.test(a)) {
            g[indexCommon++] = f1L * gl1[index] + dF1dL * g1[index] + f2L * rgl1[index] + dF2dL * rg1[index++];
            g[indexCommon++] = f1L * gl1[index] + dF1dL * g1[index] + f2L * rgl1[index] + dF2dL * rg1[index++];
            g[indexCommon++] = f1L * gl1[index] + dF1dL * g1[index] + f2L * rgl1[index] + dF2dL * rg1[index++];
        } else {
            g[indexUnique++] = f1L * gl1[index] + dF1dL * g1[index] + f2L * rgl1[index] + dF2dL * rg1[index++];
            g[indexUnique++] = f1L * gl1[index] + dF1dL * g1[index] + f2L * rgl1[index] + dF2dL * rg1[index++];
            g[indexUnique++] = f1L * gl1[index] + dF1dL * g1[index] + f2L * rgl1[index] + dF2dL * rg1[index++];
        }
    }
    /**
     * Coordinate Gradient from Topology 2.
     */
    index = 0;
    indexCommon = 0;
    for (int i = 0; i < nActive2; i++) {
        Atom a = activeAtoms2[i];
        if (a.isActive()) {
            if (!doUnpin.test(a)) {
                g[indexCommon++] += (-f2L * gl2[index] + dF2dL * g2[index] - f1L * rgl2[index] + dF1dL * rg2[index++]);
                g[indexCommon++] += (-f2L * gl2[index] + dF2dL * g2[index] - f1L * rgl2[index] + dF1dL * rg2[index++]);
                g[indexCommon++] += (-f2L * gl2[index] + dF2dL * g2[index] - f1L * rgl2[index] + dF1dL * rg2[index++]);
            } else {
                g[indexUnique++] = (-f2L * gl2[index] + dF2dL * g2[index] - f1L * rgl2[index] + dF1dL * rg2[index++]);
                g[indexUnique++] = (-f2L * gl2[index] + dF2dL * g2[index] - f1L * rgl2[index] + dF1dL * rg2[index++]);
                g[indexUnique++] = (-f2L * gl2[index] + dF2dL * g2[index] - f1L * rgl2[index] + dF1dL * rg2[index++]);
            }
        }
    }
}

Example 54 with Atom

use of ffx.potential.bonded.Atom in project ffx by mjschnie.

the class RotamerOptimization method bruteForce.

/**
 * Performs a recursive brute-force rotamer optimization over a passed list
 * of residues.
 *
 * @param residueList Residues to be optimized.
 * @return Global minimum energy conformation energy.
 */
private double bruteForce(List<Residue> residueList) {
    Residue[] residues = residueList.toArray(new Residue[residueList.size()]);
    int nResidues = residues.length;
    int[] optimum = new int[nResidues];
    if (x == null) {
        Atom[] atoms = molecularAssembly.getAtomArray();
        int nAtoms = atoms.length;
        x = new double[nAtoms * 3];
    }
    /**
     * Compute the number of permutations without eliminating dead-ends.
     */
    double permutations = 1;
    for (int i = 0; i < nResidues; i++) {
        Residue residue = residues[i];
        Rotamer[] rotamers = residue.getRotamers(library);
        permutations *= rotamers.length;
    }
    logger.info(format(" Number of permutations: %16.8e.", permutations));
    double e;
    useFullAMOEBAEnergy = false;
    if (!useFullAMOEBAEnergy) {
        setPruning(0);
        rotamerEnergies(residues);
        int[] rotamerSet = new int[nResidues];
        fill(rotamerSet, 0);
        e = decomposedRotamerOptimization(molecularAssembly, residues, 0, Double.MAX_VALUE, optimum, rotamerSet);
        for (int i = 0; i < nResidues; i++) {
            Residue residue = residues[i];
            Rotamer[] rotamers = residue.getRotamers(library);
            RotamerLibrary.applyRotamer(residue, rotamers[optimum[i]]);
            turnOnAtoms(residue);
        }
        double fullEnergy = 0;
        try {
            fullEnergy = currentEnergy(residueList);
        } catch (Exception ex) {
            logger.severe(String.format(" Exception %s in calculating full energy; FFX shutting down", ex.toString()));
        }
        logger.info(format(" Final summation of energies:    %16.5f", e));
        logger.info(format(" Final energy of optimized structure:    %16.5f", fullEnergy));
        logger.info(format(" Neglected:    %16.5f", fullEnergy - e));
    } else {
        e = rotamerOptimization(molecularAssembly, residues, 0, Double.MAX_VALUE, optimum);
    }
    for (int i = 0; i < nResidues; i++) {
        Residue residue = residues[i];
        Rotamer[] rotamers = residue.getRotamers(library);
        int ri = optimum[i];
        Rotamer rotamer = rotamers[ri];
        logger.info(format(" %s %s (%d)", residue.getResidueNumber(), rotamer.toString(), ri));
        RotamerLibrary.applyRotamer(residue, rotamer);
        if (useFullAMOEBAEnergy) {
            try {
                e = currentEnergy(residueList);
            } catch (ArithmeticException ex) {
                logger.fine(String.format(" Exception %s in calculating full AMOEBA energy at the end of brute force", ex.toString()));
            }
        }
    }
    return e;
}

Example 55 with Atom

use of ffx.potential.bonded.Atom in project ffx by mjschnie.

the class RotamerOptimization method generateSuperbox.

/**
 * Returns the superbox used to generate the boxes for sliding box. If
 * superbox coordinates manually set, uses them plus the defined buffer.
 * Else, if an aperiodic system, uses maximum and minimum C alpha (or N1/9)
 * coordinates plus superboxBuffer (by default, 8A, longer than a lysine
 * side chain or N1/N9 distance to any other atom). Else, it just uses the
 * ordinary crystal.
 *
 * @param residueList List of residues to incorporate.
 * @return Superbox crystal.
 */
private Crystal generateSuperbox(List<Residue> residueList) {
    double[] maxXYZ = new double[3];
    double[] minXYZ = new double[3];
    Crystal originalCrystal = molecularAssembly.getCrystal();
    if (manualSuperbox) {
        for (int i = 0; i < maxXYZ.length; i++) {
            int ii = 2 * i;
            minXYZ[i] = boxDimensions[ii] - superboxBuffer;
            maxXYZ[i] = boxDimensions[ii + 1] + superboxBuffer;
        }
    } else if (originalCrystal.aperiodic()) {
        if (residueList == null || residueList.isEmpty()) {
            throw new IllegalArgumentException(" Null or empty residue list when generating superbox.");
        }
        Atom initializerAtom = residueList.get(0).getReferenceAtom();
        initializerAtom.getXYZ(minXYZ);
        initializerAtom.getXYZ(maxXYZ);
        for (Residue residue : residueList) {
            Atom refAtom = residue.getReferenceAtom();
            double[] refAtomCoords = new double[3];
            refAtom.getXYZ(refAtomCoords);
            for (int i = 0; i < 3; i++) {
                maxXYZ[i] = (refAtomCoords[i] > maxXYZ[i] ? refAtomCoords[i] : maxXYZ[i]);
                minXYZ[i] = (refAtomCoords[i] < minXYZ[i] ? refAtomCoords[i] : minXYZ[i]);
            }
        }
        for (int i = 0; i < 3; i++) {
            minXYZ[i] -= superboxBuffer;
            maxXYZ[i] += superboxBuffer;
        }
    } else {
        return originalCrystal;
    }
    double newA = maxXYZ[0] - minXYZ[0];
    double newB = maxXYZ[1] - minXYZ[1];
    double newC = maxXYZ[2] - minXYZ[2];
    if (manualSuperbox) {
        logger.info(format(" Manual superbox set over (minX, maxX, minY, " + "maxY, minZ, maxZ): %f, %f, %f, %f, %f, %f", minXYZ[0], maxXYZ[0], minXYZ[1], maxXYZ[1], minXYZ[2], maxXYZ[2]));
        logger.info(format(" Buffer size (included in dimensions): %f\n", superboxBuffer));
    } else {
        // Crystal systems will have already returned.
        logger.info(" System is aperiodic: protein box generated over these coordinates (minX, maxX, minY, maxY, minZ, maxZ):");
        String message = " Aperiodic box dimensions: ";
        for (int i = 0; i < minXYZ.length; i++) {
            message = message.concat(format("%f,%f,", minXYZ[i], maxXYZ[i]));
        }
        message = message.substring(0, message.length() - 1);
        logger.info(message);
        logger.info(format(" Buffer size (included in dimensions): %f\n", superboxBuffer));
    }
    return new Crystal(newA, newB, newC, 90.0, 90.0, 90.0, "P1");
}