| Modifier and Type | Method and Description | 
|---|---|
| AFPChain | BioJavaStructureAlignment. align(Atom[] ca1,
     Atom[] ca2) | 
| AFPChain | StructureAlignment. align(Atom[] ca1,
     Atom[] ca2)Run an alignment while specifying the atoms to be aligned. | 
| abstract AFPChain | AbstractStructureAlignment. align(Atom[] ca1,
     Atom[] ca2) | 
| AFPChain | BioJavaStructureAlignment. align(Atom[] ca1,
     Atom[] ca2,
     Object params) | 
| AFPChain | StructureAlignment. align(Atom[] ca1,
     Atom[] ca2,
     Object params)run an alignment and also send a bean containing the parameters. | 
| abstract AFPChain | AbstractStructureAlignment. align(Atom[] ca1,
     Atom[] ca2,
     Object params) | 
| AFPChain | CallableStructureAlignment. call() | 
| Modifier and Type | Method and Description | 
|---|---|
| static int | AFPTwister. afp2Res(AFPChain afpChain,
       int afpn,
       int[] afpPositions,
       int listStart)Set the list of equivalent residues in the two proteins given a list of AFPs
 WARNING: changes the values for FocusRes1, focusRes2 and FocusResn in afpChain! | 
| static Group[] | AFPTwister. twistOptimized(AFPChain afpChain,
              Atom[] ca1,
              Atom[] ca2)superimposing according to the optimized alignment | 
| static Group[] | AFPTwister. twistPDB(AFPChain afpChain,
        Atom[] ca1,
        Atom[] ca2)calculate the total rmsd of the blocks
 output a merged pdb file for both proteins
          protein 1, in chain A
         protein 2 is twisted according to the twists detected, in chain B | 
| Modifier and Type | Method and Description | 
|---|---|
| AFPChain | CeMain. align(Atom[] ca1,
     Atom[] ca2) | 
| AFPChain | OptimalCECPMain. align(Atom[] ca1,
     Atom[] ca2,
     Object param)Finds the optimal alignment between two proteins allowing for a circular
 permutation (CP). | 
| AFPChain | CeMain. align(Atom[] ca1,
     Atom[] ca2,
     Object param)Align ca2 onto ca1. | 
| AFPChain | CeCPMain. align(Atom[] ca1,
     Atom[] ca2,
     Object param)Aligns ca1 and ca2 using a heuristic to check for CPs. | 
| AFPChain | OptimalCECPMain. alignOptimal(Atom[] ca1,
            Atom[] ca2,
            Object param,
            AFPChain[] alignments)Finds the optimal alignment between two proteins allowing for a circular
 permutation (CP). | 
| AFPChain | OptimalCECPMain. alignPermuted(Atom[] ca1,
             Atom[] ca2,
             Object param,
             int cp)Aligns ca1 with ca2 permuted by cp residues. | 
| AFPChain | CeCalculatorEnhanced. extractFragments(AFPChain afpChain,
                Atom[] ca1,
                Atom[] ca2) | 
| AFPChain | CECalculator. extractFragments(AFPChain afpChain,
                Atom[] ca1,
                Atom[] ca2) | 
| static AFPChain | CeCPMain. filterDuplicateAFPs(AFPChain afpChain,
                   CECalculator ceCalc,
                   Atom[] ca1,
                   Atom[] ca2duplicated)Takes as input an AFPChain where ca2 has been artificially duplicated. | 
| static AFPChain | CeCPMain. filterDuplicateAFPs(AFPChain afpChain,
                   CECalculator ceCalc,
                   Atom[] ca1,
                   Atom[] ca2duplicated,
                   CECPParameters params) | 
| AFPChain | CeCPMain. invertAlignment(AFPChain a)Swaps the order of structures in an AFPChain | 
| static AFPChain | CeCPMain. postProcessAlignment(AFPChain afpChain,
                    Atom[] ca1,
                    Atom[] ca2m,
                    CECalculator calculator)Circular permutation specific code to be run after the standard CE alignment | 
