//////////////////////////////////////////////////////////////////////////////////
/////////////////////////// rosetta::chemical::AtomSet ///////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::chemical{
class AtomSet : ( inherits?? )
{
   int     n_atomtypes (                               ) const;
   int atom_type_index ( string const & atom_type_name ) const;
  void       read_file ( string const & filename       );
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////////// rosetta::chemical::AtomType ///////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::chemical{
class AtomType : ( inherits?? )
{
                   Real         lk_lambda (                         ) const;
                   Real         lk_dgfree (                         ) const;
                   Real         lk_volume (                         ) const;
                   Real         lj_radius (                         ) const;
                   Real         lj_wdepth (                         ) const;
                   bool       is_acceptor (                         ) const;
                   bool          is_donor (                         ) const;
                   bool is_polar_hydrogen (                         ) const;
                   bool       is_hydrogen (                         ) const;
                   bool            is_h2o (                         ) const;
                   void     set_parameter ( string const & param   
                                          , Real const setting    
                                          );
                   void      set_property ( string const & property
                                          , bool const setting    
                                          );
  Hybridization const &     hybridization (                         ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////////// rosetta::conformation::Atom ///////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::conformation{
class Atom : ( inherits?? )
{
             int type (                       ) const;
  Vector const &  xyz (                       ) const;
            void  xyz ( Vector const & xyz_in );
             int  cpl (                       ) const;
             int  cpu (                       ) const;
             int  cps (                       ) const;
            void  cpl ( int const type_in     );
            void  cpu ( int const type_in     );
            void  cps ( int const type_in     );
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////// rosetta::conformation::Conformation ///////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::conformation{
class Conformation : ( inherits?? )
{
                   Size                       size (                                 ) const;
                   Size                 num_chains (                                 ) const;
       FoldTree const &                  fold_tree (                                 ) const;
       AtomTree const &                  atom_tree (                                 ) const;
                   void                  fold_tree ( FoldTree const & fold_tree_in   );
        Residue const &                    residue ( int const seqpos                ) const;
                   void             append_residue ( ResidueCOP new_rsd_in          
                                                   , bool const attach_by_jump=false
                                                   , int const jump_anchor_residue=0
                                                   , int const jump_anchor_atomno=0
                                                   , int const jump_root_atomno=0  
                                                   );
                   void            replace_residue ( int const seqpos               
                                                   , Residue const & new_rsd       
                                                   , bool const orient_backbone    
                                                   );
                   void               copy_segment ( int const size                 
                                                   , Conformation const & src      
                                                   , int const begin               
                                                   , int const src_begin           
                                                   );
                   Real                        dof ( DOF_ID const & id               ) const;
                   void                    set_dof ( DOF_ID const & id              
                                                   , Real const setting            
                                                   );
                   Real                    torsion ( TorsionID const & id            ) const;
                   void                set_torsion ( TorsionID const & id           
                                                   , Real const setting            
                                                   );
           Jump const &                       jump ( int const jump_number           ) const;
                   void                   set_jump ( int const jump_number          
                                                   , Jump const & new_jump         
                                                   );
           Jump const &                       jump ( AtomID const & id               ) const;
                   void                   set_jump ( AtomID const & id              
                                                   , Jump const & new_jump         
                                                   );
  PointPosition const &                        xyz ( AtomID const & id               ) const;
                   void                    set_xyz ( AtomID const & id              
                                                   , PointPosition const & position
                                                   );
                   void           update_actcoords (                                 );
                 DOF_ID     dof_id_from_torsion_id ( TorsionID const & id            ) const;
                 AtomID               jump_atom_id ( int const jump_number           ) const;
                   bool get_torsion_angle_atom_ids ( TorsionID const & tor_id       
                                                   , AtomID & id1                  
                                                   , AtomID & id2                  
                                                   , AtomID & id3                  
                                                   , AtomID & id4                  
                                                   ) const;
                   void          update_domain_map ( DomainMap & domain_map          ) const;
                   bool            structure_moved (                                 ) const;
                   void      reset_structure_moved (                                 ) const;
                   void            reset_move_data (                                 );
                   void                      clear (                                 );
                   void     debug_residue_torsions (                                 ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
/////////////////////// rosetta::conformation::LiteResidue ///////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::conformation{
class LiteResidue : ( inherits?? )
{
                       int                   natoms (                             ) const;
                       int              nheavyatoms (                             ) const;
                       int     first_sidechain_atom (                             ) const;
                       int first_sidechain_hydrogen (                             ) const;
                       int       lower_connect_atom (                             ) const;
                       int       upper_connect_atom (                             ) const;
                       int            path_distance ( int arg0                   
                                                    , int arg1                  
                                                    ) const;
     FArray2D<int> const &            path_distance (                             ) const;
                      bool         atom_is_backbone ( int const atomno            ) const;
                       int         attached_H_begin ( int const atom              ) const;
                       int           attached_H_end ( int const atom              ) const;
     vector1<int,> const &         attached_H_begin (                             ) const;
     vector1<int,> const &           attached_H_end (                             ) const;
                       int                atom_base ( int const atomno            ) const;
                       int                   abase2 ( int const atomno            ) const;
                       int                     nchi (                             ) const;
  vector1<double,> const &       mainchain_torsions (                             ) const;
  vector1<double,> const &                      chi (                             ) const;
                      Real        mainchain_torsion ( int const torsion           ) const;
                      Real                      chi ( size_t const chino          ) const;
                       int                   seqpos (                             ) const;
                       int                    chain (                             ) const;
                    size_t        sequence_distance ( LiteResidue const & residue ) const;
              Atom const &                     atom ( int const atomno            ) const;
                   Atom  &                     atom ( int const atomno            );
          AtomType const &                atom_type ( int const atomno            ) const;
     vector1<int,> const &               Hpos_polar (                             ) const;
     vector1<int,> const &                accpt_pos (                             ) const;
                       int                 nbr_atom (                             ) const;
            Vector const &                 actcoord (                             ) const;
                      Real               nbr_radius (                             ) const;
                      bool               is_polymer (                             ) const;
                      bool               is_protein (                             ) const;
                      bool                   is_DNA (                             ) const;
                      bool                   is_RNA (                             ) const;
                      bool                    is_NA (                             ) const;
                      bool                 is_polar (                             ) const;
                      bool               is_charged (                             ) const;
                      bool              is_aromatic (                             ) const;
                      bool                  is_term (                             ) const;
            string const &                     name (                             ) const;
            string const &                    name3 (                             ) const;
                      char                    name1 (                             ) const;
                AA const &                       aa (                             ) const;
   vector1<Atom*,> const &                    atoms (                             ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::conformation::Residue /////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::conformation{
class Residue : ( inherits?? )
{
                              ResidueOP                    clone (                                    ) const;
                              RotamerOP           create_rotamer (                                    ) const;
                                    int                   natoms (                                    ) const;
                                    int                     nchi (                                    ) const;
                                    int              nheavyatoms (                                    ) const;
                                    int       lower_connect_atom (                                    ) const;
                                   void   set_lower_connect_atom ( int const value                    );
                                    int       upper_connect_atom (                                    ) const;
                                   void   set_upper_connect_atom ( int const value                    );
                                    int            path_distance ( int at1                           
                                                                 , int at2                          
                                                                 ) const;
                  FArray2D<int> const &            path_distance (                                    ) const;
                                    int         attached_H_begin ( int const atom                     ) const;
                                    int           attached_H_end ( int const atom                     ) const;
                  vector1<int,> const &         attached_H_begin (                                    ) const;
                  vector1<int,> const &           attached_H_end (                                    ) const;
                  vector1<int,> const &          bonded_neighbor ( int const atomno                   ) const;
                  vector1<int,> const &                     nbrs ( int const atomno                   ) const;
                  vector1<int,> const &                chi_atoms ( int const chino                    ) const;
        vector1<vector1<int,>,> const &                chi_atoms (                                    ) const;
                  vector1<int,> const &          mainchain_atoms (                                    ) const;
                                   void      set_mainchain_atoms ( vector1<int                       
                                                                 , allocator<int> > const & mainchain
                                                                 );
               vector1<double,> const &       mainchain_torsions (                                    ) const;
                    vector1<double,>  &       mainchain_torsions (                                    );
               vector1<double,> const &                      chi (                                    ) const;
                    vector1<double,>  &                      chi (                                    );
                                   Real        mainchain_torsion ( int const torsion                  ) const;
                                   Real                      chi ( size_t const chino                 ) const;
                                    int                   seqpos (                                    ) const;
                                   void                   seqpos ( int const setting                  );
                                    int                    chain (                                    ) const;
                                   void                    chain ( int const setting                  );
                         Vector const &                 actcoord (                                    ) const;
                                   bool                      has ( string const & atom_name           ) const;
  vector1<pair<double,double>,> const &             chi_rotamers ( size_t const chino                 ) const;
                       AtomType const &                atom_type ( int const atomno                   ) const;
                  vector1<int,> const &               Hpos_polar (                                    ) const;
                  vector1<int,> const &                accpt_pos (                                    ) const;
                                   void                 add_atom ( string const & atom_name          
                                                                 , string const & atom_type_name    
                                                                 , Real const charge                
                                                                 );
                                   void                 add_bond ( string const & atom_name1         
                                                                 , string const & atom_name2        
                                                                 );
                                   void                  add_chi ( size_t const chino                
                                                                 , string const & atom_name1        
                                                                 , string const & atom_name2        
                                                                 , string const & atom_name3        
                                                                 , string const & atom_name4        
                                                                 );
                                   void          add_chi_rotamer ( size_t const chino                
                                                                 , Real const mean                  
                                                                 , Real const sdev                  
                                                                 );
                                   void                 nbr_atom ( string const & atom_name           );
                                    int                 nbr_atom (                                    ) const;
                                   void               nbr_radius ( Real const radius                  );
                                   Real               nbr_radius (                                    ) const;
                                   void             add_property ( string const & property            );
                                   void        add_actcoord_atom ( string const & atom                );
                                   bool               is_polymer (                                    ) const;
                                   bool               is_protein (                                    ) const;
                                   bool                   is_DNA (                                    ) const;
                                   bool                   is_RNA (                                    ) const;
                                   bool                    is_NA (                                    ) const;
                                   bool                 is_polar (                                    ) const;
                                   bool               is_charged (                                    ) const;
                                   bool              is_aromatic (                                    ) const;
                                   bool                  is_term (                                    ) const;
                         string const &                     name (                                    ) const;
                                   void                     name ( string const & name_in             );
                         string const &                    name3 (                                    ) const;
                                   void                    name3 ( string const & name_in             );
                                   char                    name1 (                                    ) const;
                                   void                    name1 ( char const code                    );
                                   bool        requires_actcoord (                                    );
                                   void          update_actcoord (                                    );
                                   void          update_actcoord ( Rotamer & rot                      ) const;
                                   void            set_atom_base ( string const & atom_name1         
                                                                 , string const & atom_name2        
                                                                 );
                                    int                atom_base ( int const atomno                   ) const;
                                    int                   abase2 ( int const atomno                   ) const;
                                   void                       aa ( string const & type                );
                         string const &                atom_name ( int const index                    ) const;
                                    int               atom_index ( string const & name                ) const;
                             AA const &                       aa (                                    ) const;
                                   void                 finalize (                                    );
                                   void            require_final (                                    );
                                    int     first_sidechain_atom (                                    ) const;
                                   void     first_sidechain_atom ( string const & name_in             );
                                    int first_sidechain_hydrogen (                                    ) const;
                                   bool         atom_is_backbone ( int const atomno                   ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////////// rosetta::conformation::ResidueFactory //////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::conformation{
class ResidueFactory : ( inherits?? )
{
  static ResidueOP create_residue ( AtomSetCOP params );
}
}

///////////////////////////////////////////////////////////////////////////////////
//////////////////////// rosetta::conformation::ResidueSet ////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::conformation{
class ResidueSet : ( inherits?? )
{
                   void read_list_of_residues ( string const & list_filename );
  ConstResidues const &             name3_map ( string const & name          ) const;
  ConstResidues const &                aa_map ( AA const & aa                ) const;
   _List_const_iter<AA>     aas_defined_begin (                              ) const;
   _List_const_iter<AA>       aas_defined_end (                              ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::conformation::Residue_ /////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::conformation{
class Residue_ : ( inherits?? )
{
                              ResidueOP                    clone (                                    ) const;
                              RotamerOP           create_rotamer (                                    ) const;
                                    int                   natoms (                                    ) const;
                                    int                     nchi (                                    ) const;
                                    int              nheavyatoms (                                    ) const;
                                    int       lower_connect_atom (                                    ) const;
                                   void   set_lower_connect_atom ( int const value                    );
                                    int       upper_connect_atom (                                    ) const;
                                   void   set_upper_connect_atom ( int const value                    );
                                    int            path_distance ( int at1                           
                                                                 , int at2                          
                                                                 ) const;
                  FArray2D<int> const &            path_distance (                                    ) const;
                                    int         attached_H_begin ( int const atom                     ) const;
                                    int           attached_H_end ( int const atom                     ) const;
                  vector1<int,> const &         attached_H_begin (                                    ) const;
                  vector1<int,> const &           attached_H_end (                                    ) const;
                  vector1<int,> const &          bonded_neighbor ( int const atomno                   ) const;
                  vector1<int,> const &                     nbrs ( int const atomno                   ) const;
                  vector1<int,> const &                chi_atoms ( int const chino                    ) const;
        vector1<vector1<int,>,> const &                chi_atoms (                                    ) const;
                  vector1<int,> const &          mainchain_atoms (                                    ) const;
                                   void      set_mainchain_atoms ( vector1<int                       
                                                                 , allocator<int> > const & mainchain
                                                                 );
               vector1<double,> const &       mainchain_torsions (                                    ) const;
                    vector1<double,>  &       mainchain_torsions (                                    );
               vector1<double,> const &                      chi (                                    ) const;
                    vector1<double,>  &                      chi (                                    );
                                   Real        mainchain_torsion ( int const torsion                  ) const;
                                   Real                      chi ( size_t const chino                 ) const;
                                    int                   seqpos (                                    ) const;
                                   void                   seqpos ( int const setting                  );
                                    int                    chain (                                    ) const;
                                   void                    chain ( int const setting                  );
                         Vector const &                 actcoord (                                    ) const;
                                   bool                      has ( string const & atom_name           ) const;
  vector1<pair<double,double>,> const &             chi_rotamers ( size_t const chino                 ) const;
                       AtomType const &                atom_type ( int const atomno                   ) const;
                  vector1<int,> const &               Hpos_polar (                                    ) const;
                  vector1<int,> const &                accpt_pos (                                    ) const;
                                   void                 add_atom ( string const & atom_name          
                                                                 , string const & atom_type_name    
                                                                 , Real const charge                
                                                                 );
                                   void                 add_bond ( string const & atom_name1         
                                                                 , string const & atom_name2        
                                                                 );
                                   void                  add_chi ( size_t const chino                
                                                                 , string const & atom_name1        
                                                                 , string const & atom_name2        
                                                                 , string const & atom_name3        
                                                                 , string const & atom_name4        
                                                                 );
                                   void          add_chi_rotamer ( size_t const chino                
                                                                 , Real const mean                  
                                                                 , Real const sdev                  
                                                                 );
                                   void                 nbr_atom ( string const & atom_name           );
                                    int                 nbr_atom (                                    ) const;
                                   void               nbr_radius ( Real const radius                  );
                                   Real               nbr_radius (                                    ) const;
                                   void             add_property ( string const & property            );
                                   void        add_actcoord_atom ( string const & atom                );
                                   bool               is_polymer (                                    ) const;
                                   bool               is_protein (                                    ) const;
                                   bool                   is_DNA (                                    ) const;
                                   bool                   is_RNA (                                    ) const;
                                   bool                    is_NA (                                    ) const;
                                   bool                 is_polar (                                    ) const;
                                   bool               is_charged (                                    ) const;
                                   bool              is_aromatic (                                    ) const;
                                   bool                  is_term (                                    ) const;
                         string const &                     name (                                    ) const;
                                   void                     name ( string const & name_in             );
                         string const &                    name3 (                                    ) const;
                                   void                    name3 ( string const & name_in             );
                                   char                    name1 (                                    ) const;
                                   void                    name1 ( char const code                    );
                                   bool        requires_actcoord (                                    );
                                   void          update_actcoord (                                    );
                                   void          update_actcoord ( Rotamer & rot                      ) const;
                                   void            set_atom_base ( string const & atom_name1         
                                                                 , string const & atom_name2        
                                                                 );
                                    int                atom_base ( int const atomno                   ) const;
                                    int                   abase2 ( int const atomno                   ) const;
                                   void                       aa ( string const & type                );
                         string const &                atom_name ( int const index                    ) const;
                                    int               atom_index ( string const & name                ) const;
                             AA const &                       aa (                                    ) const;
                                   void                 finalize (                                    );
                                   void            require_final (                                    );
                                    int     first_sidechain_atom (                                    ) const;
                                   void     first_sidechain_atom ( string const & name_in             );
                                    int first_sidechain_hydrogen (                                    ) const;
                                   bool         atom_is_backbone ( int const atomno                   ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::conformation::Rotamer /////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::conformation{
class Rotamer : ( inherits?? )
{
          AtomType const &                atom_type ( int const atomno   ) const;
     vector1<int,> const &               Hpos_polar (                    ) const;
     vector1<int,> const &                accpt_pos (                    ) const;
                       int                   natoms (                    ) const;
                       int              nheavyatoms (                    ) const;
                       int     first_sidechain_atom (                    ) const;
                       int first_sidechain_hydrogen (                    ) const;
                       int       lower_connect_atom (                    ) const;
                       int       upper_connect_atom (                    ) const;
                       int            path_distance ( int at1           
                                                    , int at2          
                                                    ) const;
      FArray2D_int const &            path_distance (                    ) const;
                      bool         atom_is_backbone ( int const atomno   ) const;
                       int         attached_H_begin ( int const atom     ) const;
                       int           attached_H_end ( int const atom     ) const;
     vector1<int,> const &         attached_H_begin (                    ) const;
     vector1<int,> const &           attached_H_end (                    ) const;
                       int                atom_base ( int const atomno   ) const;
                       int                   abase2 ( int const atomno   ) const;
                       int                     nchi (                    ) const;
  vector1<double,> const &       mainchain_torsions (                    ) const;
  vector1<double,> const &                      chi (                    ) const;
                      Real        mainchain_torsion ( int const torsion  ) const;
                      Real                      chi ( size_t const chino ) const;
                       int                   seqpos (                    ) const;
                       int                    chain (                    ) const;
                      void          update_actcoord (                    );
            Vector const &                 actcoord (                    ) const;
                       int                 nbr_atom (                    ) const;
                      Real               nbr_radius (                    ) const;
                      bool               is_polymer (                    ) const;
                      bool               is_protein (                    ) const;
                      bool                   is_DNA (                    ) const;
                      bool                   is_RNA (                    ) const;
                      bool                    is_NA (                    ) const;
                      bool                 is_polar (                    ) const;
                      bool               is_charged (                    ) const;
                      bool              is_aromatic (                    ) const;
                      bool                  is_term (                    ) const;
            string const &                     name (                    ) const;
            string const &                    name3 (                    ) const;
                      char                    name1 (                    ) const;
                AA const &                       aa (                    ) const;
                      void                  set_chi ( int const chino   
                                                    , Real const setting
                                                    );
                 ResidueOP           create_residue (                    ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////////// rosetta::conformation::RotamerFactory //////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::conformation{
class RotamerFactory : ( inherits?? )
{
  static RotamerOP create_rotamer ( Residue const & rsd_in        
                                  , Residue const & current_rsd_in
                                  );
}
}

//////////////////////////////////////////////////////////////////////////////////
////////////////////////////// rosetta::graph::Edge //////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::graph{
class Edge : ( inherits?? )
{
          void            delete_edge (                                             );
          void              copy_from ( Edge const * source                         );
           int          get_other_ind ( int callers_index                           ) const;
  Node const *         get_other_node ( int callers_index                           ) const;
       Node  *         get_other_node ( int callers_index                           );
           int     get_first_node_ind (                                             ) const;
           int    get_second_node_ind (                                             ) const;
          void set_pos_in_owners_list ( _List_iterator<Edge*> edge_iterator        
                                      , _List_iterator<Edge const*> const_edge_iter
                                      );
          bool              same_edge ( int node1                                  
                                      , int node2                                 
                                      ) const;
          bool                is_loop (                                             ) const;
  unsigned int    count_static_memory (                                             ) const;
  unsigned int   count_dynamic_memory (                                             ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////////////////// rosetta::graph::Graph //////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::graph{
class Graph : ( inherits?? )
{
                            int                num_nodes (               ) const;
                           void            set_num_nodes ( int num_nodes );
                           void                 add_edge ( int node1    
                                                         , int node2   
                                                         );
                           bool          get_edge_exists ( int node1    
                                                         , int node2   
                                                         ) const;
                           void           drop_all_edges (               );
                           void  drop_all_edges_for_node ( int node      );
                           void           print_vertices (               ) const;
                           void      output_connectivity ( ostream & os  ) const;
                           void            output_dimacs ( ostream & os  ) const;
                   FArray2D_int all_pairs_shortest_paths (               ) const;
                        Node  *                 get_node ( int index     ) const;
                            int                num_edges (               ) const;
  _List_const_iter<Edge const*>          edge_list_begin (               ) const;
        _List_const_iter<Edge*>          edge_list_begin (               );
  _List_const_iter<Edge const*>            edge_list_end (               ) const;
        _List_const_iter<Edge*>            edge_list_end (               );
                        Edge  *                find_edge ( int node1    
                                                         , int node2   
                                                         );
                   Edge const *                find_edge ( int node1    
                                                         , int node2   
                                                         ) const;
                   unsigned int      getTotalMemoryUsage (               ) const;
                   unsigned int      count_static_memory (               ) const;
                   unsigned int     count_dynamic_memory (               ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
////////////////////////////// rosetta::graph::Node //////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::graph{
class Node : ( inherits?? )
{
                           void                              copy_from ( Node const * source                         );
                           void                               add_edge ( Edge * edge_ptr                            
                                                                       , _List_iterator<Edge*> & arg1              
                                                                       , _List_iterator<Edge const*> & arg2        
                                                                       );
                           void                              drop_edge ( _List_iterator<Edge*> edge_iterator        
                                                                       , _List_iterator<Edge const*> const_edge_iter
                                                                       );
                           void                         drop_all_edges (                                             );
                   Edge const *                              find_edge ( int other_node_index                        ) const;
                        Edge  *                              find_edge ( int other_node_index                        );
                           void                                  print (                                             ) const;
        _List_const_iter<Edge*>                        edge_list_begin (                                             );
  _List_const_iter<Edge const*>                      c_edge_list_begin (                                             ) const;
        _List_const_iter<Edge*>                          edge_list_end (                                             );
  _List_const_iter<Edge const*>                        c_edge_list_end (                                             ) const;
        _List_const_iter<Edge*>                  lower_edge_list_begin (                                             );
  _List_const_iter<Edge const*>                c_lower_edge_list_begin (                                             ) const;
        _List_const_iter<Edge*>                    lower_edge_list_end (                                             );
  _List_const_iter<Edge const*>                  c_lower_edge_list_end (                                             ) const;
        _List_const_iter<Edge*>                  upper_edge_list_begin (                                             );
  _List_const_iter<Edge const*>                c_upper_edge_list_begin (                                             ) const;
        _List_const_iter<Edge*>                    upper_edge_list_end (                                             );
  _List_const_iter<Edge const*>                  c_upper_edge_list_end (                                             ) const;
                            int                         get_node_index (                                             ) const;
                            int                              num_edges (                                             ) const;
                            int            num_neighbors_counting_self (                                             ) const;
                            int get_num_edges_to_smaller_indexed_nodes (                                             ) const;
                            int  get_num_edges_to_larger_indexed_nodes (                                             ) const;
                   unsigned int                    count_static_memory (                                             ) const;
                   unsigned int                   count_dynamic_memory (                                             ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////////// rosetta::io::pdb::PDBReader ///////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::io::pdb{
class PDBReader : ( inherits?? )
{
      bool  read ( Record_OP & record );
  Iterator begin (                    );
  Iterator   end (                    );
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////////// rosetta::io::pdb::PDBWriter ///////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::io::pdb{
class PDBWriter : ( inherits?? )
{
      bool write ( Record_OP const & record );
  Iterator begin (                          );
  Iterator   end (                          );
}
}

///////////////////////////////////////////////////////////////////////////////////
//////////////////////////// rosetta::kinematics::Atom ////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class Atom : ( inherits?? )
{
                                void                update_xyz_coords ( Stub & stub                      );
                                void           update_internal_coords ( Stub & stub                     
                                                                      , bool const recursive=true      
                                                                      );
                                void           update_internal_coords ( bool const recursive             );
                                void              update_atom_pointer ( AtomPointers & atom_pointer      );
                                void                      update_stub ( Stub & stub                      ) const;
                                void                      copy_coords ( Atom const & src                 );
                                Real                              dof ( DOF_Type const type              ) const;
                                void                          set_dof ( DOF_Type const type             
                                                                      , Real const value               
                                                                      );
                        Jump const &                             jump (                                  ) const;
                                void                             jump ( Jump const & jump_in             );
                             Atom  *                            clone ( Atom * parent_in                 ) const;
                                void                    setup_min_map ( DOF_ID & last_torsion           
                                                                      , DOF_ID_Mask const & move_map   
                                                                      , MinimizerMap & min_map         
                                                                      ) const;
                                void         get_dof_axis_and_end_pos ( Vector & axis                   
                                                                      , PointPosition & end_pos        
                                                                      , DOF_Type const type            
                                                                      ) const;
                                bool                          is_jump (                                  ) const;
                                bool                   keep_dof_fixed ( DOF_Type const arg0              ) const;
                                void                             show (                                  ) const;
                                Real dihedral_between_bonded_children ( Atom const * child1             
                                                                      , Atom const * child2            
                                                                      ) const;
                                void                update_domain_map ( int & current_color             
                                                                      , int & biggest_color            
                                                                      , DomainMap & domain_map         
                                                                      , AtomID_Mask const & dof_moved  
                                                                      , AtomID_Mask const & atom_moved 
                                                                      ) const;
  iter<Atom* const*,vector<Atom*,> >                      atoms_begin (                                  ) const;
  iter<Atom* const*,vector<Atom*,> >                        atoms_end (                                  ) const;
        iter<Atom**,vector<Atom*,> >                      atoms_begin (                                  );
        iter<Atom**,vector<Atom*,> >                        atoms_end (                                  );
                              size_t                           n_atom (                                  ) const;
                                void                      append_atom ( Atom * arg0                      );
                                void                      delete_atom ( Atom * arg0                      );
                                void                      insert_atom ( Atom * arg0                      );
                                void                      insert_atom ( Atom * arg0                     
                                                                      , int const arg1                 
                                                                      );
                                void                     replace_atom ( Atom * const old_atom           
                                                                      , Atom * const new_atom          
                                                                      );
                        Atom const *                 get_nonjump_atom ( int const i                      ) const;
                                void                            erase (                                  );
                                 int                       n_children (                                  ) const;
                        Atom const *                            child ( int const k                      ) const;
                             Atom  *                            child ( int const k                      );
                                bool                       downstream ( Atom const * atom1               ) const;
                      AtomID const &                               id (                                  ) const;
                                void                               id ( AtomID const & id_in             );
                      AtomID const &                          atom_id (                                  ) const;
               PointPosition const &                         position (                                  ) const;
                                void                         position ( PointPosition const & position_a );
               PointPosition const &                              xyz (                                  ) const;
                                void                              xyz ( PointPosition const & position_a );
                      Length const &                                x (                                  ) const;
                      Length const &                                y (                                  ) const;
                      Length const &                                z (                                  ) const;
                              Length                         distance ( Atom const & atom                ) const;
                              Length                 distance_squared ( Atom const & atom                ) const;
                        Atom const *                           parent (                                  ) const;
                                void                           parent ( Atom * parent_in                 );
                             Atom  *                           parent (                                  );
                                Stub                         get_stub (                                  ) const;
                                Stub                   get_input_stub (                                  ) const;
                        Atom const *                       stub_atom1 (                                  ) const;
                        Atom const *                       stub_atom2 (                                  ) const;
                        Atom const *                       stub_atom3 (                                  ) const;
                      AtomID const &                    stub_atom1_id (                                  ) const;
                      AtomID const &                    stub_atom2_id (                                  ) const;
                      AtomID const &                    stub_atom3_id (                                  ) const;
                        Atom const *                 input_stub_atom0 (                                  ) const;
                        Atom const *                 input_stub_atom1 (                                  ) const;
                        Atom const *                 input_stub_atom2 (                                  ) const;
                        Atom const *                 input_stub_atom3 (                                  ) const;
                      AtomID const &              input_stub_atom0_id (                                  ) const;
                      AtomID const &              input_stub_atom1_id (                                  ) const;
                      AtomID const &              input_stub_atom2_id (                                  ) const;
                      AtomID const &              input_stub_atom3_id (                                  ) const;
                        Atom const *                 previous_sibling (                                  ) const;
                        Atom const *                   previous_child ( Atom const * child               ) const;
                             Atom  *                       next_child ( Atom const * child               );
                                bool                     stub_defined (                                  ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////////// rosetta::kinematics::AtomID ///////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class AtomID : ( inherits?? )
{
     int    rsd (  ) const;
  int  &    rsd (  );
     int atomno (  ) const;
  int  & atomno (  );
    bool  valid (  ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////////// rosetta::kinematics::AtomID_Map<bool> //////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class AtomID_Map<bool> : ( inherits?? )
{
          void        AtomID_Map<bool>::resize ( size_t const n_res           );
          void        AtomID_Map<bool>::resize ( size_t const i_res          
                                               , size_t const n_atom        
                                               );
          void        AtomID_Map<bool>::resize ( size_t const i_res          
                                               , size_t const n_atom        
                                               , bool const & value         
                                               );
          void          AtomID_Map<bool>::fill (                              );
          void     AtomID_Map<bool>::fill_with ( bool const & value           );
          void     AtomID_Map<bool>::fill_with ( size_t const seqpos         
                                               , bool const & value         
                                               );
          bool           AtomID_Map<bool>::get ( AtomID const & id            ) const;
          void           AtomID_Map<bool>::set ( AtomID const & id           
                                               , bool const & value         
                                               );
          void      AtomID_Map<bool>::finalize (                              );
          void        AtomID_Map<bool>::shrink (                              );
          void          AtomID_Map<bool>::swap ( AtomID_Map<bool> & s         );
          void         AtomID_Map<bool>::clear (                              );
          void         AtomID_Map<bool>::clear ( bool const & default_value_a );
        size_t          AtomID_Map<bool>::size (                              ) const;
        size_t     AtomID_Map<bool>::n_residue (                              ) const;
        size_t        AtomID_Map<bool>::n_atom ( size_t const i_res           ) const;
          bool         AtomID_Map<bool>::empty (                              ) const;
  bool const & AtomID_Map<bool>::default_value (                              ) const;
          void AtomID_Map<bool>::default_value ( bool const & default_value_a );
          bool           AtomID_Map<bool>::has ( AtomID const & id            ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////// rosetta::kinematics::AtomID_Map<rosetta::kinematics::Atom*> ///////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class AtomID_Map<rosetta::kinematics::Atom*> : ( inherits?? )
{
            void        AtomID_Map<Atom*>::resize ( size_t const n_res             );
            void        AtomID_Map<Atom*>::resize ( size_t const i_res            
                                                  , size_t const n_atom          
                                                  );
            void        AtomID_Map<Atom*>::resize ( size_t const i_res            
                                                  , size_t const n_atom          
                                                  , Atom * const & value         
                                                  );
            void          AtomID_Map<Atom*>::fill (                                );
            void     AtomID_Map<Atom*>::fill_with ( Atom * const & value           );
            void     AtomID_Map<Atom*>::fill_with ( size_t const seqpos           
                                                  , Atom * const & value         
                                                  );
  Atom * const &           AtomID_Map<Atom*>::get ( AtomID const & id              ) const;
            void           AtomID_Map<Atom*>::set ( AtomID const & id             
                                                  , Atom * const & value         
                                                  );
            void      AtomID_Map<Atom*>::finalize (                                );
            void        AtomID_Map<Atom*>::shrink (                                );
            void          AtomID_Map<Atom*>::swap ( AtomID_Map<Atom*> & s          );
            void         AtomID_Map<Atom*>::clear (                                );
            void         AtomID_Map<Atom*>::clear ( Atom * const & default_value_a );
          size_t          AtomID_Map<Atom*>::size (                                ) const;
          size_t     AtomID_Map<Atom*>::n_residue (                                ) const;
          size_t        AtomID_Map<Atom*>::n_atom ( size_t const i_res             ) const;
            bool         AtomID_Map<Atom*>::empty (                                ) const;
  Atom * const & AtomID_Map<Atom*>::default_value (                                ) const;
            void AtomID_Map<Atom*>::default_value ( Atom * const & default_value_a );
            bool           AtomID_Map<Atom*>::has ( AtomID const & id              ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
//////// rosetta::kinematics::AtomID_Map<rosetta::optimization::DOF_Node*> ////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class AtomID_Map<rosetta::optimization::DOF_Node*> : ( inherits?? )
{
                void        AtomID_Map<DOF_Node*>::resize ( size_t const n_res                 );
                void        AtomID_Map<DOF_Node*>::resize ( size_t const i_res                
                                                          , size_t const n_atom              
                                                          );
                void        AtomID_Map<DOF_Node*>::resize ( size_t const i_res                
                                                          , size_t const n_atom              
                                                          , DOF_Node * const & value         
                                                          );
                void          AtomID_Map<DOF_Node*>::fill (                                    );
                void     AtomID_Map<DOF_Node*>::fill_with ( DOF_Node * const & value           );
                void     AtomID_Map<DOF_Node*>::fill_with ( size_t const seqpos               
                                                          , DOF_Node * const & value         
                                                          );
  DOF_Node * const &           AtomID_Map<DOF_Node*>::get ( AtomID const & id                  ) const;
                void           AtomID_Map<DOF_Node*>::set ( AtomID const & id                 
                                                          , DOF_Node * const & value         
                                                          );
                void      AtomID_Map<DOF_Node*>::finalize (                                    );
                void        AtomID_Map<DOF_Node*>::shrink (                                    );
                void          AtomID_Map<DOF_Node*>::swap ( AtomID_Map<DOF_Node*> & s          );
                void         AtomID_Map<DOF_Node*>::clear (                                    );
                void         AtomID_Map<DOF_Node*>::clear ( DOF_Node * const & default_value_a );
              size_t          AtomID_Map<DOF_Node*>::size (                                    ) const;
              size_t     AtomID_Map<DOF_Node*>::n_residue (                                    ) const;
              size_t        AtomID_Map<DOF_Node*>::n_atom ( size_t const i_res                 ) const;
                bool         AtomID_Map<DOF_Node*>::empty (                                    ) const;
  DOF_Node * const & AtomID_Map<DOF_Node*>::default_value (                                    ) const;
                void AtomID_Map<DOF_Node*>::default_value ( DOF_Node * const & default_value_a );
                bool           AtomID_Map<DOF_Node*>::has ( AtomID const & id                  ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////////////// rosetta::kinematics::AtomTree //////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class AtomTree : ( inherits?? )
{
                   void             add_atom ( AtomID const & id1                   
                                             , AtomID const & id2                  
                                             , bool const add_bonded_atom          
                                             , bool const from_xyz                 
                                             );
                   void       insert_subtree ( Atom * const subtree_root            
                                             , AtomID const & anchor_id            
                                             , bool const insert_at_front          
                                             );
                   void      replace_subtree ( Atom * const subtree_root            
                                             , vector<AtomID                       
                                             , allocator<AtomID> > const & old_atoms
                                             , AtomID_Map<AtomID> const & atom_map 
                                             );
                   void         replace_tree ( Atom * new_root                      
                                             , bool const from_xyz=true            
                                             );
                   void          copy_coords ( AtomTree const & src                  );
                   void              set_dof ( DOF_ID const & id                    
                                             , Real const setting                  
                                             );
                   void              set_xyz ( AtomID const & id                    
                                             , PointPosition const & xyz           
                                             );
                   void             set_jump ( AtomID const & id                    
                                             , Jump const & jump                   
                                             );
                 DOF_ID    set_torsion_angle ( AtomID const & atom1                 
                                             , AtomID const & atom2                
                                             , AtomID const & atom3                
                                             , AtomID const & atom4                
                                             , Real const setting                  
                                             );
                   void    update_domain_map ( DomainMap & domain_map               
                                             , AtomID_Mask const & dof_moved       
                                             , AtomID_Mask const & xyz_moved       
                                             ) const;
                   void                clear (                                       );
           Atom const *                 root (                                       ) const;
                   Real                  dof ( DOF_ID const & id                     ) const;
  PointPosition const &                  xyz ( AtomID const & id                     ) const;
           Atom const &                 atom ( AtomID const & id                     ) const;
           Jump const &                 jump ( AtomID const & id                     ) const;
                 DOF_ID torsion_angle_dof_id ( AtomID const & atom1                 
                                             , AtomID const & atom2                
                                             , AtomID const & atom3                
                                             , AtomID const & atom4                
                                             ) const;
                 DOF_ID torsion_angle_dof_id ( AtomID const & atom1_in_id           
                                             , AtomID const & atom2_in_id          
                                             , AtomID const & atom3_in_id          
                                             , AtomID const & atom4_in_id          
                                             , Real & offset                       
                                             ) const;
                   Real        torsion_angle ( AtomID const & atom1                 
                                             , AtomID const & atom2                
                                             , AtomID const & atom3                
                                             , AtomID const & atom4                
                                             ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
/////////////////////////// rosetta::kinematics::Atom_ ///////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class Atom_ : ( inherits?? )
{
                                void                update_xyz_coords (                                  );
                                void           update_internal_coords ( bool const recursive             );
                                void              update_atom_pointer ( AtomPointers & atom_pointer      );
                                bool                   keep_dof_fixed ( DOF_Type const arg0              ) const;
                                Real dihedral_between_bonded_children ( Atom const * child1             
                                                                      , Atom const * child2            
                                                                      ) const;
                                void                             show (                                  ) const;
                                void                update_domain_map ( int & current_color             
                                                                      , int & biggest_color            
                                                                      , DomainMap & domain_map         
                                                                      , AtomID_Mask const & dof_moved  
                                                                      , AtomID_Mask const & atom_moved 
                                                                      ) const;
  iter<Atom* const*,vector<Atom*,> >                      atoms_begin (                                  ) const;
  iter<Atom* const*,vector<Atom*,> >                        atoms_end (                                  ) const;
        iter<Atom**,vector<Atom*,> >                      atoms_begin (                                  );
        iter<Atom**,vector<Atom*,> >                        atoms_end (                                  );
                              size_t                           n_atom (                                  ) const;
                                void                      append_atom ( Atom * arg0                      );
                                void                      delete_atom ( Atom * arg0                      );
                                void                      insert_atom ( Atom * arg0                      );
                                void                      insert_atom ( Atom * arg0                     
                                                                      , int const arg1                 
                                                                      );
                                void                     replace_atom ( Atom * const old_atom           
                                                                      , Atom * const new_atom          
                                                                      );
                        Atom const *                 get_nonjump_atom ( int const i                      ) const;
                                void                            erase (                                  );
                                 int                       n_children (                                  ) const;
                        Atom const *                            child ( int const k                      ) const;
                             Atom  *                            child ( int const k                      );
                                bool                       downstream ( Atom const * atom1               ) const;
                      AtomID const &                               id (                                  ) const;
                                void                               id ( AtomID const & id_in             );
                      AtomID const &                          atom_id (                                  ) const;
               PointPosition const &                         position (                                  ) const;
                                void                         position ( PointPosition const & position_a );
               PointPosition const &                              xyz (                                  ) const;
                                void                              xyz ( PointPosition const & position_a );
                      Length const &                                x (                                  ) const;
                      Length const &                                y (                                  ) const;
                      Length const &                                z (                                  ) const;
                              Length                         distance ( Atom const & atom                ) const;
                              Length                 distance_squared ( Atom const & atom                ) const;
                        Atom const *                           parent (                                  ) const;
                                void                           parent ( Atom * parent_in                 );
                             Atom  *                           parent (                                  );
                                Stub                         get_stub (                                  ) const;
                                Stub                   get_input_stub (                                  ) const;
                      AtomID const &                    stub_atom1_id (                                  ) const;
                      AtomID const &                    stub_atom2_id (                                  ) const;
                      AtomID const &                    stub_atom3_id (                                  ) const;
                        Atom const *                 input_stub_atom0 (                                  ) const;
                        Atom const *                 input_stub_atom1 (                                  ) const;
                        Atom const *                 input_stub_atom2 (                                  ) const;
                        Atom const *                 input_stub_atom3 (                                  ) const;
                      AtomID const &              input_stub_atom0_id (                                  ) const;
                      AtomID const &              input_stub_atom1_id (                                  ) const;
                      AtomID const &              input_stub_atom2_id (                                  ) const;
                      AtomID const &              input_stub_atom3_id (                                  ) const;
                        Atom const *                 previous_sibling (                                  ) const;
                        Atom const *                   previous_child ( Atom const * child               ) const;
                             Atom  *                       next_child ( Atom const * child               );
                                bool                     stub_defined (                                  ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::kinematics::BondedAtom /////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class BondedAtom : ( inherits?? )
{
          void        update_xyz_coords ( Stub & stub                    );
          void   update_internal_coords ( Stub & stub                   
                                        , bool const recursive=true    
                                        );
          void              update_stub ( Stub & stub                    ) const;
          void                  set_dof ( DOF_Type const type           
                                        , double const value           
                                        );
        double                      dof ( DOF_Type const type            ) const;
  Jump const &                     jump (                                ) const;
          void                     jump ( Jump const & arg0              );
       Atom  *                    clone ( Atom * parent_in               ) const;
          void            setup_min_map ( DOF_ID & last_torsion         
                                        , DOF_ID_Mask const & allow_move
                                        , MinimizerMap & min_map       
                                        ) const;
          void get_dof_axis_and_end_pos ( Vector & axis                 
                                        , PointPosition & end_pos      
                                        , DOF_Type const type          
                                        ) const;
          bool                  is_jump (                                ) const;
          bool           keep_dof_fixed ( DOF_Type const type            ) const;
          void              copy_coords ( Atom const & src               );
  Atom const *               stub_atom1 (                                ) const;
  Atom const *               stub_atom2 (                                ) const;
  Atom const *               stub_atom3 (                                ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////////// rosetta::kinematics::DOF_ID ///////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class DOF_ID : ( inherits?? )
{
  AtomID const & atom_id (  ) const;
             int     rsd (  ) const;
             int  atomno (  ) const;
        DOF_Type    type (  ) const;
            bool   valid (  ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
//////// rosetta::kinematics::DOF_ID_Map<rosetta::optimization::DOF_Node*> ////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class DOF_ID_Map<rosetta::optimization::DOF_Node*> : ( inherits?? )
{
                void        DOF_ID_Map<DOF_Node*>::resize ( size_t const n_res                 );
                void        DOF_ID_Map<DOF_Node*>::resize ( size_t const i_res                
                                                          , size_t const n_atom              
                                                          );
                void        DOF_ID_Map<DOF_Node*>::resize ( size_t const i_res                
                                                          , size_t const n_atom              
                                                          , DOF_Node * const & value         
                                                          );
                void      DOF_ID_Map<DOF_Node*>::finalize (                                    );
                void        DOF_ID_Map<DOF_Node*>::shrink (                                    );
                void          DOF_ID_Map<DOF_Node*>::swap ( DOF_ID_Map<DOF_Node*> & s          );
                void         DOF_ID_Map<DOF_Node*>::clear (                                    );
                void           DOF_ID_Map<DOF_Node*>::set ( DOF_Type const dof                 );
                void           DOF_ID_Map<DOF_Node*>::set ( DOF_Type const dof                
                                                          , DOF_Node * const & value         
                                                          );
              size_t          DOF_ID_Map<DOF_Node*>::size (                                    ) const;
              size_t     DOF_ID_Map<DOF_Node*>::n_residue (                                    ) const;
              size_t        DOF_ID_Map<DOF_Node*>::n_atom ( size_t const i_res                 ) const;
                bool         DOF_ID_Map<DOF_Node*>::empty (                                    ) const;
  DOF_Node * const & DOF_ID_Map<DOF_Node*>::default_value ( DOF_Type const dof                 ) const;
                void DOF_ID_Map<DOF_Node*>::default_value ( DOF_Type const dof                
                                                          , DOF_Node * const & default_value_a
                                                          );
                void DOF_ID_Map<DOF_Node*>::default_value ( DOF_Node * const & default_value_a );
}
}

///////////////////////////////////////////////////////////////////////////////////
//////////////////////////// rosetta::kinematics::Edge ////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class Edge : ( inherits?? )
{
     int             start (  ) const;
  int  &             start (  );
     int              stop (  ) const;
  int  &              stop (  );
     int        start_atom (  ) const;
  int  &        start_atom (  );
     int         stop_atom (  ) const;
  int  &         stop_atom (  );
     int   upstream_atomno (  ) const;
  int  &   upstream_atomno (  );
     int downstream_atomno (  ) const;
  int  & downstream_atomno (  );
     int             label (  ) const;
  int  &             label (  );
    bool           is_jump (  ) const;
    bool     has_atom_info (  ) const;
     int polymer_direction (  ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////////////// rosetta::kinematics::FoldTree //////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class FoldTree : ( inherits?? )
{
                               int                         size (                                    ) const;
  iter<Edge const*,vector<Edge,> >                        begin (                                    ) const;
  iter<Edge const*,vector<Edge,> >                          end (                                    ) const;
                              void                     add_edge ( int const start                   
                                                                , int const stop                   
                                                                , int const label                  
                                                                );
                              void                  delete_edge ( __normal_iterator<Edge*           
                                                                , vector<Edge                      
                                                                , allocator<Edge> > > edge         
                                                                );
                              void                  delete_edge ( Edge const & edge                  );
                              void        delete_unordered_edge ( int const start                   
                                                                , int const stop                   
                                                                , int const label                  
                                                                );
                              void            update_edge_label ( int const start                   
                                                                , int const stop                   
                                                                , int const old_label              
                                                                , int const new_label              
                                                                );
                              void                        clear (                                    );
                              void               renumber_jumps (                                    );
                              void        delete_extra_vertices (                                    );
                              void               delete_segment ( int const seg_begin               
                                                                , int const seg_end                
                                                                );
                               int                     new_jump ( int const jump_pos1               
                                                                , int const jump_pos2              
                                                                , int const cutpoint               
                                                                );
                              void                  simple_tree ( int const nres_in                  );
                              bool random_tree_from_jump_points ( int const nres_in                 
                                                                , int const num_jump_in            
                                                                , FArray2D_int const & jump_point  
                                                                , FArray1D_float const & cut_bias  
                                                                );
                              bool     tree_from_jumps_and_cuts ( int const nres_in                 
                                                                , int const num_jump_in            
                                                                , FArray2D_int const & jump_point  
                                                                , FArray1D_int const & cuts        
                                                                , bool const verbose=true          
                                                                );
                              void               append_residue ( bool const attach_by_jump=false   
                                                                , int const jump_anchor_residue=0  
                                                                , int const jump_upstream_atomno=0 
                                                                , int const jump_downstream_atomno=0
                                                                );
                              bool                      reorder ( int const start_residue            );
                              bool              check_fold_tree (                                    ) const;
                              bool                    connected (                                    ) const;
                               int        upstream_jump_residue ( int const jump_number              ) const;
                               int      downstream_jump_residue ( int const jump_number              ) const;
                              void            partition_by_jump ( int const jump_number             
                                                                , FArray1D_bool & partner1         
                                                                ) const;
                               int             cutpoint_by_jump ( int const jump_number              ) const;
                               int              upstream_atomno ( int const jump_number              ) const;
                               int            downstream_atomno ( int const jump_number              ) const;
                               int        get_residue_direction ( int const seqpos                   ) const;
                              void               set_jump_atoms ( int const jump_number             
                                                                , int const upstream_atomno        
                                                                , int const downstream_atomno      
                                                                );
                               int                         nres (                                    ) const;
                               int                     num_jump (                                    ) const;
                               int                   jump_point ( int const lower_higher            
                                                                , int const jump_number            
                                                                ) const;
                              bool                is_jump_point ( int const seqpos                   ) const;
                               int                     cutpoint ( int const cut                      ) const;
                               int                 num_cutpoint (                                    ) const;
                              bool                  is_cutpoint ( int const seqpos                   ) const;
                               int                 cutpoint_map ( int const seqpos                   ) const;
                      Edge const &                    jump_edge ( int const jump_number              ) const;
              FArray1D_int const &          get_jump_edge_count (                                    ) const;
                               int         count_fixed_residues ( int const begin_res               
                                                                , int const size                   
                                                                , int & min_edge_count_out         
                                                                ) const;
                      vector<int,>                    cutpoints (                                    ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
//////////////////////////// rosetta::kinematics::Jump ////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class Jump : ( inherits?? )
{
                      void             from_stubs ( Stub const & stub1             
                                                  , Stub const & stub2            
                                                  );
                      void              make_jump ( Stub const & stub1             
                                                  , Stub & stub2                  
                                                  ) const;
                      bool            ortho_check (                                 ) const;
                      bool         nonzero_deltas (                                 ) const;
                      void                  reset (                                 );
                      void           random_trans ( float const dist_in             );
                      void          gaussian_move ( int const dir                  
                                                  , float const trans_mag         
                                                  , float const rot_mag           
                                                  );
                      void     rotation_by_matrix ( Stub const & stub              
                                                  , xyzVector_double const & center
                                                  , xyzMatrix_double const & matrix
                                                  );
                      void translation_along_axis ( Stub const & stub              
                                                  , xyzVector_double const & axis 
                                                  , float const dist              
                                                  );
                      void     identity_transform (                                 );
                      void                reverse (                                 );
  xyzMatrix_double const &           get_rotation (                                 ) const;
  xyzVector_double const &        get_translation (                                 ) const;
                      void           set_rotation ( xyzMatrix_double const & R_in   );
                      void        set_translation ( xyzVector_double const & t      );
                      void      fold_in_rb_deltas (                                 );
          FArray1Da_double           get_rb_delta ( int const dir                   ) const;
                    double           get_rb_delta ( int const rb_no                
                                                  , int const dir                 
                                                  ) const;
                      void           set_rb_delta ( int const rb_no                
                                                  , int const dir                 
                                                  , double const value            
                                                  );
  xyzVector_double const &          get_rb_center ( int const dir                   ) const;
                      void          set_rb_center ( int const dir                  
                                                  , Stub const & stub             
                                                  , xyzVector_double const & center
                                                  );
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////////////// rosetta::kinematics::JumpAtom //////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class JumpAtom : ( inherits?? )
{
          void        update_xyz_coords ( Stub & stub                    );
          void   update_internal_coords ( Stub & stub                   
                                        , bool const recursive=true    
                                        );
          void                  set_dof ( DOF_Type const type           
                                        , double const value           
                                        );
        double                      dof ( DOF_Type const type            ) const;
  Jump const &                     jump (                                ) const;
          void                     jump ( Jump const & jump_in           );
       Atom  *                    clone ( Atom * parent_in               ) const;
          void            setup_min_map ( DOF_ID & last_torsion         
                                        , DOF_ID_Mask const & allow_move
                                        , MinimizerMap & min_map       
                                        ) const;
          void get_dof_axis_and_end_pos ( Vector & axis                 
                                        , PointPosition & end_pos      
                                        , DOF_Type const type          
                                        ) const;
          bool                  is_jump (                                ) const;
          bool           keep_dof_fixed ( DOF_Type const type            ) const;
          void              copy_coords ( Atom const & src               );
          void              update_stub ( Stub & arg0                    ) const;
  Atom const *               stub_atom1 (                                ) const;
  Atom const *               stub_atom2 (                                ) const;
  Atom const *               stub_atom3 (                                ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
////////////////////////// rosetta::kinematics::MoveMap //////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class MoveMap : ( inherits?? )
{
                                           void      clear (                       );
                                           void     set_bb ( int const seqpos     
                                                           , bool const setting  
                                                           );
                                           void     set_bb ( bool const setting    );
                                           void    set_chi ( int const seqpos     
                                                           , bool const setting  
                                                           );
                                           void    set_chi ( bool const setting    );
                                           void   set_jump ( int const jump_number
                                                           , bool const setting  
                                                           );
                                           void   set_jump ( bool const setting    );
                                           void vary_omega ( bool const setting    );
                                           void        set ( DOF_Type const & t   
                                                           , bool const setting  
                                                           );
                                           void        set ( DOF_ID const & id    
                                                           , bool const setting  
                                                           );
                                           bool     get_bb ( int const seqpos      ) const;
                                           bool    get_chi ( int const seqpos      ) const;
                                           bool   get_jump ( int const jump_number ) const;
                                           bool        get ( DOF_Type const & t    ) const;
                                           bool        get ( DOF_ID const & id     ) const;
                                           bool vary_omega (                       ) const;
  _Rb_tree_const_iter<pair<DOF_ID const,bool> >  dof_begin (                       ) const;
  _Rb_tree_const_iter<pair<DOF_ID const,bool> >    dof_end (                       ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////// rosetta::kinematics::RT /////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class RT : ( inherits?? )
{
                      void         from_stubs ( Stub const & stub1                
                                              , Stub const & stub2               
                                              );
                      void            reverse (                                    );
                      void              reset (                                    );
                      void identity_transform (                                    );
                      void    set_translation ( xyzVector_double const & t         );
                      void       set_rotation ( xyzMatrix_double const & r         );
  xyzMatrix_double const &       get_rotation (                                    ) const;
  xyzVector_double const &    get_translation (                                    ) const;
                      void  fold_in_rb_deltas ( FArray1Da_double rb               
                                              , xyzVector_double const & rb_center
                                              );
                      void          make_jump ( Stub const & stub1                
                                              , Stub & stub2                     
                                              ) const;
                      bool        ortho_check (                                    ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
//////////////////////////// rosetta::kinematics::Stub ////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class Stub : ( inherits?? )
{
              void from_four_points ( xyzVector_double const & center
                                    , xyzVector_double const & a    
                                    , xyzVector_double const & b    
                                    , xyzVector_double const & c    
                                    );
              bool    is_orthogonal ( double const & tolerance        ) const;
  xyzVector_double     global2local ( xyzVector_double const & xyz    ) const;
  xyzVector_double     local2global ( xyzVector_double const & xyz    ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::kinematics::TorsionID /////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::kinematics{
class TorsionID : ( inherits?? )
{
             int     rsd (  ) const;
          int  &     rsd (  );
     TorsionType    type (  ) const;
  TorsionType  &    type (  );
             int torsion (  ) const;
          int  & torsion (  );
            bool   valid (  ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::optimization::AtomNode /////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::optimization{
class AtomNode : ( inherits?? )
{
                                   int            rsd (                ) const;
                                   int         atomno (                ) const;
  iter<AtomNode**,vector<AtomNode*,> > nbr_list_begin (                );
  iter<AtomNode**,vector<AtomNode*,> >   nbr_list_end (                );
                                  void        add_nbr ( AtomNode * nbr );
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////// rosetta::optimization::AtomTreeMinimizer ////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::optimization{
class AtomTreeMinimizer : ( inherits?? )
{
  Real run ( Pose & pose                     
           , MoveMap const & move_map       
           , ScoreFunction const & scorefxn 
           , MinimizerOptions const & options
           ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////// rosetta::optimization::AtomTreeMultifunc ////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::optimization{
class AtomTreeMultifunc : ( inherits?? )
{
  void dfunc ( Multivec const & vars
             , Multivec & dE_dvars 
             ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::optimization::DOF_Node /////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::optimization{
class DOF_Node : ( inherits?? )
{
                 Vector  &           F1 (                         );
                 Vector  &           F2 (                         );
            Vector const &           F1 (                         ) const;
            Vector const &           F2 (                         ) const;
                       int          rsd (                         ) const;
                       int       atomno (                         ) const;
            AtomID const &      atom_id (                         ) const;
                  DOF_Type         type (                         ) const;
            DOF_ID const &       dof_id (                         ) const;
                       int        depth (                         ) const;
  vector1<AtomID,> const &        atoms (                         ) const;
          DOF_Node const *       parent (                         ) const;
                      void     add_atom ( AtomID const & atom     );
         TorsionID const &   torsion_id (                         ) const;
                      void   torsion_id ( TorsionID const & id_in );
                      void link_vectors (                         );
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////// rosetta::optimization::Minimizer ////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::optimization{
class Minimizer : ( inherits?? )
{
  Real run ( Multivec & phipsi_inout ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////// rosetta::optimization::MinimizerMap ///////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::optimization{
class MinimizerMap : ( inherits?? )
{
                         void                setup ( Pose & pose               
                                                   , MoveMap const & move_map 
                                                   );
                         void          add_torsion ( DOF_ID const & new_torsion
                                                   , DOF_ID const & parent    
                                                   );
                         void             add_atom ( AtomID const & atom_id    
                                                   , DOF_ID const & dof_id    
                                                   );
  _List_const_iter<DOF_Node*>                begin (                            ) const;
  _List_const_iter<DOF_Node*>                  end (                            ) const;
        _List_iter<DOF_Node*>                begin (                            );
        _List_iter<DOF_Node*>                  end (                            );
     list<DOF_Node*,> const &            dof_nodes (                            ) const;
          list<DOF_Node*,>  &            dof_nodes (                            );
                         void link_torsion_vectors (                            );
                         void zero_torsion_vectors (                            );
                         void                reset ( Pose const & pose          );
                         void  copy_dofs_from_pose ( Pose const & pose         
                                                   , Multivec & dofs          
                                                   ) const;
                         void    copy_dofs_to_pose ( Pose & pose               
                                                   , Multivec const & dofs    
                                                   ) const;
                          int              nangles (                            ) const;
                         void reset_jump_rb_deltas ( Pose & pose               
                                                   , Multivec & dofs          
                                                   ) const;
                         Real torsion_scale_factor ( DOF_Node const & tor       ) const;
            DomainMap const &           domain_map (                            ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////// rosetta::optimization::MinimizerOptions /////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::optimization{
class MinimizerOptions : ( inherits?? )
{
  string const &            min_type (  ) const;
       string  &            min_type (  );
            bool         deriv_check (  ) const;
            Real  minimize_tolerance (  ) const;
         Real  &  minimize_tolerance (  );
            bool          use_nblist (  ) const;
            Real             ax_init (  ) const;
            Real             xx_init (  ) const;
            Real             bx_init (  ) const;
            Real brent_abs_tolerance (  ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////// rosetta::optimization::Multifunc ////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::optimization{
class Multifunc : ( inherits?? )
{
  void dfunc ( Multivec const & phipsi
             , Multivec & dE_dphipsi 
             ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////// rosetta::pack::rotamer_set::AminoAcidRotamerSet /////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::rotamer_set{
class AminoAcidRotamerSet : ( inherits?? )
{
        void            build_rotamers ( Pose const & the_pose             
                                       , ScoreFunction const & scorefxn   
                                       , PackerTask const & task          
                                       , ResidueSet const & residue_set   
                                       );
        void compute_one_body_energies ( Pose const & pose                 
                                       , ScoreFunction const & scorefxn   
                                       , HBondSet const & hbs             
                                       , PackerTask const & task          
                                       , vector1<double                   
                                       , allocator<double> > & energies   
                                       ) const;
        void compute_all_pair_energies ( RotamerSet const & other          
                                       , ScoreFunction const & scorefxn   
                                       , FArray2D_float & pair_energy_table
                                       ) const;
      size_t              num_rotamers (                                    ) const;
      size_t    id_for_current_rotamer (                                    ) const;
  RotamerCOP               get_rotamer ( size_t rot_id                      ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////// rosetta::pack::rotamer_set::BumpSelector ////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::rotamer_set{
class BumpSelector : ( inherits?? )
{
  void                 reset (                            );
  void iterate_bump_selector ( Energy bumpenegy          
                             , bool & delete_current_rot
                             , bool & delete_previous_rot
                             );
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////////// rosetta::pack::rotamer_set::RotamerSet /////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::rotamer_set{
class RotamerSet : ( inherits?? )
{
        void                 set_resid ( int resid                          );
        void            build_rotamers ( Pose const & the_pose             
                                       , ScoreFunction const & scorefxn   
                                       , PackerTask const & task          
                                       , ResidueSet const & residue_set   
                                       );
        void compute_one_body_energies ( Pose const & pose                 
                                       , ScoreFunction const & scorefxn   
                                       , HBondSet const & hbs             
                                       , PackerTask const & task          
                                       , vector1<double                   
                                       , allocator<double> > & energies   
                                       ) const;
        void compute_all_pair_energies ( RotamerSet const & other          
                                       , ScoreFunction const & scorefxn   
                                       , FArray2D_float & pair_energy_table
                                       ) const;
      size_t              num_rotamers (                                    ) const;
      size_t    id_for_current_rotamer (                                    ) const;
         int                     resid (                                    ) const;
  RotamerCOP               get_rotamer ( size_t rot_id                      ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////// rosetta::pack::rotamer_set::RotamerSetFactory //////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::rotamer_set{
class RotamerSetFactory : ( inherits?? )
{
  RotamerSetOP create_rotamer_set ( LiteResidue const & arg0 );
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////// rosetta::pack::rotamer_set::RotamerSets /////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::rotamer_set{
class RotamerSets : ( inherits?? )
{
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::pack::task::PackerTask /////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::task{
class PackerTask : ( inherits?? )
{
       PackerTaskOP                    clone (                     ) const;
             size_t            total_residue (                     ) const;
               void           fix_everything (                     );
               void         set_pack_residue ( int resid          
                                             , bool setting      
                                             );
               bool             pack_residue ( int resid           ) const;
             size_t         num_to_be_packed (                     ) const;
               void       set_design_residue ( int resid          
                                             , bool setting      
                                             );
               bool           design_residue ( int reside          ) const;
               void             set_allow_aa ( int resid          
                                             , AA aa             
                                             , bool setting      
                                             );
               bool                 allow_aa ( int resid          
                                             , AA aa             
                                             ) const;
               void       set_allow_concrete ( int resid          
                                             , string const & name
                                             , bool setting      
                                             );
               bool           allow_concrete ( int resid          
                                             , string const & name
                                             ) const;
               bool repacking_allow_concrete ( AA aa              
                                             , string const & name
                                             ) const;
               void           set_bump_check ( bool setting        );
               bool               bump_check (                     ) const;
               void      set_include_current ( bool setting        );
               bool          include_current (                     ) const;
   RotamerOptionsOP          rotamer_options (                     );
  RotamerOptionsCOP          rotamer_options (                     ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////// rosetta::pack::task::PackerTask_ ////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::task{
class PackerTask_ : ( inherits?? )
{
       PackerTaskOP                    clone (                     ) const;
             size_t            total_residue (                     ) const;
               void           fix_everything (                     );
               void         set_pack_residue ( int resid          
                                             , bool setting      
                                             );
               bool             pack_residue ( int resid           ) const;
             size_t         num_to_be_packed (                     ) const;
               void       set_design_residue ( int resid          
                                             , bool setting      
                                             );
               bool           design_residue ( int reside          ) const;
               void             set_allow_aa ( int resid          
                                             , AA aa             
                                             , bool setting      
                                             );
               bool                 allow_aa ( int resid          
                                             , AA aa             
                                             ) const;
               void       set_allow_concrete ( int resid          
                                             , string const & arg1
                                             , bool setting      
                                             );
               bool           allow_concrete ( int resid          
                                             , string const & arg1
                                             ) const;
               bool repacking_allow_concrete ( AA aa              
                                             , string const & name
                                             ) const;
               void           set_bump_check ( bool setting        );
               bool               bump_check (                     ) const;
               void      set_include_current ( bool setting        );
               bool          include_current (                     ) const;
   RotamerOptionsOP          rotamer_options (                     );
  RotamerOptionsCOP          rotamer_options (                     ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////// rosetta::pack::task::RotamerOptions ///////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::task{
class RotamerOptions : ( inherits?? )
{
  RotamerOptionsOP                   clone (                                       ) const;
              void setup_from_command_line (                                       );
              void                 set_ex1 ( bool arg0                             );
              bool                     ex1 (                                       ) const;
              void                 set_ex2 ( bool arg0                             );
              bool                     ex2 (                                       ) const;
              void                 set_ex3 ( bool arg0                             );
              bool                     ex3 (                                       ) const;
              void                 set_ex4 ( bool arg0                             );
              bool                     ex4 (                                       ) const;
              void              set_ex1aro ( bool arg0                             );
              bool                  ex1aro (                                       ) const;
              void         set_ex1aro_half ( bool arg0                             );
              bool             ex1aro_half (                                       ) const;
              void         set_ex2aro_only ( bool arg0                             );
              bool             ex2aro_only (                                       ) const;
              void      set_ex1aro_exposed ( bool arg0                             );
              bool          ex1aro_exposed (                                       ) const;
              void      set_ex2aro_exposed ( bool arg0                             );
              bool          ex2aro_exposed (                                       ) const;
              void                set_exOH ( bool arg0                             );
              bool                    exOH (                                       ) const;
              void               set_excys ( bool arg0                             );
              bool                   excys (                                       ) const;
              void    set_ex1_sample_level ( ExtraRotSample arg0                   );
    ExtraRotSample        ex1_sample_level (                                       ) const;
              void    set_ex2_sample_level ( ExtraRotSample arg0                   );
    ExtraRotSample        ex2_sample_level (                                       ) const;
              void    set_ex3_sample_level ( ExtraRotSample arg0                   );
    ExtraRotSample        ex3_sample_level (                                       ) const;
              void    set_ex4_sample_level ( ExtraRotSample arg0                   );
    ExtraRotSample        ex4_sample_level (                                       ) const;
              void    set_exrotset_from_db ( bool arg0                             );
              bool        exrotset_from_db (                                       ) const;
              void       set_extrachi_flag ( bool buried                          
                                           , int chi                             
                                           , AA const arg2                       
                                           , ExtraRotSample setting              
                                           );
    ExtraRotSample           extrachi_flag ( bool buried                          
                                           , int chi                             
                                           , AA const arg2                       
                                           ) const;
              void       set_extra_samples ( int num_10A_neighbors                
                                           , int chi                             
                                           , AA const aa_type                    
                                           , vector1<double                      
                                           , allocator<double> > & extra_chi_steps
                                           ) const;
              void     set_extrachi_cutoff ( int arg0                              );
               int         extrachi_cutoff (                                       ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
/////////////////// rosetta::pack::task::RotamerOptionsFactory ///////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::task{
class RotamerOptionsFactory : ( inherits?? )
{
  static RotamerOptionsOP create_rotamer_options (  );
}
}

//////////////////////////////////////////////////////////////////////////////////
////////////////////// rosetta::pack::task::RotamerOptions_ //////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::task{
class RotamerOptions_ : ( inherits?? )
{
  RotamerOptionsOP                   clone (                                       ) const;
              void setup_from_command_line (                                       );
              void                 set_ex1 ( bool arg0                             );
              bool                     ex1 (                                       ) const;
              void                 set_ex2 ( bool arg0                             );
              bool                     ex2 (                                       ) const;
              void                 set_ex3 ( bool arg0                             );
              bool                     ex3 (                                       ) const;
              void                 set_ex4 ( bool arg0                             );
              bool                     ex4 (                                       ) const;
              void              set_ex1aro ( bool arg0                             );
              bool                  ex1aro (                                       ) const;
              void         set_ex1aro_half ( bool arg0                             );
              bool             ex1aro_half (                                       ) const;
              void         set_ex2aro_only ( bool arg0                             );
              bool             ex2aro_only (                                       ) const;
              void      set_ex1aro_exposed ( bool arg0                             );
              bool          ex1aro_exposed (                                       ) const;
              void      set_ex2aro_exposed ( bool arg0                             );
              bool          ex2aro_exposed (                                       ) const;
              void                set_exOH ( bool arg0                             );
              bool                    exOH (                                       ) const;
              void               set_excys ( bool arg0                             );
              bool                   excys (                                       ) const;
              void    set_ex1_sample_level ( ExtraRotSample arg0                   );
    ExtraRotSample        ex1_sample_level (                                       ) const;
              void    set_ex2_sample_level ( ExtraRotSample arg0                   );
    ExtraRotSample        ex2_sample_level (                                       ) const;
              void    set_ex3_sample_level ( ExtraRotSample arg0                   );
    ExtraRotSample        ex3_sample_level (                                       ) const;
              void    set_ex4_sample_level ( ExtraRotSample arg0                   );
    ExtraRotSample        ex4_sample_level (                                       ) const;
              void    set_exrotset_from_db ( bool arg0                             );
              bool        exrotset_from_db (                                       ) const;
              void       set_extrachi_flag ( bool buried                          
                                           , int chi                             
                                           , AA const aa_type                    
                                           , ExtraRotSample setting              
                                           );
    ExtraRotSample           extrachi_flag ( bool buried                          
                                           , int chi                             
                                           , AA const aa_type                    
                                           ) const;
              void       set_extra_samples ( int num_10A_neighbors                
                                           , int chi                             
                                           , AA const aa_type                    
                                           , vector1<double                      
                                           , allocator<double> > & extra_chi_steps
                                           ) const;
              void     set_extrachi_cutoff ( int arg0                              );
               int         extrachi_cutoff (                                       ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////// rosetta::pack::task::TaskFactory ////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pack::task{
class TaskFactory : ( inherits?? )
{
  static PackerTaskOP create_packer_task ( int nres );
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////// rosetta::pose::Energies /////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pose{
class Energies : ( inherits?? )
{
     EnergyMap const &           total_energies (                                 ) const;
          EnergyMap  &           total_energies (                                 );
     EnergyMap const &         onebody_energies ( int const seqpos                ) const;
          EnergyMap  &         onebody_energies ( int const seqpos                );
   EnergyGraph const &             energy_graph (                                 ) const;
        EnergyGraph  &             energy_graph (                                 );
         Graph const &      tenA_neighbor_graph (                                 ) const;
              Graph  &      tenA_neighbor_graph (                                 );
                  void update_residue_neighbors ( DomainMap const & domain_map_in
                                                , Pose const & pose             
                                                );
                  bool                res_moved ( int const seqpos                ) const;
                  void           clear_energies (                                 );
                  Size                     size (                                 ) const;
                  void                     show ( ostream & out                   ) const;
                  void      structure_has_moved ( Size const nres                 ) const;
                  void            scoring_begin ( DomainMap const & domain_map_in
                                                , ScoreFunctionInfo const & info
                                                , bool const update_neighbors   
                                                , Pose const & pose             
                                                );
                  void              scoring_end (                                 );
                  void                    clear (                                 );
                  bool               use_nblist (                                 ) const;
  NeighborList const &                   nblist ( CachedDataType const & type     ) const;
                  void               set_nblist ( CachedDataType const & type    
                                                , NeighborList & nblist_in      
                                                );
                  void           set_use_nblist ( Pose const & pose              
                                                , DomainMap const & domain_map_in
                                                );
                  void             reset_nblist (                                 );
                  void               store_data ( CachedDataType const & type    
                                                , CachedData & data             
                                                );
    CachedData const &                 get_data ( CachedDataType const & type     ) const;
                   int               domain_map ( int const pos                   ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
//////////////////////////// rosetta::pose::MonteCarlo ////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pose{
class MonteCarlo : ( inherits?? )
{
                   void set_temperature ( float const temp               );
                   void    set_autotemp ( bool const setting            
                                        , float const quench_temp      
                                        );
                   bool       boltzmann ( Pose & pose                   
                                        , string const & move_type="unk"
                                        );
                   void           reset ( Pose const & pose              );
           Pose const &       best_pose (                                ) const;
           Pose const &        low_pose (                                ) const;
                   void     recover_low ( Pose & pose                    );
                   void  score_function ( ScoreFunction const & scorefxn );
  ScoreFunction const &  score_function (                                ) const;
                   void     show_scores (                                ) const;
                   void  reset_counters (                                );
                   void   show_counters (                                ) const;
                  float      best_score (                                ) const;
                  float       low_score (                                ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////////////// rosetta::pose::Pose ///////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::pose{
class Pose : ( inherits?? )
{
   Conformation const &             conformation (                                 ) const;
       FoldTree const &                fold_tree (                                 ) const;
                   void                fold_tree ( FoldTree const & fold_tree_in   );
       AtomTree const &                atom_tree (                                 ) const;
                    int                    chain ( int const seqpos                ) const;
       Energies const &                 energies (                                 ) const;
            Energies  &                 energies (                                 );
                   void           append_residue ( ResidueCOP new_rsd             
                                                 , bool const attach_by_jump=false
                                                 , int const jump_anchor_residue=0
                                                 , int const jump_anchor_atomno=0
                                                 , int const jump_root_atomno=0  
                                                 );
                   void          replace_residue ( int const seqpos               
                                                 , Residue const & new_rsd_in    
                                                 , bool const orient_backbone    
                                                 );
                   void             copy_segment ( int const size                 
                                                 , Pose const & src              
                                                 , int const begin               
                                                 , int const src_begin           
                                                 );
                   Size            total_residue (                                 ) const;
                   Size                n_residue (                                 ) const;
                    int                 num_jump (                                 ) const;
        Residue const &                  residue ( int const seqpos                ) const;
                   Real                      phi ( int const pos                   ) const;
                   void                  set_phi ( int const seqpos               
                                                 , Real const setting            
                                                 );
                   Real                      psi ( int const seqpos                ) const;
                   void                  set_psi ( int const seqpos               
                                                 , Real const setting            
                                                 );
                   Real                    omega ( int const seqpos                ) const;
                   void                set_omega ( int const seqpos               
                                                 , Real const setting            
                                                 );
                   void                 set_jump ( int const jump_number          
                                                 , Jump const & new_jump         
                                                 );
           Jump const &                     jump ( int const jump_number           ) const;
                   void                 set_jump ( AtomID const & id              
                                                 , Jump const & new_jump         
                                                 );
           Jump const &                     jump ( AtomID const & id               ) const;
                   Real                      chi ( int const chino                
                                                 , int const seqpos              
                                                 ) const;
                   void                  set_chi ( int const chino                
                                                 , int const seqpos              
                                                 , Real const setting            
                                                 );
                   Real                  torsion ( TorsionID const & id            ) const;
                   void              set_torsion ( TorsionID const & id           
                                                 , Real const setting            
                                                 );
                   Real                      dof ( DOF_ID const & id               ) const;
                   void                  set_dof ( DOF_ID const & id              
                                                 , Real const setting            
                                                 );
  PointPosition const &                      xyz ( AtomID const & id               ) const;
                   void                  set_xyz ( AtomID const & id              
                                                 , PointPosition const & point   
                                                 );
                   void update_residue_neighbors (                                 );
                   void            scoring_begin ( ScoreFunctionInfo const & info 
                                                 , bool const update_neighbors   
                                                 );
                   void              scoring_end (                                 );
                   void         update_actcoords (                                 );
                   void                    clear (                                 );
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::scoring::AtomNeighbor /////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class AtomNeighbor : ( inherits?? )
{
   int    rsd (  ) const;
   int atomno (  ) const;
  Real weight (  ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
////////////////////////// rosetta::scoring::CachedData //////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class CachedData : ( inherits?? )
{
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////// rosetta::scoring::count_pair::CountPair1 ////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::count_pair{
class CountPair1 : ( inherits?? )
{
  bool                    count ( int const at1            
                                , int const at2           
                                , Real & arg2             
                                ) const;
  void residue_atom_pair_energy ( LiteResidue const & arg0 
                                , LiteResidue const & arg1
                                , EtableEnergy const & arg2
                                , EnergyMap & arg3        
                                ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////// rosetta::scoring::count_pair::CountPair2 ////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::count_pair{
class CountPair2 : ( inherits?? )
{
  bool                    count ( int const at1            
                                , int const at2           
                                , Real & w                
                                ) const;
  void residue_atom_pair_energy ( LiteResidue const & arg0 
                                , LiteResidue const & arg1
                                , EtableEnergy const & arg2
                                , EnergyMap & arg3        
                                ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////// rosetta::scoring::count_pair::CountPair3 ////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::count_pair{
class CountPair3 : ( inherits?? )
{
  bool                    count ( int const at1            
                                , int const at2           
                                , Real & w                
                                ) const;
  void residue_atom_pair_energy ( LiteResidue const & arg0 
                                , LiteResidue const & arg1
                                , EtableEnergy const & arg2
                                , EnergyMap & arg3        
                                ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////// rosetta::scoring::count_pair::CountPairDisulf //////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::count_pair{
class CountPairDisulf : ( inherits?? )
{
  bool                    count ( int const at1                     
                                , int const at2                    
                                , Real & w                         
                                ) const;
  void residue_atom_pair_energy ( LiteResidue const & res1          
                                , LiteResidue const & res2         
                                , EtableEnergy const & etable_energy
                                , EnergyMap & emap                 
                                ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////// rosetta::scoring::count_pair::CountPairFunction /////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::count_pair{
class CountPairFunction : ( inherits?? )
{
  bool                    count ( int const at1            
                                , int const at2           
                                , Real & arg2             
                                ) const;
  void residue_atom_pair_energy ( LiteResidue const & arg0 
                                , LiteResidue const & arg1
                                , EtableEnergy const & arg2
                                , EnergyMap & arg3        
                                ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
/////////////////////// rosetta::scoring::dunbrack::ChiSet ///////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::dunbrack{
class ChiSet : ( inherits?? )
{
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////// rosetta::scoring::dunbrack::DunbrackRotamer ///////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::dunbrack{
class DunbrackRotamer : ( inherits?? )
{
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////// rosetta::scoring::dunbrack::DunbrackRotamerSet /////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::dunbrack{
class DunbrackRotamerSet : ( inherits?? )
{
             size_t const         size (                       ) const;
  DunbrackRotamer const & find_rotamer ( RotVector const & rot ) const;
                     void    push_back ( DunbrackRotamerOP ptr );
}
}

//////////////////////////////////////////////////////////////////////////////////
/////////////////// rosetta::scoring::dunbrack::RotamerLibrary ///////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::dunbrack{
class RotamerLibrary : ( inherits?? )
{
  Real       rotamer_energy ( LiteResidue const & rsd                           ) const;
  Real rotamer_energy_deriv ( LiteResidue const & rsd                          
                            , vector1<double                                  
                            , allocator<double> > & dE_dbb                    
                            , vector1<double                                  
                            , allocator<double> > & dE_dchi                   
                            );
  void  fill_chi_set_vector ( Residue const & rsd                              
                            , Residue const & rsd_at_seqpos                   
                            , vector1<vector1<double                          
                            , allocator<double> >                             
                            ,allocator<vector1<double                         
                            , allocator<double> > > > const & extra_chi_steps 
                            , vector1<owning_ptr<ChiSet>                      
                            ,allocator<owning_ptr<ChiSet> > > & chi_set_vector
                            ) const;
  void  add_residue_library ( AA const & aa                                    
                            , SingleResidueRotamerLibraryOP rot_lib           
                            );
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////// rosetta::scoring::dunbrack::SingleResidueDunbrackLibrary ////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::dunbrack{
class SingleResidueDunbrackLibrary : ( inherits?? )
{
  Real rotamer_energy_deriv ( LiteResidue const & rsd                          
                            , vector1<double                                  
                            , allocator<double> > & dE_dbb                    
                            , vector1<double                                  
                            , allocator<double> > & dE_dchi                   
                            ) const;
  Real       rotamer_energy ( LiteResidue const & rsd                           ) const;
  void  fill_chi_set_vector ( Residue const & rsd                              
                            , Residue const & rsd_at_seqpos                   
                            , vector1<vector1<double                          
                            , allocator<double> >                             
                            ,allocator<vector1<double                         
                            , allocator<double> > > > const & extra_chi_steps 
                            , vector1<owning_ptr<ChiSet>                      
                            ,allocator<owning_ptr<ChiSet> > > & chi_set_vector
                            ) const;
  void         rot_from_chi ( LiteResidue const & rsd                          
                            , ChiVector const & chi                           
                            , RotVector & rot                                 
                            ) const;
  void              add_set ( size_t const phibin                              
                            , size_t const psibin                             
                            , DunbrackRotamerSetOP rot_set                    
                            );
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////// rosetta::scoring::dunbrack::SingleResidueRotamerLibrary /////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::dunbrack{
class SingleResidueRotamerLibrary : ( inherits?? )
{
  Real rotamer_energy_deriv ( LiteResidue const & rsd                          
                            , vector1<double                                  
                            , allocator<double> > & dE_dbb                    
                            , vector1<double                                  
                            , allocator<double> > & dE_dchi                   
                            ) const;
  Real       rotamer_energy ( LiteResidue const & rsd                           ) const;
  void  fill_chi_set_vector ( Residue const & rsd                              
                            , Residue const & rsd_at_seqpos                   
                            , vector1<vector1<double                          
                            , allocator<double> >                             
                            ,allocator<vector1<double                         
                            , allocator<double> > > > const & extra_chi_steps 
                            , vector1<owning_ptr<ChiSet>                      
                            ,allocator<owning_ptr<ChiSet> > > & chi_set_vector
                            ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
////////////////////////// rosetta::scoring::EMapVector //////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class EMapVector : ( inherits?? )
{
  Real  * begin (                        );
  Real  *   end (                        );
     void clear (                        );
     Real   dot ( EMapVector const & src ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
////////////////////////// rosetta::scoring::EnergyEdge //////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class EnergyEdge : ( inherits?? )
{
                    void                 copy_from ( Edge const * source );
            EnergyMap  &                energy_map (                     );
       EnergyMap const &                energy_map (                     ) const;
  CountPairFunctionOP  &       count_pair_function (                     );
    CountPairFunctionCOP       count_pair_function (                     ) const;
                    void    mark_energies_computed (                     );
                    void  mark_energies_uncomputed (                     );
                    bool energies_not_yet_computed (                     ) const;
            unsigned int       count_static_memory (                     ) const;
            unsigned int      count_dynamic_memory (                     ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////////////// rosetta::scoring::EnergyGraph //////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class EnergyGraph : ( inherits?? )
{
                bool        energy_exists ( ScoreType const & type ) const;
       EnergyEdge  *     find_energy_edge ( int n1                
                                          , int n2               
                                          );
  EnergyEdge const *     find_energy_edge ( int n1                
                                          , int n2               
                                          ) const;
        unsigned int  count_static_memory (                        ) const;
        unsigned int count_dynamic_memory (                        ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
////////////////////////// rosetta::scoring::EnergyNode //////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class EnergyNode : ( inherits?? )
{
          void            copy_from ( Node const * source );
          void                print (                     );
  unsigned int  count_static_memory (                     ) const;
  unsigned int count_dynamic_memory (                     ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////// rosetta::scoring::Etable ////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class Etable : ( inherits?? )
{
  FArray3D<double> const &                        ljatr (  ) const;
  FArray3D<double> const &                        ljrep (  ) const;
  FArray3D<double> const &                        solv1 (  ) const;
  FArray3D<double> const &                        solv2 (  ) const;
  FArray3D<double> const &                       dljatr (  ) const;
  FArray3D<double> const &                       dljrep (  ) const;
  FArray3D<double> const &                        dsolv (  ) const;
                      Real            get_safe_max_dis2 (  ) const;
                       int              get_bins_per_A2 (  ) const;
                AtomSetCOP                     atom_set (  ) const;
                      Real hydrogen_interaction_cutoff2 (  ) const;
                      Real        nblist_dis2_cutoff_XX (  ) const;
                      Real        nblist_dis2_cutoff_XH (  ) const;
                      Real        nblist_dis2_cutoff_HH (  ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::scoring::EtableOptions /////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class EtableOptions : ( inherits?? )
{
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////////// rosetta::scoring::hbonds::FadeInterval /////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::hbonds{
class FadeInterval : ( inherits?? )
{
  double       value ( Real const x   ) const;
    void value_deriv ( Real const x  
                     , double & val 
                     , double & deriv
                     ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::scoring::hbonds::HBond /////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::hbonds{
class HBond : ( inherits?? )
{
                                                 int                      don_res (                     ) const;
                                                 int                     don_hatm (                     ) const;
                                                 int don_hatm_is_protein_backbone (                     ) const;
                                                 int                      acc_res (                     ) const;
                                                 int                      acc_atm (                     ) const;
                                                 int  acc_atm_is_protein_backbone (                     ) const;
                                                Real                       energy (                     ) const;
                                                Real                       weight (                     ) const;
  pair<xyzVector<double>,xyzVector<double> > const &                        deriv (                     ) const;
                                  HBEvalType const &                    eval_type (                     ) const;
                                                bool               atom_is_donorH ( AtomID const & atom ) const;
                                                bool             atom_is_acceptor ( AtomID const & atom ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
/////////////////////// rosetta::scoring::hbonds::HBondSet ///////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::hbonds{
class HBondSet : ( inherits?? )
{
                                            int                         nhbonds (                                   ) const;
                                  HBond const &                           hbond ( int const number                  ) const;
                                           void                    append_hbond ( int const dhatm                  
                                                                                , LiteResidue const & don_rsd     
                                                                                , int const aatm                  
                                                                                , LiteResidue const & acc_rsd     
                                                                                , HBEvalType const & hbe_type     
                                                                                , Real const energy               
                                                                                , Real const weight               
                                                                                , pair<xyzVector<double>          
                                                                                , xyzVector<double> > const & deriv
                                                                                );
                                           bool                     allow_hbond ( int const index                   ) const;
                                           bool                     allow_hbond ( HBond const & hbond               ) const;
                                           bool          acc_bbg_in_bb_bb_hbond ( int residue                       ) const;
                                           bool          don_bbg_in_bb_bb_hbond ( int residue                       ) const;
                                           void                  setup_atom_map (                                   ) const;
  vector1<HBond const*,<HBond const*> > const &                     atom_hbonds ( AtomID const & atom               ) const;
                                           void                           clear (                                   );
                                           void      get_residue_residue_energy ( LiteResidue const & rsd1         
                                                                                , LiteResidue const & rsd2        
                                                                                , Real & scE                      
                                                                                , Real & bb_scE                   
                                                                                ) const;
                                           void setup_for_residue_pair_energies ( Pose const & pose                 );
}
}

//////////////////////////////////////////////////////////////////////////////////
/////////////////////// rosetta::scoring::KnowledgeManager ///////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class KnowledgeManager : ( inherits?? )
{
  static KnowledgeManager  *       get_instance (  );
      PairEPotential const & get_PairEPotential (  ) const;
      RotamerLibrary const & get_RotamerLibrary (  ) const;
        Ramachandran const &   get_Ramachandran (  ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////// rosetta::scoring::methods::ContextDependentTwoBodyEnergy ////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class ContextDependentTwoBodyEnergy : ( inherits?? )
{
  EnergyMethodType         method_type (                            ) const;
              void residue_pair_energy ( LiteResidue const & rsd1  
                                       , LiteResidue const & rsd2 
                                       , Pose const & pose        
                                       , Energies const & energies
                                       , CountPairFunctionCOP cpfxn
                                       , bool const use_nblist    
                                       , EnergyMap & emap         
                                       ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
/////////// rosetta::scoring::methods::ContextIndependentOneBodyEnergy ///////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class ContextIndependentOneBodyEnergy : ( inherits?? )
{
  EnergyMethodType    method_type (                         ) const;
              void residue_energy ( LiteResidue const & rsd
                                  , EnergyMap & emap      
                                  ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
/////////// rosetta::scoring::methods::ContextIndependentTwoBodyEnergy ///////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class ContextIndependentTwoBodyEnergy : ( inherits?? )
{
  EnergyMethodType         method_type (                            ) const;
              void residue_pair_energy ( LiteResidue const & rsd1  
                                       , LiteResidue const & rsd2 
                                       , CountPairFunctionCOP cpfxn
                                       , bool const use_nblist    
                                       , EnergyMap & emap         
                                       ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////// rosetta::scoring::methods::EnergyMethod /////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class EnergyMethod : ( inherits?? )
{
                void     setup_for_packing ( Pose & arg0               ) const;
                void     setup_for_scoring ( Pose & arg0               ) const;
                void  setup_for_minimizing ( Pose & arg0              
                                           , MinimizerMap const & arg1
                                           , bool const arg2         
                                           ) const;
                void setup_for_derivatives ( Pose & arg0               ) const;
                void  eval_atom_derivative ( AtomID const & arg0      
                                           , Pose const & arg1       
                                           , Energies const & arg2   
                                           , EnergyMap const & arg3  
                                           , bool const arg4         
                                           , Vector & arg5           
                                           , Vector & arg6           
                                           ) const;
                Real   eval_dof_derivative ( DOF_ID const & arg0      
                                           , TorsionID const & arg1  
                                           , Pose const & arg2       
                                           , Energies const & arg3   
                                           , EnergyMap const & arg4  
                                           ) const;
                void finalize_total_energy ( Pose const & arg0        
                                           , EnergyMap & arg1        
                                           ) const;
  ScoreTypes const &           score_types (                           ) const;
    EnergyMethodType           method_type (                           ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////// rosetta::scoring::methods::EnergyMethodManager /////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class EnergyMethodManager : ( inherits?? )
{
  static EnergyMethodManager  * get_instance (                                     );
                 EnergyMethodOP       method ( ScoreType const & t                
                                             , EnergyMethodOptions const & options
                                             ) const;
                           void   add_etable ( string const & name                
                                             , EtableOP etable                   
                                             );
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////// rosetta::scoring::methods::EnergyMethodOptions /////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class EnergyMethodOptions : ( inherits?? )
{
  string const & etable_type (                     ) const;
            void etable_type ( string const & type );
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////// rosetta::scoring::methods::EtableEnergy /////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class EtableEnergy : ( inherits?? )
{
  void         setup_for_minimizing ( Pose & pose                 
                                    , MinimizerMap const & min_map
                                    , bool const use_nblist      
                                    ) const;
  void          residue_pair_energy ( LiteResidue const & rsd1    
                                    , LiteResidue const & rsd2   
                                    , CountPairFunctionCOP cpfxn 
                                    , bool const use_nblist      
                                    , EnergyMap & emap           
                                    ) const;
  void        finalize_total_energy ( Pose const & pose           
                                    , EnergyMap & totals         
                                    ) const;
  void         eval_atom_derivative ( AtomID const & id           
                                    , Pose const & pose          
                                    , Energies const & energies  
                                    , EnergyMap const & weights  
                                    , bool const use_nblist      
                                    , Vector & F1                
                                    , Vector & F2                
                                    ) const;
  void             atom_pair_energy ( Atom const & atom1          
                                    , Atom const & atom2         
                                    , Real const weight          
                                    , EnergyMap & emap           
                                    , Real & d2                  
                                    ) const;
  Real                pair_energy_H ( Atom const & atom1          
                                    , Atom const & atom2         
                                    ) const;
  Real            eval_dE_dR_over_r ( Atom const & atom1          
                                    , Atom const & atom2         
                                    , EnergyMap const & weights  
                                    , Vector & f1                
                                    , Vector & f2                
                                    ) const;
  Real hydrogen_interaction_cutoff2 (                              ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////////// rosetta::scoring::methods::HBondEnergy /////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class HBondEnergy : ( inherits?? )
{
  void     setup_for_packing ( Pose & pose               ) const;
  void     setup_for_scoring ( Pose & pose               ) const;
  void setup_for_derivatives ( Pose & pose               ) const;
  void   residue_pair_energy ( LiteResidue const & rsd1 
                             , LiteResidue const & rsd2
                             , Pose const & arg2       
                             , Energies const & energies
                             , CountPairFunctionCOP arg4
                             , bool const arg5         
                             , EnergyMap & emap        
                             ) const;
  void finalize_total_energy ( Pose const & pose        
                             , EnergyMap & totals      
                             );
  void   get_atom_derivative ( AtomID const & atom_id   
                             , Pose const & pose       
                             , EnergyMap const & weights
                             , Vector & f1             
                             , Vector & f2             
                             );
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////////// rosetta::scoring::methods::PairEnergy //////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class PairEnergy : ( inherits?? )
{
  void     setup_for_packing ( Pose & pose               ) const;
  void     setup_for_scoring ( Pose & pose               ) const;
  void setup_for_derivatives ( Pose & pose               ) const;
  void   residue_pair_energy ( LiteResidue const & rsd1 
                             , LiteResidue const & rsd2
                             , Pose const & arg2       
                             , Energies const & energies
                             , CountPairFunctionCOP arg4
                             , bool const arg5         
                             , EnergyMap & emap        
                             ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
////////////////// rosetta::scoring::methods::RamachandranEnergy //////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring::methods{
class RamachandranEnergy : ( inherits?? )
{
  void      residue_energy ( LiteResidue const & rsd  
                           , EnergyMap & emap        
                           ) const;
  Real eval_dof_derivative ( DOF_ID const & arg0      
                           , TorsionID const & tor_id
                           , Pose const & pose       
                           , Energies const & arg3   
                           , EnergyMap const & weights
                           ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::scoring::NeighborList /////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class NeighborList : ( inherits?? )
{
  AtomNeighbors const &   atom_neighbors ( int const pos                   
                                         , int const atomno               
                                         ) const;
  AtomNeighbors const &   atom_neighbors ( AtomID const & id                ) const;
                   void            setup ( Pose const & pose               
                                         , EnergyGraph const & energy_graph
                                         , DomainMap const & domain_map   
                                         , Real const XX_cutoff           
                                         , Real const XH_cutoff           
                                         , Real const HH_cutoff           
                                         );
                   void check_domain_map ( DomainMap const & domain_map_in  );
                   void            clear (                                  );
}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////// rosetta::scoring::PairEPotential ////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class PairEPotential : ( inherits?? )
{
  Energy           pair_term_energy ( LiteResidue const & res1    
                                    , int res1_num_10A_neighbors 
                                    , LiteResidue const & res2   
                                    , int res1_num_10A_neighbors 
                                    ) const;
  Energy pair_term_energy_and_deriv ( LiteResidue const & res1    
                                    , int res1_num_10A_neighbors 
                                    , LiteResidue const & res2   
                                    , int res1_num_10A_neighbors 
                                    , EnergyDerivative & dpairE_dr
                                    ) const;
}
}

//////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::scoring::Ramachandran /////////////////////////
//////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class Ramachandran : ( inherits?? )
{
  void          eval_rama_score_all ( Pose & pose                   
                                    , ScoreFunction const & scorefxn
                                    ) const;
  void         write_rama_score_all ( Pose const & pose              ) const;
  void      eval_rama_score_residue ( LiteResidue const & res       
                                    , Real & rama                  
                                    , Real & drama_dphi            
                                    , Real & drama_dpsi            
                                    ) const;
  Real get_rama_score_residue_deriv ( int res                       
                                    , Pose const & a_pose          
                                    , ProteinTorsion torsion       
                                    ) const;
  void           eval_procheck_rama ( Pose const & a_pose           
                                    , Real & favorable             
                                    , Real & allowed               
                                    , Real & generous              
                                    ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////// rosetta::scoring::ScoreFunction /////////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class ScoreFunction : ( inherits?? )
{
               void                     set_etable ( string const & etable_name   );
  ScoreFunctionInfo                           info (                              ) const;
  EnergyMap const &                        weights (                              ) const;
               bool                has_zero_weight ( ScoreType const & t          ) const;
               bool             has_nonzero_weight ( ScoreType const & t          ) const;
               void                     set_weight ( ScoreType const & t         
                                                   , Real const & setting       
                                                   );
               void           setup_for_minimizing ( Pose & pose                 
                                                   , MinimizerMap const & min_map
                                                   , bool const use_nblist      
                                                   ) const;
               void              setup_for_packing ( Pose & pose                  ) const;
               void              setup_for_scoring ( Pose & pose                  ) const;
               void          setup_for_derivatives ( Pose & pose                  ) const;
               void eval_twobody_neighbor_energies ( Pose & pose                  ) const;
               void          eval_onebody_energies ( Pose & pose                  ) const;
               void                     eval_ci_1b ( LiteResidue const & rsd     
                                                   , EnergyMap & emap           
                                                   ) const;
               void                     eval_ci_2b ( LiteResidue const & rsd1    
                                                   , LiteResidue const & rsd2   
                                                   , CountPairFunctionCOP cpfxn 
                                                   , bool const use_nblist      
                                                   , EnergyMap & emap           
                                                   ) const;
               void                     eval_cd_2b ( LiteResidue const & rsd1    
                                                   , LiteResidue const & rsd2   
                                                   , Pose const & pose          
                                                   , Energies const & energies  
                                                   , CountPairFunctionCOP cpfxn 
                                                   , bool const use_nblist      
                                                   , EnergyMap & emap           
                                                   ) const;
               void           eval_atom_derivative ( AtomID const & atom_id      
                                                   , Pose const & pose          
                                                   , Vector & F1                
                                                   , Vector & F2                
                                                   ) const;
               Real            eval_dof_derivative ( DOF_ID const & dof_id       
                                                   , TorsionID const & torsion_id
                                                   , Pose const & pose          
                                                   ) const;
               void                  zero_energies ( EnergyMethodType const & t  
                                                   , EnergyMap & emap           
                                                   ) const;
}
}

///////////////////////////////////////////////////////////////////////////////////
/////////////////////// rosetta::scoring::ScoreFunctionInfo ///////////////////////
///////////////////////////////////////////////////////////////////////////////////
namespace rosetta::scoring{
class ScoreFunctionInfo : ( inherits?? )
{
}
}