| static AFPChain | CeCPMain. postProcessAlignment(AFPChain afpChain,
                    Atom[] ca1,
                    Atom[] ca2m,
                    CECalculator calculator,
                    CECPParameters param)Circular permutation specific code to be run after the standard CE alignment | 
| Modifier and Type | Method and Description | 
|---|---|
| AFPChain | OptimalCECPMain. alignOptimal(Atom[] ca1,
            Atom[] ca2,
            Object param,
            AFPChain[] alignments)Finds the optimal alignment between two proteins allowing for a circular
 permutation (CP). | 
| void | CeCalculatorEnhanced. convertAfpChain(AFPChain afpChain,
               Atom[] ca1,
               Atom[] ca2)copy data from this class into AFPChain container object. | 
| void | CECalculator. convertAfpChain(AFPChain afpChain,
               Atom[] ca1,
               Atom[] ca2)copy data from this class into AFPChain container object. | 
| static Object | GuiWrapper. display(AFPChain afpChain,
       Atom[] ca1,
       Atom[] ca2) | 
| AFPChain | CeCalculatorEnhanced. extractFragments(AFPChain afpChain,
                Atom[] ca1,
                Atom[] ca2) | 
| AFPChain | CECalculator. extractFragments(AFPChain afpChain,
                Atom[] ca1,
                Atom[] ca2) | 
| static AFPChain | CeCPMain. filterDuplicateAFPs(AFPChain afpChain,
                   CECalculator ceCalc,
                   Atom[] ca1,
                   Atom[] ca2duplicated)Takes as input an AFPChain where ca2 has been artificially duplicated. | 
| static AFPChain | CeCPMain. filterDuplicateAFPs(AFPChain afpChain,
                   CECalculator ceCalc,
                   Atom[] ca1,
                   Atom[] ca2duplicated,
                   CECPParameters params) | 
| String | AbstractUserArgumentProcessor. getDbSearchResult(AFPChain afpChain) | 
| AFPChain | CeCPMain. invertAlignment(AFPChain a)Swaps the order of structures in an AFPChain | 
| void | CeCalculatorEnhanced. nextStep(AFPChain afpChain,
        Atom[] ca1,
        Atom[] ca2) | 
| void | CECalculator. nextStep(AFPChain afpChain,
        Atom[] ca1,
        Atom[] ca2) | 
| static AFPChain | CeCPMain. postProcessAlignment(AFPChain afpChain,
                    Atom[] ca1,
                    Atom[] ca2m,
                    CECalculator calculator)Circular permutation specific code to be run after the standard CE alignment | 
| static AFPChain | CeCPMain. postProcessAlignment(AFPChain afpChain,
                    Atom[] ca1,
                    Atom[] ca2m,
                    CECalculator calculator,
                    CECPParameters param)Circular permutation specific code to be run after the standard CE alignment | 
| static Group[] | GuiWrapper. prepareGroupsForDisplay(AFPChain afpChain,
                       Atom[] ca1,
                       Atom[] ca2) | 
| static void | GuiWrapper. showAlignmentImage(AFPChain afpChain,
                  Atom[] ca1,
                  Atom[] ca2,
                  Object jmol) | 
| void | CeCalculatorEnhanced. traceFragmentMatrix(AFPChain afpChain,
                   Atom[] ca1,
                   Atom[] ca2) | 
| void | CECalculator. traceFragmentMatrix(AFPChain afpChain,
                   Atom[] ca1,
                   Atom[] ca2) | 
| Modifier and Type | Method and Description | 
|---|---|
| static AFPChain | JFatCatClient. getAFPChainFromServer(String serverLocation,
                     String name1,
                     String name2,
                     Atom[] ca1,
                     Atom[] ca2) | 
| static AFPChain | JFatCatClient. getAFPChainFromServer(String serverLocation,
                     String method,
                     String name1,
                     String name2,
                     Atom[] ca1,
                     Atom[] ca2,
                     int timeout) | 
| Modifier and Type | Method and Description | 
|---|---|
| static void | JFatCatClient. sendAFPChainToServer(String serverLocation,
                    AFPChain afpChain,
                    Atom[] ca1,
                    Atom[] ca2) | 
| Modifier and Type | Method and Description | 
|---|---|
| AFPChain | FatCatRigid. align(Atom[] ca1,
     Atom[] ca2) | 
| AFPChain | FatCatFlexible. align(Atom[] ca1,
     Atom[] ca2) | 
| protected AFPChain | FatCat. align(Atom[] ca1,
     Atom[] ca2,
     FatCatParameters params,
     boolean doRigid) | 
| AFPChain | FatCatRigid. align(Atom[] ca1,
     Atom[] ca2,
     Object param) | 
| AFPChain | FatCatFlexible. align(Atom[] ca1,
     Atom[] ca2,
     Object param) | 
| AFPChain | FatCat. alignFlexible(Atom[] ca1,
             Atom[] ca2,
             FatCatParameters params) | 
| AFPChain | FatCat. alignRigid(Atom[] ca1,
          Atom[] ca2) | 
| AFPChain | FatCat. alignRigid(Atom[] ca1,
          Atom[] ca2,
          FatCatParameters params) | 
| Modifier and Type | Method and Description | 
|---|---|
| AFPChain | FatCatAligner. getAfpChain() | 
| Modifier and Type | Method and Description | 
|---|---|
| static boolean | AFPChainer. afpPairConn(int afp1,
           int afp2,
           FatCatParameters params,
           AFPChain afpChain)//Key function: calculate the connectivity of AFP pairs
        //no compatibility criteria is executed
        //note: afp1 is previous to afp2 in terms of the position
                 //this module must be optimized | 
| static void | AFPOptimizer. blockInfo(AFPChain afpChain)get the afp list and residue list for each block | 
| protected static double | AFPChainer. calAfpRmsd(int afpn,
          int[] afpPositions,
          int listStart,
          AFPChain afpChain,
          Atom[] ca1,
          Atom[] ca2)//return the rmsd of the residues from the segments that form the given AFP list
        //this value can be a measurement (1) for the connectivity of the AFPs | 
| double | SigEva. calNS(FatCatParameters params,
     AFPChain afpChain) | 
| double | SigEva. calSigAll(FatCatParameters params,
         AFPChain afpChain) | 
| static void | AFPChainer. doChainAfp(FatCatParameters params,
          AFPChain afpChain,
          Atom[] ca1,
          Atom[] ca2)// Key function: chain (assembly) the AFPs
        // a AFP (k) is defined as (i, j, k), with i and j are staring points
        // AFP extension (eg. | 
| static void | AFPCalculator. extractAFPChains(FatCatParameters params,
                AFPChain afpChain,
                Atom[] ca1,
                Atom[] ca2) | 
| static void | AFPOptimizer. optimizeAln(FatCatParameters params,
           AFPChain afpChain,
           Atom[] ca1,
           Atom[] ca2)optimize the alignment by dynamic programming | 
| static void | AFPPostProcessor. postProcess(FatCatParameters params,
           AFPChain afpChain,
           Atom[] ca1,
           Atom[] ca2) | 
| static void | AFPCalculator. sortAfps(AFPChain afpChain,
        Atom[] ca1,
        Atom[] ca2) | 
| static void | AFPOptimizer. updateScore(FatCatParameters params,
           AFPChain afpChain)to update the chaining score after block delete and merge processed
 the blockScore value is important for significance evaluation | 
| Modifier and Type | Method and Description | 
|---|---|
| static Structure | DisplayAFP. createArtificalStructure(AFPChain afpChain,
                        Atom[] ca1,
                        Atom[] ca2)Create a "fake" Structure objects that contains the two sets of atoms aligned on top of each other. | 
| static StructureAlignmentJmol | StructureAlignmentDisplay. display(AFPChain afpChain,
       Atom[] ca1,
       Atom[] ca2)Display an AFPChain alignment | 
| static StructureAlignmentJmol | DisplayAFP. display(AFPChain afpChain,
       Group[] twistedGroups,
       Atom[] ca1,
       Atom[] ca2,
       List<Group> hetatms1,
       List<Group> hetatms2)Note: ca2, hetatoms2 and nucleotides2 should not be rotated. | 
| static JMenuBar | MenuCreator. getAlignmentPanelMenu(JFrame frame,
                     ActionListener actionListener,
                     AFPChain afpChain,
                     MultipleAlignment msa)Create the menu for the Alignment Panel representation of
 Structural Alignments. | 
| static JMenuBar | MenuCreator. getAlignmentTextMenu(JFrame frame,
                    ActionListener actionListener,
                    AFPChain afpChain,
                    MultipleAlignment msa)Create the menu for the Text representations of Structural Alignments. | 
| static Atom | DisplayAFP. getAtomForAligPos(AFPChain afpChain,
                 int chainNr,
                 int aligPos,
                 Atom[] ca,
                 boolean getPrevious)return the atom at alignment position aligPos. | 
| static int | DisplayAFP. getBlockNrForAlignPos(AFPChain afpChain,
                     int aligPos)Deprecated. 
 use AFPAlignmentDisplay.getBlockNrForAlignPos instead... | 
| static List<Integer> | DisplayAFP. getEQRAlignmentPos(AFPChain afpChain) | 
| static List<String> | DisplayAFP. getPDBresnum(int aligPos,
            AFPChain afpChain,
            Atom[] ca)Return a list of pdb Strings corresponding to the aligned positions of the molecule. | 
| static JMenuItem | MenuCreator. getSaveAlignmentMenuItem(AFPChain afpChain,
                        MultipleAlignment msa) | 
| static JMenuBar | MenuCreator. initJmolMenu(JFrame frame,
            AbstractAlignmentJmol parent,
            AFPChain afpChain,
            MultipleAlignment msa)Provide a JMenuBar that can be added to a JFrame containing
 a JmolPanel. | 
| static Group[] | StructureAlignmentDisplay. prepareGroupsForDisplay(AFPChain afpChain,
                       Atom[] ca1,
                       Atom[] ca2)Rotate the Atoms/Groups so they are aligned for the 3D visualisation | 
| static void | StructureAlignmentDisplay. shiftCA2(AFPChain afpChain,
        Atom[] ca2,
        Matrix m,
        Atom shift,
        Group[] twistedGroups)only shift CA positions. | 
| static void | DisplayAFP. showAlignmentImage(AFPChain afpChain,
                  String result) | 
| static void | DisplayAFP. showAlignmentPanel(AFPChain afpChain,
                  Atom[] ca1,
                  Atom[] ca2,
                  AbstractAlignmentJmol jmol) | 
| Constructor and Description | 
|---|
| DotPlotListener(AFPChain afpChain) | 
| DotPlotPanel(AFPChain alignment) | 
| MySaveFileListener(AFPChain afpChain) | 
| MySaveFileListener(AFPChain afpChain,
                  MultipleAlignment msa)Constructor to avoid checking which of the two is null before
 instantiating this class. | 
| Modifier and Type | Method and Description | 
|---|---|
| AFPChain | StatusDisplay. getAfpChain() | 
| AFPChain | AligPanel. getAFPChain() | 
| Modifier and Type | Method and Description | 
|---|---|
| void | StatusDisplay. setAfpChain(AFPChain afpChain) | 
| void | AFPChainCoordManager. setAFPChain(AFPChain afpChain) | 
| void | AligPanel. setAFPChain(AFPChain afpChain) | 
| Constructor and Description | 
|---|
| MultipleAligPanel(AFPChain afpChain,
                 Atom[] ca1,
                 Atom[] ca2,
                 AbstractAlignmentJmol jmol)Constructor using an afpChain and the atom arrays for pairwise
 alignments. | 
| Modifier and Type | Method and Description | 
|---|---|
| static String | StructureAlignmentJmol. getJmolScript4Block(AFPChain afpChain,
                   Atom[] ca1,
                   Atom[] ca2,
                   int blockNr) | 
| static String | StructureAlignmentJmol. getJmolString(AFPChain afpChain,
             Atom[] ca1,
             Atom[] ca2) | 
| Constructor and Description | 
|---|
| StructureAlignmentJmol(AFPChain afpChain,
                      Atom[] ca1,
                      Atom[] ca2) | 
| Modifier and Type | Method and Description | 
|---|---|
| static String | AfpChainWriter. toAlignedPairs(AFPChain afpChain,
              Atom[] ca1,
              Atom[] ca2)Prints the alignment in the simplest form: a list of aligned residues. | 
| static String | AfpChainWriter. toCE(AFPChain afpChain,
    Atom[] ca1,
    Atom[] ca2) | 
| static String | AfpChainWriter. toDBSearchResult(AFPChain afpChain) | 
| static String | AfpChainWriter. toFatCat(AFPChain afpChain,
        Atom[] ca1,
        Atom[] ca2) | 
| static String | AfpChainWriter. toFatCatCore(AFPChain afpChain,
            Atom[] ca1,
            Atom[] ca2,
            boolean printLegend,
            boolean longHeader,
            boolean showHTML,
            boolean showAlignmentBlock)Output in FatCatCore format | 
| static String | AfpChainWriter. toRotMat(AFPChain afpChain) | 
| static String | AfpChainWriter. toScoresList(AFPChain afpChain) | 
| static String | AfpChainWriter. toWebSiteDisplay(AFPChain afpChain,
                Atom[] ca1,
                Atom[] ca2)Prints the afpChain as a nicely formatted alignment, including alignment
 statistics, the aligned sequences themselves, and information about the
 superposition. | 
| static String | AfpChainWriter. toWebSiteDisplay(AFPChain afpChain,
                Atom[] ca1,
                Atom[] ca2,
                boolean showAlignmentBlock)Prints the afpChain as a nicely formatted alignment, including alignment
 statistics, the aligned sequences themselves, and information about the
 superposition. | 
| Constructor and Description | 
|---|
| AFPChain(AFPChain o)Copy constructor | 
| Constructor and Description | 
|---|
| MultipleAlignmentEnsembleImpl(AFPChain afp,
                             Atom[] ca1,
                             Atom[] ca2,
                             boolean flexible)Constructor from an AFPChain instance. | 
| Modifier and Type | Method and Description | 
|---|---|
| AFPChain | SmithWaterman3Daligner. align(Atom[] ca1,
     Atom[] ca2) | 
| AFPChain | SmithWaterman3Daligner. align(Atom[] ca1,
     Atom[] ca2,
     Object parameters) | 
| Modifier and Type | Method and Description | 
|---|---|
| static AFPChain | AlignmentTools. createAFPChain(Atom[] ca1,
              Atom[] ca2,
              ResidueNumber[] aligned1,
              ResidueNumber[] aligned2)Fundamentally, an alignment is just a list of aligned residues in each
 protein. | 
| static AFPChain | AlignmentTools. replaceOptAln(AFPChain afpChain,
             Atom[] ca1,
             Atom[] ca2,
             int blockNum,
             int[] optLens,
             int[][][] optAln) | 
| static AFPChain | AlignmentTools. replaceOptAln(AFPChain afpChain,
             Atom[] ca1,
             Atom[] ca2,
             Map<Integer,Integer> alignment)Takes an AFPChain and replaces the optimal alignment based on an alignment map | 
| static AFPChain | AlignmentTools. replaceOptAln(int[][][] newAlgn,
             AFPChain afpChain,
             Atom[] ca1,
             Atom[] ca2)It replaces an optimal alignment of an AFPChain and calculates all the new alignment scores and variables. | 
| static AFPChain | AlignmentTools. splitBlocksByTopology(AFPChain a,
                     Atom[] ca1,
                     Atom[] ca2) | 
| Modifier and Type | Method and Description | 
|---|---|
| static Map<Integer,Integer> | AlignmentTools. alignmentAsMap(AFPChain afpChain)Creates a Map specifying the alignment as a mapping between residue indices
 of protein 1 and residue indices of protein 2. | 
| static void | AlignmentTools. alignmentToSIF(Writer out,
              AFPChain afpChain,
              Atom[] ca1,
              Atom[] ca2,
              String backboneInteraction,
              String alignmentInteraction)Creates a simple interaction format (SIF) file for an alignment. | 
| static Structure | AFPAlignmentDisplay. createArtificalStructure(AFPChain afpChain,
                        Atom[] ca1,
                        Atom[] ca2) | 
| static void | AFPAlignmentDisplay. getAlign(AFPChain afpChain,
        Atom[] ca1,
        Atom[] ca2)Extract the alignment output | 
| static void | AFPAlignmentDisplay. getAlign(AFPChain afpChain,
        Atom[] ca1,
        Atom[] ca2,
        boolean showSeq) | 
| static Atom[] | AFPAlignmentDisplay. getAlignedAtoms1(AFPChain afpChain,
                Atom[] ca1) | 
| static Atom[] | AFPAlignmentDisplay. getAlignedAtoms2(AFPChain afpChain,
                Atom[] ca2) | 
| static double | RotationAxis. getAngle(AFPChain afpChain)Calculate the rotation angle for a structure | 
| static int | AFPAlignmentDisplay. getBlockNrForAlignPos(AFPChain afpChain,
                     int aligPos)get the block number for an aligned position | 
| static List<List<List<Integer>>> | AlignmentTools. getOptAlnAsList(AFPChain afpChain)Retrieves the optimum alignment from an AFPChain and returns it as a
 java collection. | 
| static Matrix | AFPAlignmentDisplay. getRotMax(AFPChain afpChain,
         Atom[] ca1,
         Atom[] ca2) | 
| static int | AlignmentTools. getSymmetryOrder(AFPChain afpChain,
                int maxSymmetry,
                float minimumMetricChange)Guesses the order of symmetry in an alignment | 
| static double | AFPChainScorer. getTMScore(AFPChain align,
          Atom[] ca1,
          Atom[] ca2) | 
| static Atom | AFPAlignmentDisplay. getTranslation(AFPChain afpChain,
              Atom[] ca1,
              Atom[] ca2) | 
| static boolean | AlignmentTools. isSequentialAlignment(AFPChain afpChain,
                     boolean checkWithinBlocks)Checks that the alignment given by afpChain is sequential. | 
| static AFPChain | AlignmentTools. replaceOptAln(AFPChain afpChain,
             Atom[] ca1,
             Atom[] ca2,
             int blockNum,
             int[] optLens,
             int[][][] optAln) | 
| static AFPChain | AlignmentTools. replaceOptAln(AFPChain afpChain,
             Atom[] ca1,
             Atom[] ca2,
             Map<Integer,Integer> alignment)Takes an AFPChain and replaces the optimal alignment based on an alignment map | 
| static AFPChain | AlignmentTools. replaceOptAln(int[][][] newAlgn,
             AFPChain afpChain,
             Atom[] ca1,
             Atom[] ca2)It replaces an optimal alignment of an AFPChain and calculates all the new alignment scores and variables. | 
| static AFPChain | AlignmentTools. splitBlocksByTopology(AFPChain a,
                     Atom[] ca1,
                     Atom[] ca2) | 
| static void | AlignmentTools. updateSuperposition(AFPChain afpChain,
                   Atom[] ca1,
                   Atom[] ca2)After the alignment changes (optAln, optLen, blockNum, at a minimum),
 many other properties which depend on the superposition will be invalid. | 
| Constructor and Description | 
|---|
| RotationAxis(AFPChain afpChain)Calculate the rotation axis for the first block of an AFPChain | 
| Modifier and Type | Method and Description | 
|---|---|
| static AFPChain | AFPChainFlipper. flipChain(AFPChain o)Flip the position of name1 and name2 (as well as all underlying data) in an AFPChain. | 
| static AFPChain | AFPChainXMLParser. fromXML(String xml,
       Atom[] ca1,
       Atom[] ca2) | 
| static AFPChain | AFPChainXMLParser. fromXML(String xml,
       String name1,
       String name2,
       Atom[] ca1,
       Atom[] ca2)new utility method that checks that the order of the pair in the XML alignment is correct and flips the direction if needed | 
| static AFPChain[] | AFPChainXMLParser. parseMultiXML(String xml) | 
| Modifier and Type | Method and Description | 
|---|---|
| static AFPChain | AFPChainFlipper. flipChain(AFPChain o)Flip the position of name1 and name2 (as well as all underlying data) in an AFPChain. | 
| static void | AFPChainXMLConverter. printXMLEQRInferPositions(PrettyXMLWriter xml,
                         AFPChain afpChain,
                         int bk,
                         Atom[] ca1,
                         Atom[] ca2) | 
| static void | AFPChainXMLConverter. printXMLHeader(PrettyXMLWriter xml,
              AFPChain afpChain) | 
| static void | AFPChainXMLParser. rebuildAFPChain(AFPChain afpChain,
               Atom[] ca1,
               Atom[] ca2)replace the PDB res nums with atom positions: | 
| static String | AFPChainXMLConverter. toXML(AFPChain afpChain) | 
| static String | AFPChainXMLConverter. toXML(AFPChain afpChain,
     Atom[] ca1,
     Atom[] ca2)Convert an afpChain to a simple XML representation | 
| static void | AFPChainXMLConverter. toXML(AFPChain afpChain,
     StringWriter swriter,
     Atom[] ca1,
     Atom[] ca2)Write the XML representation to a StringWriter | 
| Modifier and Type | Method and Description | 
|---|---|
| static AFPChain | FastaAFPChainConverter. cpFastaToAfpChain(File fastaFile,
                 Structure structure,
                 int cpSite)Takes a structure and sequence corresponding to an alignment between a structure or sequence and itself (or even a structure with a sequence), where the result has a circular permutation site
  cpSiteresidues to the right. | 
| static AFPChain | FastaAFPChainConverter. cpFastaToAfpChain(ProteinSequence first,
                 ProteinSequence second,
                 Structure structure,
                 int cpSite)Takes a structure and sequence corresponding to an alignment between a structure or sequence and itself (or even a structure with a sequence), where the result has a circular permutation site
  cpSiteresidues to the right. | 
| static AFPChain | FastaAFPChainConverter. cpFastaToAfpChain(String first,
                 String second,
                 Structure structure,
                 int cpSite) | 
| static AFPChain | FastaAFPChainConverter. fastaFileToAfpChain(File fastaFile,
                   Structure structure1,
                   Structure structure2)Reads the file  fastaFile, expecting exactly two sequences which give a pairwise alignment. | 
| static AFPChain | FastaAFPChainConverter. fastaStringToAfpChain(String sequence1,
                     String sequence2,
                     Structure structure1,
                     Structure structure2)Returns an AFPChain corresponding to the alignment between  structure1andstructure2, which is given by the gapped protein sequencessequence1andsequence2. | 
| static AFPChain | FastaAFPChainConverter. fastaToAfpChain(Map<String,ProteinSequence> sequences,
               Structure structure1,
               Structure structure2)Uses two sequences each with a corresponding structure to create an AFPChain corresponding to the alignment. | 
| static AFPChain | FastaAFPChainConverter. fastaToAfpChain(ProteinSequence sequence1,
               ProteinSequence sequence2,
               Structure structure1,
               Structure structure2)Returns an AFPChain corresponding to the alignment between  structure1andstructure2, which is given by the gapped protein sequencessequence1andsequence2. | 
| static AFPChain | FastaAFPChainConverter. fastaToAfpChain(SequencePair<Sequence<AminoAcidCompound>,AminoAcidCompound> alignment,
               Structure structure1,
               Structure structure2)Provided only for convenience. | 
| static AFPChain | FastaAFPChainConverter. fastaToAfpChain(String sequence1,
               String sequence2,
               Structure structure1,
               Structure structure2)TODO Write comment | 
| Modifier and Type | Method and Description | 
|---|---|
| AFPChain | CeSymmResult. getSelfAlignment() | 
| static AFPChain | SequenceFunctionRefiner. refineSymmetry(AFPChain afpChain,
              Atom[] ca1,
              Atom[] ca2,
              int k)Refines a CE-Symm alignment so that it is perfectly symmetric. | 
| Modifier and Type | Method and Description | 
|---|---|
| int | AngleOrderDetectorPlus. calculateOrder(AFPChain afpChain,
              Atom[] ca) | 
| int | GraphComponentOrderDetector. calculateOrder(AFPChain selfAlignment,
              Atom[] ca) | 
| int | SequenceFunctionOrderDetector. calculateOrder(AFPChain afpChain,
              Atom[] ca) | 
| int | OrderDetector. calculateOrder(AFPChain afpChain,
              Atom[] ca) | 
| MultipleAlignment | SequenceFunctionRefiner. refine(AFPChain selfAlignment,
      Atom[] atoms,
      int order) | 
| MultipleAlignment | SymmetryRefiner. refine(AFPChain selfAlignment,
      Atom[] atoms,
      int order)Returns a refined symmetry alignment, where the repeat residues are
 aligned consistently in a MultipleAlignment. | 
| MultipleAlignment | GraphComponentRefiner. refine(AFPChain selfAlignment,
      Atom[] atoms,
      int order) | 
| static AFPChain | SequenceFunctionRefiner. refineSymmetry(AFPChain afpChain,
              Atom[] ca1,
              Atom[] ca2,
              int k)Refines a CE-Symm alignment so that it is perfectly symmetric. | 
| void | CeSymmResult. setSelfAlignment(AFPChain selfAlignment) | 
| Modifier and Type | Method and Description | 
|---|---|
| static boolean[][] | SymmetryTools. blankOutBreakFlag(AFPChain afpChain,
                 Atom[] ca2,
                 int rows,
                 int cols,
                 CECalculator calculator,
                 boolean[][] breakFlag,
                 int blankWindowSize) | 
| static Matrix | SymmetryTools. blankOutPreviousAlignment(AFPChain afpChain,
                         Atom[] ca2,
                         int rows,
                         int cols,
                         CECalculator calculator,
                         Matrix max,
                         int blankWindowSize) | 
| static org.jgrapht.UndirectedGraph<Integer,org.jgrapht.graph.DefaultEdge> | SymmetryTools. buildSymmetryGraph(AFPChain selfAlignment)Converts a self alignment into a directed jGraphT of aligned residues,
 where each vertex is a residue and each edge means the equivalence
 between the two residues in the self-alignment. | 
| static MultipleAlignment | SymmetryTools. fromAFP(AFPChain symm,
       Atom[] atoms)Converts a refined symmetry AFPChain alignment into the standard
 representation of symmetry in a MultipleAlignment, that contains the
 entire Atom array of the strcuture and the symmetric repeats are orgaized
 in different rows in a single Block. | 
| static double | SymmetryTools. getAngle(AFPChain afpChain,
        Atom[] ca1,
        Atom[] ca2)Returns the magnitude of the angle between the first and second
 blocks of  afpChain, measured in degrees. | 
| static Matrix | SymmetryTools. grayOutPreviousAlignment(AFPChain afpChain,
                        Atom[] ca2,
                        int rows,
                        int cols,
                        CECalculator calculator,
                        Matrix max,
                        int blankWindowSize,
                        double[] gradientPolyCoeff,
                        double gradientExpCoeff) | 
| Modifier and Type | Method and Description | 
|---|---|
| static List<List<Integer>> | SymmetryTools. buildSymmetryGraph(List<AFPChain> afps,
                  Atom[] atoms,
                  boolean undirected)Converts a set of AFP alignments into a Graph of aligned residues, where
 each vertex is a residue and each edge means the connection between the
 two residues in one of the alignments. | 
Copyright © 2000–2016 BioJava. All rights reserved.