/opt/conda/conda-bld/coot-headless_1778826286086/work/api/molecules-container.hh

 
#ifndef MOLECULES_CONTAINER_HH
#define MOLECULES_CONTAINER_HH
 
#include <memory>
#ifdef SWIG
#include "Python.h"
#endif
 
#include <vector>
 
#ifdef HAVE_SSMLIB
#include <ssm/ssm_align.h>
#endif
 
#if NB_VERSION_MAJOR // for flychecking
#include <nanobind/nanobind.h>
#endif
 
#include "compat/coot-sysdep.h"
 
#include "coords/Cartesian.hh"
#include "coords/ramachandran-container.hh"
#include "coot-molecule.hh"
#include "coot-utils/coot-rama.hh"
#include "coot-utils/coot-coord-extras.hh" // the missing atoms type
#include "coot-utils/coot-map-utils.hh"
#include "utils/coot-utils.hh"
#include "utils/setup-syminfo.hh"
#include "ideal/simple-restraint.hh" // needed?
#include "atom-pull.hh"
#include "validation-information.hh"
#include "superpose-results.hh"
#include "lsq-results.hh"
#include "coot-utils/simple-mesh.hh"
#include "coot-utils/texture-as-floats.hh"
#include "phi-psi-prob.hh"
#include "instancing.hh"
#include "coot-colour.hh" // put this in utils
#include "ligand/molecular-replacement.hh"  // coot::mr_solution_t, glm/gtc/quaternion.hpp
#include "saved-strand-info.hh"
#include "svg-store-key.hh"
#include "moorhen-h-bonds.hh"
#include "header-info.hh"
#include "positioned-atom-spec.hh"
#include "user-defined-colour-table.hh"

class molecules_container_t {
 
   std::vector<coot::molecule_t> molecules;
   coot::protein_geometry geom;
   coot::rotamer_probability_tables rot_prob_tables;
   bool ospray_is_initialized;
   ramachandrans_container_t ramachandrans_container;
   static std::atomic<bool> on_going_updating_map_lock;
   bool draw_missing_residue_loops_flag;
 
   class rail_points_t {
   public:
      int model_rail_points_delta; // for the latest change, I mean
      int   map_rail_points_delta;
      float rmsd_of_difference_map;
      explicit rail_points_t(float rmsd) {
         model_rail_points_delta = 0;
         map_rail_points_delta = 0;
         rmsd_of_difference_map = rmsd;
      }
      rail_points_t(float rmsd_diff_map_current, const rail_points_t &rail_points_prev) {
         model_rail_points_delta = 0;
         rmsd_of_difference_map = rmsd_diff_map_current;
         map_rail_points_delta = rail_points_delta(rail_points_prev);
      }
      int rail_points_delta(const rail_points_t &prev) {
         float fudge = 2.4; // 20230117-PE makes 1000 rail points equal ~1% in R-factor for the tutorial data
         return int(100000.0 * fudge * (prev.rmsd_of_difference_map - rmsd_of_difference_map));
      }
      static int total(const std::vector<rail_points_t> &rail_point_history) {
         int sum = 0;
         for (const auto &item : rail_point_history) {
            sum += item.map_rail_points_delta;
         }
         return sum;
      }
   };
   std::vector<rail_points_t> rail_point_history; // map and model (model currently not used)
 
   class updating_maps_info_f {
   public:
      bool maps_need_an_update;
      int imol_model;
      int imol_2fofc;
      int imol_fofc;
      int imol_with_data_info_attached;
      updating_maps_info_f() {
         maps_need_an_update = false;
         imol_model = -1;
         imol_2fofc = -1;
         imol_fofc = -1;
         imol_with_data_info_attached = -1;
      }
   };
#ifdef SKIP_FOR_PYTHON_DOXYGEN
#else
   updating_maps_info_f updating_maps_info;
   void set_updating_maps_need_an_update(int imol);
                                                    // Checks the above information before acting, of course.
                                                    // No action if imol is the the model for updating maps.

   void update_updating_maps(int imol); // called from the get_map_contours_mesh() function
 
   coot::util::sfcalc_genmap_stats_t latest_sfcalc_stats;
#endif
   // --------------------- superposition --------------------------
 
   // --------------------- refinement --------------------------
 
   // 201803004:
   // refinement now uses references to Xmaps.
   // A dummy_map is created and a reference to that is created. Then
   // the reference is reset to a real xmap in a molecule (imol_for_map).
   // But, for a reason I don't understand, the refinement crashes when I do that.
   // When the initial dummy_xmap doesn't go out of scope, then the refinement is OK.
   // So this static dummy map is the map that doesn't go out of scope.
   // We only need one of it, so it goes here, rather than get created every
   // time we do a refinement. It may need to be public in future.
   //
   // 20221018-PE:
   // Now that we are in api, then I am now no longer sure that this should be static
   // or what static means in WebAssembly.
   static clipper::Xmap<float> *dummy_xmap;
   float map_weight;
   float geman_mcclure_alpha;
 
   bool use_rama_plot_restraints;
   float rama_plot_restraints_weight;
 
   bool use_torsion_restraints;
   float torsion_restraints_weight;
 
   ctpl::thread_pool thread_pool;
   bool show_timings;
 
   coot::restraints_container_t *last_restraints;
   bool continue_threaded_refinement_loop;
   bool refinement_is_quiet;
   int cif_dictionary_read_number;

   std::string adjust_refinement_residue_name(const std::string &resname) const;
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   bool make_last_restraints(const std::vector<std::pair<bool,mmdb::Residue *> > &local_residues,
                 const std::vector<mmdb::Link> &links,
                 const coot::protein_geometry &geom,
                 mmdb::Manager *mol_for_residue_selection,
                 const std::vector<coot::atom_spec_t> &fixed_atom_specs,
                 coot::restraint_usage_Flags flags,
                 bool use_map_flag,
                 const clipper::Xmap<float> *xmap_p);
   coot::refinement_results_t refine_residues_vec(int imol,
                                                  const std::vector<mmdb::Residue *> &residues,
                                                  const std::string &alt_conf,
                                                  mmdb::Manager *mol);
 
   atom_selection_container_t make_moving_atoms_asc(mmdb::Manager *residues_mol,
                                                    const std::vector<mmdb::Residue *> &residues) const;
 
   int find_serial_number_for_insert(int seqnum_new,
                                     const std::string &ins_code_for_new,
                                     mmdb::Chain *chain_p) const;
 
   // return 0 if any of the residues in selection don't have (at least) bond
   // restraints.  Try to auto-load the dictionary cifs and try again.
   // The vector is a list of residues for which no restraints could be found.
 
   std::pair<int, std::vector<std::string> >
     check_dictionary_for_residue_restraints(int imol, mmdb::PResidue *SelResidues, int nSelResidues);
 
   std::pair<int, std::vector<std::string> >
     check_dictionary_for_residue_restraints(int imol, const std::vector<mmdb::Residue *> &residues);
 
   std::pair<mmdb::Manager *, std::vector<mmdb::Residue *> >
   create_mmdbmanager_from_res_vector(const std::vector<mmdb::Residue *> &residues,
                                      int imol,
                                      mmdb::Manager *mol_in,
                                      std::string alt_conf);
 
   // simple mmdb::Residue * interface to refinement.  20081216
   coot::refinement_results_t
   generate_molecule_and_refine(int imol,  // needed for UDD Atom handle transfer
                                const std::vector<mmdb::Residue *> &residues,
                                const std::string &alt_conf,
                                mmdb::Manager *mol,
                                bool use_map_flag=true);
 
   static void thread_for_refinement_loop_threaded();
 
   static std::atomic<bool> restraints_lock;
   static void get_restraints_lock(const std::string &calling_function_name);
   static void release_restraints_lock(const std::string &calling_function_name);
   static std::string restraints_locking_function_name; //  static because it is set by above
 
   bool particles_have_been_shown_already_for_this_round_flag;
 
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   int servalcat_refine_xray_internal(int imol, int imol_map, const std::string &output_prefix,
                                      const std::map<std::string, std::string> &key_value_pairs);
#endif
 
 
#ifdef SKIP_FOR_PYTHON_DOXYGEN
#else
   std::pair<short int, clipper::RTop_orth> get_lsq_matrix_internal(int imol_ref, int imol_mov, bool summary_to_screen) const;
#endif
 
   coot::validation_information_t
   get_q_score_validation_information(mmdb::Manager *mol, int udd_q_score, bool do_per_atom) const;
 
#endif
 
 
   bool refinement_immediate_replacement_flag = true;
   int imol_moving_atoms;
   enum moving_atoms_asc_t {
      NEW_COORDS_UNSET = 0,       // moving_atoms_asc_type values
      NEW_COORDS_ADD = 1,                 // not used?
      NEW_COORDS_REPLACE = 2,
      NEW_COORDS_REPLACE_CHANGE_ALTCONF = 3,
      NEW_COORDS_INSERT = 4,
      NEW_COORDS_INSERT_CHANGE_ALTCONF = 5};
   short int moving_atoms_asc_type;
 
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   static void all_atom_pulls_off();
   static std::vector<atom_pull_info_t> atom_pulls;
   // nanobinds doesn't have a atom_spec_t, does it?
   static void atom_pull_off(const coot::atom_spec_t &spec);
   static void atom_pulls_off(const std::vector<coot::atom_spec_t> &specs);
#endif
 
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   std::vector<std::pair<mmdb::Residue *, std::vector<coot::dict_torsion_restraint_t> > > make_rotamer_torsions(const std::vector<std::pair<bool, mmdb::Residue *> > &local_residues) const;
#endif

 
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   int refine_direct(int imol, std::vector<mmdb::Residue *> rv, const std::string &alt_loc, int n_cycles);

   double phi_psi_probability(const coot::util::phi_psi_t &phi_psi, const ramachandrans_container_t &rc) const;
#endif
 
#ifdef SKIP_FOR_PYTHON_DOXYGEN
#else
   void read_standard_residues();
 
   std::map<svg_store_key_t, std::string> ligand_svg_store;
 
   atom_selection_container_t standard_residues_asc;
#endif
 
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
 
   coot::graph_match_info_t overlap_ligands_internal(int imol_ligand, int imol_ref, const std::string &chain_id_ref,
                                                     int resno_ref, bool apply_rtop_flag);
 
   int install_model(const coot::molecule_t &m);
 
   superpose_results_t
   superpose_with_atom_selection(atom_selection_container_t asc_ref,
                                 atom_selection_container_t asc_mov,
                                 int imol_mov,
                                 std::string moving_mol_name,
                                 std::string reference_mol_name,
                                 bool move_copy_of_imol2_flag);
#endif
 
#ifdef HAVE_SSMLIB
 
   void print_ssm_sequence_alignment(ssm::Align *SSMAlign,
                     atom_selection_container_t asc_ref,
                     atom_selection_container_t asc_mov,
                     mmdb::PAtom *atom_selection1,
                     mmdb::PAtom *atom_selection2,
                     int n_selected_atoms_1, int n_selected_atoms_2,
                     bool move_copy_of_imol2_flag);
 
   coot::validation_information_t
   make_ssm_sequence_alignment_as_validation_information(ssm::Align *SSMAlign,
                                                    atom_selection_container_t asc_ref,
                                                    atom_selection_container_t asc_mov,
                                                    mmdb::PAtom *atom_selection1, mmdb::PAtom *atom_selection2,
                                                    int n_selected_atoms_1, int n_selected_atoms_2,
                                                    bool move_copy_of_imol2_flag);
 
   void make_and_print_horizontal_ssm_sequence_alignment(ssm::Align *SSMAlign,
                             atom_selection_container_t asc_ref,
                             atom_selection_container_t asc_mov,
                             mmdb::PAtom *atom_selection1,
                             mmdb::PAtom *atom_selection2,
                             int n_selected_atoms_1, int n_selected_atoms_2) const;
 
   void map_secondary_structure_headers(ssm::Align *SSMAlign,
                    atom_selection_container_t asc_ref,
                    atom_selection_container_t asc_mov,
                    mmdb::PAtom *atom_selection1,
                    mmdb::PAtom *atom_selection2,
                    int n_selected_atoms_1, int n_selected_atoms_2) const;
 
   std::pair<std::string, std::string>
      get_horizontal_ssm_sequence_alignment(ssm::Align *SSMAlign,
                       atom_selection_container_t asc_ref,
                       atom_selection_container_t asc_mov,
                       mmdb::PAtom *atom_selection1, mmdb::PAtom *atom_selection2,
                       int n_selected_atoms_1, int n_selected_atoms_2) const;
 
   // for gesampt this will be vector of vector
   std::vector<std::pair<coot::residue_validation_information_t, coot::residue_validation_information_t> >
   get_pairs(ssm::Align *SSMAlign,
             atom_selection_container_t asc_ref,
             atom_selection_container_t asc_mov,
             mmdb::PAtom *atom_selection1, mmdb::PAtom *atom_selection2,
             int n_selected_atoms_1, int n_selected_atoms_2) const;
 
 
   void print_horizontal_ssm_sequence_alignment(std::pair<std::string, std::string> aligned_sequences) const;
 
   std::string generate_horizontal_ssm_sequence_alignment_string(const std::pair<std::string, std::string> &aligned_sequences) const;
 
#endif  // HAVE_SSMLIB
 
#ifdef SKIP_FOR_PYTHON_DOXYGEN
#else
   int valid_labels(const std::string &mtz_file_name, const std::string &f_col, const std::string &phi_col,
                    const std::string &weight_col, int use_weights) const;
 
   // water fitting settings
   float ligand_water_to_protein_distance_lim_max;
   float ligand_water_to_protein_distance_lim_min;
   float ligand_water_variance_limit;
   float ligand_water_sigma_cut_off;
#endif
 
   unsigned int max_number_of_simple_mesh_vertices;
 
   // --------------------- init --------------------------
#ifdef SKIP_FOR_PYTHON_DOXYGEN
#else
   void init(); // private
#endif
 
#ifdef SKIP_FOR_PYTHON_DOXYGEN
#else
   void debug() const;
 
   bool map_is_contoured_using_thread_pool_flag;
   double contouring_time;
#endif
 
public:

   explicit molecules_container_t(bool verbose=true);
 
   ~molecules_container_t();

   int imol_refinement_map; // direct access
   int imol_difference_map; // direct access
 
   bool use_gemmi; // for mmcif and PDB parsing. 20240112-PE set to true by default in init()
 
   // -------------------------------- Basic Utilities -----------------------------------

   std::string package_version() const;

   void set_use_gemmi(bool state) { use_gemmi = state; }

   bool get_use_gemmi() { return use_gemmi; }
 

   void set_make_backups(bool state) { make_backups_flag = state; }

   bool get_make_backups() const { return make_backups_flag; }

   bool make_backups_flag;

   std::string file_name_to_string(const std::string &file_name) const;

   unsigned int get_number_of_molecules() const { return molecules.size(); }

   void create_empty_molecules(unsigned int n_empty);

   void set_imol_refinement_map(int i) { imol_refinement_map = i; }

   void set_map_weight(float w) { map_weight = w; }

   float get_map_weight() const { return map_weight; }

   void scale_map(int imol_map, float scale_factor);

   coot::atom_spec_t atom_cid_to_atom_spec(int imol, const std::string &cid) const;

   coot::residue_spec_t residue_cid_to_residue_spec(int imol, const std::string &cid) const;

   void set_show_timings(bool s) { show_timings = s; }
 
   // duplicate?
   // coot::protein_geometry & get_geom() { return geom; }

   moorhen::header_info_t get_header_info(int imol) const;

   int get_imol_enc_any() const;
 
   // -------------------------------- generic utils -----------------------------------

   std::string get_molecule_name(int imol) const;

   void set_molecule_name(int imol, const std::string &new_name);

   void display_molecule_names_table() const;

   bool is_valid_model_molecule(int imol) const;

   bool is_valid_map_molecule(int imol_map) const;

   bool is_a_difference_map(int imol_map) const;

   int new_molecule(const std::string &name);

   int close_molecule(int imol);

   void end_delete_closed_molecules();

   void pop_back();

   void clear();

   std::vector<double> get_eigenvalues(int imol, const std::string &chain_id, int res_no, const std::string &ins_code);

   std::string get_eigenvectors_and_eigenvalues(int imol, const std::string &cid);

   coot::simple_mesh_t test_origin_cube() const;
 
#ifdef SWIG
#else
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   coot::molecule_t & operator[] (unsigned int imol);
#endif
#endif
 
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   mmdb::Manager *get_mol(unsigned int imol) const;
#endif
 
// we don't want this in the nanobinds
#ifdef NB_VERSION_MAJOR
#else
   // no protection, for testing only
   clipper::Xmap<float> get_xmap(int imol) const;
#endif

   void fill_rotamer_probability_tables();

   void accept_rotamer_probability_tables_compressed_data(const std::string &data_stream);
 
   // -------------------------------- backup and saving -----------------------------------

   bool contains_unsaved_models() const;

   void save_unsaved_model_changes();
 
   // -------------------------------- geometry/dictionaries --------------------------------

   void geometry_init_standard();

   std::vector<std::string> non_standard_residue_types_in_model(int imol) const;
 
#ifdef MAKE_ENHANCED_LIGAND_TOOLS
   // RDKit::RWMol get_rdkit_mol(const std::string &residue_name, int imol_enc);
 
   // std::shared_ptr<RDKit::RWMol> get_rdkit_mol_shared(const std::string &residue_name, int imol_enc);

   std::string get_rdkit_mol_pickle_base64(const std::string &residue_name, int imol_enc);
#endif
 
   // -------------------------------- coordinates utils -----------------------------------

   int read_coordinates(const std::string &file_name);

   int read_pdb(const std::string &file_name);

   int read_small_molecule_cif(const std::string &file_name);

   int read_amber_trajectory(int imol_coords,
                             const std::string &trajectory_file_name,
                             int start_frame,
                             int end_frame,
                             int stride);

   void print_secondary_structure_info(int imol) const;

   void replace_molecule_by_model_from_file(int imol, const std::string &pdb_file_name);

   std::vector<int> split_multi_model_molecule(int imol);

   int make_ensemble(const std::string &model_molecules_list);

   std::string molecule_to_PDB_string(int imol) const;

   std::string molecule_to_mmCIF_string(int imol) const;

   std::pair<int, std::string> get_active_atom(float x, float y, float z, const std::string &displayed_model_molecules_list) const;

   int import_cif_dictionary(const std::string &cif_file_name, int imol_enc);

   std::string get_cif_file_name(const std::string &comp_id, int imol_enc) const;

   std::string get_cif_restraints_as_string(const std::string &comp_id, int imol_enc) const;

   bool copy_dictionary(const std::string &monomer_name, int imol_current, int imol_new);

   int get_monomer(const std::string &monomer_name);

   int get_monomer_from_dictionary(const std::string &comp_id, int imol, bool idealised_flag);

   int get_monomer_and_position_at(const std::string &comp_id, int imol, float x, float y, float z);

   std::map<std::string, std::string>
   dictionary_atom_name_map(const std::string &comp_id_1, int imol_1, const std::string &comp_id_2, int imol_2);

   std::vector<std::string> get_types_in_molecule(int imol) const;
 
   // 20221030-PE nice to have one day:
   // int get_monomer_molecule_by_network_and_dict_gen(const std::string &text);

   std::vector<std::string> get_groups_for_monomers(const std::vector<std::string> &residue_names) const;

   std::string get_group_for_monomer(const std::string &residue_name) const;

   std::string get_hb_type(const std::string &compound_id, int imol_enc, const std::string &atom_name) const;

   std::vector<std::pair<std::string, std::string> > get_gphl_chem_comp_info(const std::string &compound_id, int imol_enc);

   std::vector<std::pair<std::string, std::string> > get_acedrg_atom_types(const std::string &compound_id, int imol_enc) const;

   std::vector<std::pair<std::string, std::string> > get_computed_acedrg_atom_types(const std::string &compound_id, int imol_enc);

   coot::acedrg_types_for_residue_t get_acedrg_atom_types_for_ligand(int imol, const std::string &residue_cid) const;

   void set_occupancy(int imol, const std::string &cid, float occ_new);

   std::string get_molecule_selection_as_json(int imol, const std::string &cid) const;

   std::string get_torsions_for_residues_in_chain(int imol, const std::string &chain_id) const;

   void write_png(const std::string &compound_id, int imol, const std::string &file_name) const;

   int write_coordinates(int imol, const std::string &file_name) const;

   void set_draw_missing_residue_loops(bool state);

   coot::simple_mesh_t get_bonds_mesh(int imol, const std::string &mode,
                                      bool against_a_dark_background,
                                      float bond_width, float atom_radius_to_bond_width_ratio,
                                      int smoothness_factor);

   coot::instanced_mesh_t get_bonds_mesh_instanced(int imol, const std::string &mode,
                                                   bool against_a_dark_background,
                                                   float bond_width, float atom_radius_to_bond_width_ratio,
                                                   bool show_atoms_as_aniso_flag,
                                                   bool show_aniso_atoms_as_ortep_flag,
                                                   bool show_aniso_atoms_as_empty,
                                                   bool draw_hydrogen_atoms_flag,
                                                   int smoothness_factor);

   coot::instanced_mesh_t get_bonds_mesh_for_selection_instanced(int imol, const std::string &atom_selection_cid,
                                                                 const std::string &mode,
                                                                 bool against_a_dark_background,
                                                                 float bond_width, float atom_radius_to_bond_width_ratio,
                                                                 bool show_atoms_as_aniso_flag,
                                                                 bool show_aniso_atoms_as_ortep_flag,
                                                                 bool show_aniso_atoms_as_empty_flag,
                                                                 bool draw_hydrogen_atoms_flag,
                                                                 int smoothness_factor);

   coot::instanced_mesh_t get_goodsell_style_mesh_instanced(int imol, float colour_wheel_rotation_step,
                                                            float saturation, float goodselliness);

   void export_map_molecule_as_gltf(int imol, float pos_x, float pos_y, float pos_z, float radius, float contour_level,
                                    const std::string &file_name);

   void export_model_molecule_as_gltf(int imol,
                                      const std::string &selection_cid,
                                      const std::string &mode,
                                      bool against_a_dark_background,
                                      float bonds_width, float atom_radius_to_bond_width_ratio, int smoothness_factor,
                                      bool draw_hydrogen_atoms_flag, bool draw_missing_residue_loops,
                                      const std::string &file_name);

   void export_molecular_representation_as_gltf(int imol, const std::string &atom_selection_cid,
                                               const std::string &colour_scheme, const std::string &style,
                                               int secondary_structure_usage_flag,
                                               const std::string &file_name);

   void export_chemical_features_as_gltf(int imol, const std::string &cid,
                                         const std::string &file_name) const;

   void set_gltf_pbr_roughness_factor(int imol, float roughness_factor);

   void set_gltf_pbr_metalicity_factor(int imol, float metalicity);

   void ray_trace_init();

   void ray_trace_shutdown();

   void ray_trace_image(const std::string &json_str);

   std::vector<glm::vec4> get_colour_table(int imol, bool against_a_dark_background) const;

   void set_colour_wheel_rotation_base(int imol, float r);

   void set_base_colour_for_bonds(int imol, float r, float g, float b);

   void add_to_non_drawn_bonds(int imol, const std::string &atom_selection_cid);

   void clear_non_drawn_bonds(int imol);

   void print_non_drawn_bonds(int imol) const;

   void set_user_defined_bond_colours(int imol, const std::map<unsigned int, std::array<float, 4> > &colour_map);

   void set_user_defined_atom_colour_by_selection(int imol, const std::vector<std::pair<std::string, unsigned int> > &indexed_residues_cids,
                                                  bool colour_applies_to_non_carbon_atoms_also);

   void add_colour_rule(int imol, const std::string &selection_cid, const std::string &colour);

   void add_colour_rules_multi(int imol, const std::string &selections_and_colours_combo_string);

   void delete_colour_rules(int imol);

   std::vector<std::pair<std::string, std::string> > get_colour_rules(int imol) const;

   void print_colour_rules(int imol) const;

   void set_use_bespoke_carbon_atom_colour(int imol, bool state);

   void set_bespoke_carbon_atom_colour(int imol, const coot::colour_t &col);

   void M2T_updateFloatParameter(int imol, const std::string &param_name, float value);

   void M2T_updateIntParameter(int imol, const std::string &param_name, int value);

   coot::simple_mesh_t get_molecular_representation_mesh(int imol, const std::string &cid,
                                                         const std::string &colour_scheme,
                                                         const std::string &style,
                                                         int secondary_structure_usage_flag);

   bool set_residue_properties(int imol, const std::string &json_string);
 
   // \brief clear the reisidue properties
   void clear_residue_properties(int imol);

   coot::simple_mesh_t get_gaussian_surface(int imol, float sigma, float contour_level,
                                            float box_radius, float grid_scale, float b_factor) const;

   coot::simple_mesh_t get_gaussian_surface_for_atom_selection(int imol, const std::string &cid,
                                                               float sigma, float contour_level,
                                                               float box_radius, float grid_scale,
                                                               float b_factor) const;
 
   // Make a map from a gaussian surface
   int gaussian_surface_to_map_molecule(int imol_map_ref, int imol_model,
                                        const std::string &cid,
                                        float sigma, float box_radius, float fft_b_factor);
 
   // Make a map from a gaussian surface
   int gaussian_surface_to_map_molecule_v2(int imol, const std::string &cid,
                                          float sigma, float box_radius,
                                          float grid_scale, float fft_b_factor);

   coot::simple_mesh_t get_chemical_features_mesh(int imol, const std::string &cid) const;

   mmdb::Atom *get_atom_using_cid(int imol, const std::string &cid) const;

   mmdb::Residue *get_residue_using_cid(int imol, const std::string &cid) const;
 
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   mmdb::Atom *get_atom(int imol, const coot::atom_spec_t &atom_spec) const;
   mmdb::Residue *get_residue(int imol, const coot::residue_spec_t &residue_spec) const;
   std::pair<bool, coot::Cartesian> get_atom_position(int imol, coot::atom_spec_t &atom_spec);
#endif

   bool residue_is_nucleic_acid(int imol, const std::string &cid) const;

   std::vector<double> get_residue_CA_position(int imol, const std::string &cid) const;

   std::vector<double> get_residue_average_position(int imol, const std::string &cid) const;

   std::vector<double> get_residue_sidechain_average_position(int imol, const std::string &cid) const;

   unsigned int get_number_of_atoms(int imol) const;

   float get_molecule_diameter(int imol) const;

   int get_number_of_hydrogen_atoms(int imol) const;

   std::vector<std::string> get_chains_in_model(int imol) const;

   std::vector<std::vector<std::string> > get_ncs_related_chains(int imol) const;

   std::vector<std::pair<coot::residue_spec_t, std::string> > get_single_letter_codes_for_chain(int imol, const std::string &chain_id) const;

   std::vector<std::string> get_residue_names_with_no_dictionary(int imol) const;

   std::string get_residue_name(int imol, const std::string &chain_id, int res_no, const std::string &ins_code) const;

   std::string get_residue_type(int imol, const std::string &cid) const;

   std::string get_SMILES_for_residue_type(const std::string &residue_name, int imol_enc) const;

   std::vector<coot::residue_spec_t> residues_with_missing_atoms(int imol);
 
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   // (20230117-PE I should fix that)
   coot::util::missing_atom_info missing_atoms_info_raw(int imol);
#endif

   std::vector<coot::residue_range_t> get_missing_residue_ranges(int imol) const;

   std::vector<coot::residue_spec_t> get_residues_near_residue(int imol, const std::string &residue_cid, float dist) const;

  std::vector<coot::atom_distance_t>
  get_distances_between_atoms_of_residues(int imol, const std::string &cid_res_1, const std::string &cid_res_2,
                      float dist_max) const;

   superpose_results_t SSM_superpose(int imol_ref, const std::string &chain_id_ref,
                                     int imol_mov, const std::string &chain_id_mov);

   void add_lsq_superpose_match(const std::string &chain_id_ref, int res_no_ref_start, int res_no_ref_end,
                                const std::string &chain_id_mov, int res_no_mov_start, int res_no_mov_end,
                                int match_type);

   void add_lsq_superpose_atom_match(const std::string &chain_id_ref, int res_no_ref, const std::string &atom_name_ref,
                                     const std::string &chain_id_mov, int res_no_mov, const std::string &atom_name_mov);

   void clear_lsq_matches();
 
   std::vector<coot::lsq_range_match_info_t> lsq_matchers;

   bool lsq_superpose(int imol_ref, int imol_mov);

   int transform_map_using_lsq_matrix(int imol_map, lsq_results_t lsq_matrix, float x, float y, float z, float radius);
   lsq_results_t get_lsq_matrix(int imol_ref, int imol_mov, bool summary_to_screen) const;

   coot::symmetry_info_t
   get_symmetry(int imol, float symmetry_search_radius, float centre_x, float centre_y, float centre_z) const;

   ::api::cell_t get_cell(int imol)  const;

   coot::util::map_molecule_centre_info_t get_map_molecule_centre(int imol) const;

   int undo(int imol);

   int redo(int imol);

   std::pair<int, double> get_torsion(int imol, const std::string &cid, const std::vector<std::string> &atom_names);

   void set_temperature_factors_using_cid(int imol, const std::string &cid, float temp_fact);
 
   // -------------------------------- map utils -------------------------------------------
 
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   float map_sampling_rate;
#endif

   float get_map_sampling_rate() { return map_sampling_rate; }

   void set_map_sampling_rate(float msr) { map_sampling_rate = msr; }

   int read_mtz(const std::string &file_name, const std::string &f, const std::string &phi, const std::string &weight,
                bool use_weight, bool is_a_difference_map);

   int replace_map_by_mtz_from_file(int imol, const std::string &file_name, const std::string &f, const std::string &phi,
                                    const std::string &weight, bool use_weight);

   class auto_read_mtz_info_t {
   public:
      int idx;
      std::string F;
      std::string phi;
      std::string w;
      bool weights_used;
      std::string F_obs;
      std::string sigF_obs;
      std::string Rfree;
      // constructor
      auto_read_mtz_info_t() {idx = -1; weights_used = false; }
      // constructor
      auto_read_mtz_info_t(int index, const std::string &F_in, const std::string &phi_in) :
         idx(index), F(F_in), phi(phi_in), weights_used(false) {}
      // set Fobs sigFobs column labels
      void set_fobs_sigfobs(const std::string &f, const std::string &s) {
         F_obs = f;
         sigF_obs = s;
      }
   };

   std::vector<auto_read_mtz_info_t> auto_read_mtz(const std::string &file_name);

   int read_ccp4_map(const std::string &file_name, bool is_a_difference_map);

   int write_map(int imol, const std::string &file_name) const;

   float get_map_mean(int imol) const;

   float get_map_rmsd_approx(int imol_map) const;

   coot::molecule_t::histogram_info_t get_map_histogram(int imol, unsigned int n_bins, float zoom_factor) const;
 

   float get_suggested_initial_contour_level(int imol) const;

   bool is_EM_map(int imol) const;

   int sharpen_blur_map(int imol_map, float b_factor, bool in_place_flag);

   int sharpen_blur_map_with_resample(int imol_map, float b_factor, float resample_factor, bool in_place_flag);

   int mask_map_by_atom_selection(int imol_coords, int imol_map, const std::string &cid, float atom_radius, bool invert_flag);

   std::vector<int> partition_map_by_chain(int imol_map, int imol_model);

   int make_mask(int imol_map_ref, int imol_model, const std::string &atom_selection_cid, float radius);

   int flip_hand(int imol_map);

   std::vector<int> make_masked_maps_split_by_chain(int imol, int imol_map);

   int dedust_map(int imol);

   void set_map_colour(int imol, float r, float g, float b);

   void set_map_is_contoured_with_thread_pool(bool state);

   coot::simple_mesh_t get_map_contours_mesh(int imol, double position_x, double position_y, double position_z,
                                             float radius, float contour_level);

   coot::simple_mesh_t get_map_contours_mesh_using_other_map_for_colours(int imol_ref, int imol_map_for_colouring,
                                                                         double position_x, double position_y, double position_z,
                                                                         float radius, float contour_level,
                                                                         float other_map_for_colouring_min_value,
                                                                         float other_map_for_colouring_max_value,
                                                                         bool invert_colour_ramp);
   coot::simple_mesh_t get_map_cap_mesh(int imol, float contour_level,
                                        double base_point_x, double base_point_y, double base_point_z,
                                        double x_axis_x, double x_axis_y, double x_axis_z,
                                        double y_axis_x, double y_axis_y, double y_axis_z,
                                        double x_axis_step_size, double y_axis_step_size,
                                        unsigned int n_x_axis_points, unsigned int n_y_axis_points);

   void set_map_colour_saturation(int imol, float s);
   void set_colour_map_for_map_coloured_by_other_map(std::vector<std::pair<double, std::vector<double> > > colour_table );
 
   user_defined_colour_table_t colour_map_by_other_map_user_defined_table;

   coot::molecule_t::histogram_info_t get_map_vertices_histogram(int imol, int imol_map_for_sampling,
                                 double position_x, double position_y, double position_z,
                                 float radius, float contour_level,
                                 unsigned int n_bins);
 
 

   coot::util::sfcalc_genmap_stats_t get_latest_sfcalc_stats() const { return latest_sfcalc_stats; }
 
   class r_factor_stats {
      public:
      float r_factor;  // 0 to 1
      float free_r_factor;
      int rail_points_total;
      int rail_points_new;
   };

   r_factor_stats get_r_factor_stats();

   std::string r_factor_stats_as_string(const r_factor_stats &rfs) const;

   int average_map(const std::string &imol_maps, std::vector<float> &scales);

   bool regen_map(int imol_map, const std::string &imol_maps, const std::vector<float> &scales);
 
   // -------------------------------- coordinates modelling -------------------------------

   int auto_fit_rotamer(int imol, const std::string &chain_id, int res_no, const std::string &ins_code, const std::string &alt_conf,
                        int imol_map);

   coot::molecule_t::rotamer_change_info_t change_to_next_rotamer(int imol, const std::string &residue_cid, const std::string &alt_conf);

   coot::molecule_t::rotamer_change_info_t change_to_previous_rotamer(int imol, const std::string &residue_cid, const std::string &alt_conf);

   coot::molecule_t::rotamer_change_info_t change_to_first_rotamer(int imol, const std::string &residue_cid, const std::string &alt_conf);

   int set_residue_to_rotamer_number(int imol, const std::string &residue_cid, const std::string &alt_conf, int rotamer_number);

   std::pair<int, unsigned int> delete_using_cid(int imol, const std::string &cid, const std::string &scope);

   std::pair<int, unsigned int> delete_atom(int imol, const std::string &chain_id, int res_no, const std::string &ins_code,
                   const std::string &atom_name, const std::string &alt_conf);

   std::pair<int, unsigned int> delete_atom_using_cid(int imol, const std::string &cid);

   std::pair<int, unsigned int> delete_residue(int imol, const std::string &chain_id, int res_no, const std::string &ins_code);

   std::pair<int, unsigned int> delete_residue_using_cid(int imol, const std::string &cid);

   std::pair<int, unsigned int> delete_residue_atoms_with_alt_conf(int imol, const std::string &chain_id, int res_no,
                                                                   const std::string &ins_code, const std::string &alt_conf);
   std::pair<int, unsigned int> delete_residue_atoms_using_cid(int imol, const std::string &cid);

   std::pair<int, unsigned int> delete_side_chain(int imol, const std::string &chain_id, int res_no, const std::string &ins_code);

   std::pair<int, unsigned int> delete_side_chain_using_cid(int imol, const std::string &cid);

   std::pair<int, unsigned int> delete_chain_using_cid(int imol, const std::string &cid);

   std::pair<int, unsigned int> delete_literal_using_cid(int imol, const std::string &cid);

   bool delete_all_carbohydrate(int imol);
 
   // (I should have) change(d) that stupid (alt) loc (I should have made you leave your key)
   //
   int change_alt_locs(int imol, const std::string &cid, const std::string &change_mode);

   std::pair<int, std::string> add_terminal_residue_directly(int imol, const std::string &chain_id, int res_no, const std::string &ins_code);
 
   // std::pair<int, std::string> add_terminal_residue_directly_using_cid(int imol, const std::string &cid);
   //
   int add_terminal_residue_directly_using_cid(int imol, const std::string &cid);

   int add_terminal_residue_directly_using_bucca_ml_growing_using_cid(int imol, const std::string &cid);

   int add_terminal_residue_directly_using_bucca_ml_growing(int imol, const coot::residue_spec_t &spec);

   void set_add_waters_water_to_protein_distance_lim_min(float d) {
      ligand_water_to_protein_distance_lim_min = d;
   }

   void set_add_waters_water_to_protein_distance_lim_max(float d) {
      ligand_water_to_protein_distance_lim_max = d;
   }

   void set_add_waters_variance_limit(float d) {
      ligand_water_variance_limit = d;
   }

   void set_add_waters_sigma_cutoff(float d) {
      ligand_water_sigma_cut_off = d;
   }

   int add_waters(int imol_model, int imol_map);

   int flood(int imol_model, int imol_map, float n_rmsd);

   int add_hydrogen_atoms(int imol_model);

   int delete_hydrogen_atoms(int imol_model);

   int add_alternative_conformation(int imol_model, const std::string &cid);

   int fill_partial_residue(int imol, const std::string &chain_id, int res_no, const std::string &ins_code);

   int fill_partial_residue_using_cid(int imol, const std::string &cid);

   int fill_partial_residues(int imol);

   void add_named_glyco_tree(int imol_model, int imol_map, const std::string &glycosylation_name,
                             const std::string &asn_chain_id, int asn_res_no);
 
#if NB_VERSION_MAJOR
#else
   int flip_peptide(int imol, const coot::atom_spec_t &atom_spec, const std::string &alt_conf);
#endif

   int flip_peptide_using_cid(int imol, const std::string &atom_cid, const std::string &alt_conf);

   void eigen_flip_ligand(int imol, const std::string &chain_id, int res_no, const std::string &ins_code);

   void eigen_flip_ligand_using_cid(int imol, const std::string &residue_cid);

   int mutate(int imol, const std::string &cid, const std::string &new_residue_type);

   int side_chain_180(int imol, const std::string &atom_cid);

   std::string jed_flip(int imol, const std::string &atom_cid, bool invert_selection);

   int move_molecule_to_new_centre(int imol, float x, float y, float z);

   void multiply_residue_temperature_factors(int imol, const std::string &cid, float factor);

   coot::Cartesian get_molecule_centre(int imol) const;

   double get_radius_of_gyration(int imol) const;

   struct mr_solution_t {
      glm::quat rotation;              
      float rotation_score;             
      clipper::Coord_orth translation;  
      float translation_score;          
      float mean_density_at_ca;         
      int imol;                         
      std::string pdb_filename;         
      mr_solution_t() : rotation(glm::quat(1,0,0,0)), rotation_score(0.0f),
                         translation(0,0,0), translation_score(0.0f),
                         mean_density_at_ca(0.0f), imol(-1) {}
   };

   std::vector<mr_solution_t> molecular_placement_fit(int imol_map, int imol_model,
                                                      float x, float y, float z,
                                                      int n_rotation_solutions = 10,
                                                      int n_translation_solutions = 10);

   int copy_molecule(int imol);

   int copy_fragment_using_cid(int imol, const std::string &multi_cid);

   int copy_fragment_for_refinement_using_cid(int imol, const std::string &multi_cid);

   int copy_fragment_using_residue_range(int imol, const std::string &chain_id, int res_no_start, int res_no_end);

   int apply_transformation_to_atom_selection(int imol, const std::string &atoms_selection_cid,
                                              int n_atoms, // for validation of the atom selection, (int because mmdb atom type)
                                              float m00, float m01, float m02,
                                              float m10, float m11, float m12,
                                              float m20, float m21, float m22,
                                              float c0, float c1, float c2, // the centre of the rotation
                                              float t0, float t1, float t2); // translation

   bool apply_translation_to_molecule(int imol, float tx, float ty, float tz);

   int new_positions_for_residue_atoms(int imol, const std::string &residue_cid, std::vector<coot::api::moved_atom_t> &moved_atoms);

   int new_positions_for_atoms_in_residues(int imol, const std::vector<coot::api::moved_residue_t> &moved_residues);

   std::pair<int, std::vector<merge_molecule_results_info_t> >
   merge_molecules(int imol, const std::string &list_of_other_molecules);
 
   // this is called by the above function and is useful for other non-api functions (such as add_compound()).
 
#ifdef SKIP_FOR_PYTHON_DOXYGEN
//#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   std::pair<int, std::vector<merge_molecule_results_info_t> >
   merge_molecules(int imol, std::vector<mmdb::Manager *> mols);
#endif

   int cis_trans_convert(int imol, const std::string &atom_cid);

   void replace_residue(int imol, const std::string &residue_cid, const std::string &new_residue_type, int imol_enc);

   int replace_fragment(int imol_base, int imol_reference, const std::string &atom_selection);

   int rigid_body_fit(int imol, const std::string &multi_cid, int imol_map);

   int rotate_around_bond(int imol, const std::string &residue_cid,
                          const std::string &atom_name_1,
                          const std::string &atom_name_2,
                          const std::string &atom_name_3,
                          const std::string &atom_name_4,
                          double torsion_angle);

   std::pair<int, std::string> change_chain_id(int imol, const std::string &from_chain_id,
                                               const std::string &to_chain_id,
                                               bool use_resno_range,
                                               int start_resno, int end_resno);

   int split_residue_using_map(int imol, const std::string &residue_cid, int imol_diff_map);

   void associate_sequence(int imol, const std::string &name_or_chain_id, const std::string &sequence);

   void assign_sequence(int imol_model, int imol_map);

   std::vector<std::pair<std::string, std::string> > get_sequence_info(int imol) const;

   coot::chain_mutation_info_container_t get_mutation_info(int imol) const;
 
   // -------------------------------- Coordinates Refinement ------------------------------

   int refine_residues_using_atom_cid(int imol, const std::string &cid, const std::string &mode, int n_cycles);

   int refine_residues(int imol, const std::string &chain_id, int res_no, const std::string &ins_code,
                       const std::string &alt_conf, const std::string &mode, int n_cycles);

   int refine_residue_range(int imol, const std::string &chain_id, int res_no_start, int res_no_end, int n_cycles);

   std::pair<int, coot::instanced_mesh_t>
   minimize_energy(int imol, const std::string &atom_selection_cid,
                   int n_cycles,
                   bool do_rama_plot_restraints, float rama_plot_weight,
                   bool do_torsion_restraints, float torsion_weight, bool refinement_is_quiet);

   float
   minimize(int imol, const std::string &atom_selection_cid,
            int n_cycles,
            bool do_rama_plot_restraints, float rama_plot_weight,
            bool do_torsion_restraints, float torsion_weight, bool refinement_is_quiet);

   void fix_atom_selection_during_refinement(int imol, const std::string &atom_selection_cid);

   void add_target_position_restraint(int imol, const std::string &atom_cid, float pos_x, float pos_y, float pos_z);

   void clear_target_position_restraint(int imol, const std::string &atom_cid);

   void turn_off_when_close_target_position_restraint(int imol);

   void set_logging_level(const std::string &level);

   void set_logging_file(const std::string &file_name);

   void set_use_rama_plot_restraints(bool state) { use_rama_plot_restraints = state; }

   bool get_use_rama_plot_restraints() const { return use_rama_plot_restraints; }

   void set_rama_plot_restraints_weight(float f) { rama_plot_restraints_weight = f; }

   float get_rama_plot_restraints_weight() const { return rama_plot_restraints_weight; }

   void set_use_torsion_restraints(bool state) { use_torsion_restraints = state; }

   bool get_use_torsion_restraints() const { return use_torsion_restraints; }

   void set_torsion_restraints_weight(float f) { torsion_restraints_weight = f; }

   float get_torsion_restraints_weight() const { return torsion_restraints_weight; }

   void init_refinement_of_molecule_as_fragment_based_on_reference(int imol_frag, int imol_ref, int imol_map);

   std::pair<int, coot::instanced_mesh_t> refine(int imol, int n_cycles);

   coot::instanced_mesh_t add_target_position_restraint_and_refine(int imol, const std::string &atom_cid,
                                                                   float pos_x, float pos_y, float pos_z,
                                                                   int n_cycles);
   void clear_target_position_restraints(int imol);

   void clear_refinement(int imol);

   void set_refinement_is_verbose(bool state) { refinement_is_quiet = !state; }

   void set_refinement_geman_mcclure_alpha(float a) { geman_mcclure_alpha = a; }

   float get_geman_mcclure_alpha() const { return geman_mcclure_alpha; }

   int generate_self_restraints(int imol, float local_dist_max);

   void generate_chain_self_restraints(int imol, float local_dist_max,
                                       const std::string &chain_id);

   void generate_local_self_restraints(int imol, float local_dist_max,
                                       const std::string &residue_cids);

   void add_parallel_plane_restraint(int imol,
                                     const std::string &residue_cid_1,
                                     const std::string &residue_cid_2);

   coot::instanced_mesh_t get_extra_restraints_mesh(int imol, int mode);

   int read_extra_restraints(int imol, const std::string &file_name);

   void clear_extra_restraints(int imol);

   int servalcat_refine_xray(int imol, int imol_map, const std::string &output_prefix);
 
#if NB_VERSION_MAJOR
   int servalcat_refine_xray_with_keywords(int imol, int imol_map, const std::string &output_prefix,
                                           const nanobind::dict &key_value_pairs);
#endif
 
   // -------------------------------- Coordinates validation ------------------------------

   coot::simple_mesh_t get_rotamer_dodecs(int imol);

   coot::instanced_mesh_t get_rotamer_dodecs_instanced(int imol);

   coot::simple_mesh_t get_ramachandran_validation_markup_mesh(int imol) const;

   std::vector<coot::phi_psi_prob_t> ramachandran_validation(int imol) const;

   coot::instanced_mesh_t contact_dots_for_ligand(int imol, const std::string &cid, unsigned int smoothness_factor) const;

   coot::instanced_mesh_t all_molecule_contact_dots(int imol, unsigned int smoothness_factor) const;

   // Note this function is not const because we pass a pointer to the protein_geometry geom.
   coot::simple::molecule_t get_simple_molecule(int imol, const std::string &residue_cid, bool draw_hydrogen_atoms_flag);

   generic_3d_lines_bonds_box_t
   make_exportable_environment_bond_box(int imol, coot::residue_spec_t &spec, float max_dist);

   std::vector<moorhen::h_bond> get_h_bonds(int imol, const std::string &cid_str, bool mcdonald_and_thornton_mode) const;

   // Function is not const because it might change the protein_geometry geom.
   coot::simple_mesh_t get_mesh_for_ligand_validation_vs_dictionary(int imol, const std::string &ligand_cid);

   std::vector<coot::geometry_distortion_info_pod_container_t>
   get_ligand_validation_vs_dictionary(int imol, const std::string &ligand_cid, bool include_non_bonded_contacts);

   std::vector<coot::geometry_distortion_info_pod_container_t>
   get_validation_vs_dictionary_for_selection(int imol, const std::string &selection_cid, bool include_non_bonded_contacts);

   std::pair<int, double> get_ligand_distortion(int imol, const std::string &ligand_cid, bool include_non_bonded_contacts);

   bool match_ligand_torsions(int imol_ligand, int imol_ref, const std::string &chain_id_ref, int resno_ref);

   bool match_ligand_position(int imol_ligand, int imol_ref, const std::string &chain_id_ref, int resno_ref);

   bool match_ligand_torsions_and_position(int imol_ligand, int imol_ref, const std::string &chain_id_ref, int resno_ref);

   bool match_ligand_torsions_and_position_using_cid(int imol_ligand, int imol_ref, const std::string &cid);
 
   // not const because it can dynamically add dictionaries
   coot::atom_overlaps_dots_container_t get_overlap_dots(int imol);

   coot::atom_overlaps_dots_container_t get_overlap_dots_for_ligand(int imol, const std::string &cid_ligand);

   // not const because it can dynamically add dictionaries
   std::vector<coot::plain_atom_overlap_t> get_atom_overlaps(int imol);

   float get_atom_overlap_score(int imol);

   // not const because it can dynamically add dictionaries
   std::vector<coot::plain_atom_overlap_t> get_overlaps_for_ligand(int imol, const std::string &cid_ligand);

   std::vector <positioned_atom_spec_t>
   get_atom_differences(int imol1, int imol2);

   std::string get_pucker_analysis_info(int imol) const;
 
 
   // -------------------------------- Coordinates and map validation ----------------------

   coot::validation_information_t density_fit_analysis(int imol_model, int imol_map) const;

   double get_sum_density_for_atoms_in_residue(int imol, const std::string &cid,
                                               const std::vector<std::string> &atom_names,
                                               int imol_map);

   int get_number_of_atoms_in_residue(int imol, const std::string &residue_cid) const;

   coot::validation_information_t density_correlation_analysis(int imol_model, int imol_map) const;

   coot::validation_information_t rotamer_analysis(int imol_model) const;

   coot::validation_information_t ramachandran_analysis(int imol_model) const;

   coot::validation_information_t ramachandran_analysis_for_chain(int imol_model, const std::string &chain_id) const;

   coot::validation_information_t peptide_omega_analysis(int imol_model) const;

   float get_median_temperature_factor(int imol) const;

   float get_temperature_factor_of_atom(int imol, const std::string &atom_cid) const;

   std::vector<coot::molecule_t::interesting_place_t> get_interesting_places(int imol, const std::string &mode) const;

   std::vector<coot::molecule_t::interesting_place_t> difference_map_peaks(int imol_map, int imol_protein, float n_rmsd) const;

   std::vector<coot::molecule_t::interesting_place_t> pepflips_using_difference_map(int imol_coords, int imol_difference_map, float n_sigma) const;

   std::vector<coot::molecule_t::interesting_place_t> unmodelled_blobs(int imol_model, int imol_map,
                                                                       float rmsd_cut_off) const;

   // Use the string_user_data of the spec for the button label
   std::vector <coot::atom_spec_t>
   find_water_baddies(int imol_model, int imol_map,
                      float b_factor_lim,
                      float outlier_sigma_level,
                      float min_dist, float max_dist,
                      bool ignore_part_occ_contact_flag,
                      bool ignore_zero_occ_flag);

   coot::instanced_mesh_t get_HOLE(int imol,
                                   float start_pos_x, float start_pos_y, float start_pos_z,
                                   float end_pos_x, float end_pos_y, float end_pos_z) const;

#ifdef SWIG
#else
   std::pair<std::map<coot::residue_spec_t, coot::util::density_correlation_stats_info_t>,
             std::map<coot::residue_spec_t, coot::util::density_correlation_stats_info_t> >
   get_mmrrcc(int imol, const std::string &chain_id, unsigned int n_residue_per_residue_range, int imol_map) const;

   std::pair<std::map<coot::residue_spec_t, coot::util::density_correlation_stats_info_t>,
             std::map<coot::residue_spec_t, coot::util::density_correlation_stats_info_t> >
   mmrrcc(int imol, const std::string &chain_id, int imol_map) const;
#endif
 
   // calculate the MMRRCC for the residues in the chain
   // Multi Masked Residue Range Corellation Coefficient
#ifdef SWIG
#else
   std::pair<std::map<coot::residue_spec_t, coot::util::density_correlation_stats_info_t>,
             std::map<coot::residue_spec_t, coot::util::density_correlation_stats_info_t> >
   mmrrcc_internal(const atom_selection_container_t &asc,
                   const std::string &chain_id,
                   unsigned int n_residue_per_residue_range,
                   const clipper::Xmap<float> &xmap) const;
#endif

   std::vector<std::pair<double, double> > fourier_shell_correlation(int imol_map_1, int imol_map_2) const;

   int make_power_scaled_map(int imol_ref, int imol_map_for_scaling);

   coot::validation_information_t get_q_score(int imol_model, int imol_map) const;

   coot::validation_information_t get_q_score_for_cid(int imol_model, const std::string &cid, int imol_map) const;

   std::pair<float,float> get_mean_and_variance_of_density_for_non_water_atoms(int imol_coords, int imol_map) const;

   float get_spherical_variance(int imol_map, int imol_model, const std::string &atom_cid, float mean_density_other_atoms) const;
 
   // -------------------------------- Rail Points ------------------------------------------

   int calculate_new_rail_points();

   int rail_points_total() const;
 
   // -------------------------------- Updating Maps ---------------------------------------

   void associate_data_mtz_file_with_map(int imol, const std::string &data_mtz_file_name,
                                         const std::string &f_col, const std::string &sigf_col,
                                         const std::string &free_r_col);

   int connect_updating_maps(int imol_model, int imol_with_data_info_attached, int imol_map_2fofc, int imol_map_fofc);

   void sfcalc_genmap(int imol_model,
                      int imol_map_with_data_attached,
                      int imol_updating_difference_map);

   coot::util::sfcalc_genmap_stats_t
   sfcalc_genmaps_using_bulk_solvent(int imol_model,
                                     int imol_2fofc_map,
                                     int imol_updating_difference_map,
                                     int imol_map_with_data_attached);

   bool shift_field_b_factor_refinement(int imol, int imol_with_data_attached);

   float get_density_at_position(int imol_map, float x, float y, float z) const;

   // This is a light-weight fetch, the values have already been computed, here
   // were are merely copying them.
   std::vector<std::pair<clipper::Coord_orth, float> > get_diff_diff_map_peaks(int imol_diff_map,
                                                                               float screen_centre_x,
                                                                               float screen_centre_y,
                                                                               float screen_centre_z) const;
 

   std::string get_data_set_file_name(int imol) const;
 
   // -------------------------------- Go To Blob ---------------------------------------

   std::pair<bool, clipper::Coord_orth> go_to_blob(float x1, float y1, float z1, float x2, float y2, float z2,
                                                   float contour_level);
 
 
   // -------------------------------- Ligand Functions ---------------------------------------

   // I am not yet clear what extra cut-offs and flags need to be added here.
   std::vector<int> fit_ligand_right_here(int imol_protein, int imol_map, int imol_ligand, float x, float y, float z,
                                          float n_rmsd, bool use_conformers, unsigned int n_conformers);

 
   class fit_ligand_info_t {
   public:
      int imol; // the imol of the fitted ligand
      int cluster_idx;  // the index of the cluster
      int ligand_idx;  // the ligand idx for a given cluster
      float fitting_score;
      float cluster_volume;
      fit_ligand_info_t(int i, int c, int l) : imol(i), cluster_idx(c), ligand_idx(l) { fitting_score = -1.0; cluster_volume = -1.0;}
      fit_ligand_info_t() { imol = -1; cluster_idx = -1; ligand_idx = -1; fitting_score = 1.0; cluster_volume = -1.0; }
      float get_fitting_score() const { return fitting_score; }
      float get_cluster_volume() const { return cluster_volume; }
   };

   std::vector<fit_ligand_info_t> fit_ligand(int imol_protein, int imol_map, int imol_ligand,
                                             float n_rmsd, bool use_conformers, unsigned int n_conformers);

   std::vector<fit_ligand_info_t> fit_ligand_multi_ligand(int imol_protein, int imol_map, const std::string &multi_ligand_molecule_number_list,
                                                          float n_rmsd, bool use_conformers, unsigned int n_conformers);

   float fit_to_map_by_random_jiggle(int imol, const coot::residue_spec_t &res_spec, int n_trials, float translation_scale_factor);

   float fit_to_map_by_random_jiggle_using_cid(int imol, const std::string &cid, int n_trials, float translation_scale_factor);

   float fit_to_map_by_random_jiggle_with_blur_using_cid(int imol, int imol_map, const std::string &cid, float b_factor,
                                                         int n_trials, float translation_scale_factor);

 
   int add_compound(int imol, const std::string &tlc, int imol_dict, int imol_map, float x, float y, float z);
   // This is a ligand function, not really a ligand-fitting function.
   std::string get_svg_for_residue_type(int imol, const std::string &comp_id,
                                        bool use_rdkit_svg,
                                        const std::string &background_type);

   std::string get_svg_for_2d_ligand_environment_view(int imol, const std::string &residue_cid, bool add_key);

   std::vector<coot::residue_spec_t> get_non_standard_residues_in_molecule(int imol) const;

   bool try_read_dictionaries_for_new_residue_types(int imol);

   std::vector<int> get_dictionary_conformers(const std::string &comp_id, int imol_enc, bool remove_internal_clash_conformers);

   texture_as_floats_t get_map_section_texture(int imol, int section_id, int axis,
                                               float data_value_for_bottom, float data_value_for_top) const;

   int get_number_of_map_sections(int imol_map, int axis_id) const;
 
   // -------------------------------- Others -------------------------------------

   coot::simple_mesh_t make_mesh_from_gltf_file(const std::string &file_name);

   coot::simple_mesh_t get_octahemisphere(unsigned int n_divisions) const;
 
   unsigned int get_max_number_of_simple_mesh_vertices() const;
   void set_max_number_of_simple_mesh_vertices(unsigned int n);

   std::string pae_png(const std::string &pae_file_name) const;
 
   // -------------------------------- Testing -------------------------------------
 
   class ltj_stats_t {
   public:
      unsigned int count;
      float function_value;
      std::chrono::time_point<std::chrono::high_resolution_clock> timer_start;
      std::chrono::time_point<std::chrono::high_resolution_clock> timer;
      ltj_stats_t() : timer(std::chrono::high_resolution_clock::now()) {
         count = 0;
         function_value = 0;
         timer_start = timer;
      }
      void update_timer() {
         timer = std::chrono::high_resolution_clock::now();
         count += 1;
      }

      double time_difference() {
         timer = std::chrono::high_resolution_clock::now();
         auto d10 = std::chrono::duration_cast<std::chrono::microseconds>(timer - timer_start).count();
         return d10;
      }
   };

   ltj_stats_t long_term_job_stats;
 
   // not for user-control
   bool interrupt_long_term_job;

   void testing_start_long_term_job(unsigned int n_seconds);

   void testing_stop_long_term_job();

   ltj_stats_t testing_interrogate_long_term_job() { return long_term_job_stats; }

   double get_contouring_time() const { return contouring_time; }

   void set_max_number_of_threads(unsigned int n_threads);

   void set_max_number_of_threads_in_thread_pool(unsigned int n_threads);

   double test_the_threading(int n_threads);

   double test_launching_threads(unsigned int n_threads_per_batch, unsigned int n_batches) const;

   double test_thread_pool_threads(unsigned int n_threads);

   int mmcif_tests(bool last_test_only);
 
   // I want this function in the C++ documentation, but not the Python API documentation.
   // Hmm.
#ifdef DOXYGEN_SHOULD_PARSE_THIS
#else
   coot::protein_geometry & get_geometry() {
      return geom;
   }
#endif
 
   // -------------------------------- Blender Interface ---------------------------------------


   void make_mesh_for_map_contours_for_blender(int imol, float x, float y, float z, float level, float radius);
   void make_mesh_for_bonds_for_blender(int imol, const std::string &mode, bool against_a_dark_background,
                                      float bond_width, float atom_radius_to_bond_width_ratio,
                                      int smoothness_factor);
   void make_mesh_for_molecular_representation_for_blender(int imol,
                                                           const std::string &cid,
                                                           const std::string &colour_scheme,
                                                           const std::string &style,
                                                           int secondary_structure_usage_flag);
   void make_mesh_for_gaussian_surface_for_blender(int imol, float sigma, float contour_level, float box_radius, float grid_scale, float b_factor);

   void make_mesh_for_goodsell_style_for_blender(int imol, float colour_wheel_rotation_step,
                                                 float saturation, float goodselliness);

   std::vector<float> get_colour_table_for_blender(int imol);
   std::vector<float> get_vertices_for_blender(int imol);
   std::vector<int>   get_triangles_for_blender(int imol);
 
   // -------------------------------- Pyrogen ---------------------------------------

   int pyrogen_from_SMILES(const std::string &smiles_string, const std::string &compound_id);

   int pyrogen_from_ccd_file(const std::string &ccd_file_name);

   int pyrogen_from_rdkit_mol_pickle_base64(const std::string &rdkit_mol_pickled_string, const std::string &compound_id);
 
   // -------------------------------- Other ---------------------------------------
 
   void test_function(const std::string &s);

   std::string rebox_map(int imol_model, const std::string &atom_selection_cid,
                         int imol_map, float border, unsigned int n_pixels_per_edge);
 
#if NB_VERSION_MAJOR
   // skip this (old) block for nanobinds
#else
#ifdef DOXYGEN_SHOULD_PARSE_THIS


   enum mesh_mode_t { UNKNOWN, SINGLE_COLOUR, MULTI_COLOUR };
   PyObject *simple_mesh_to_pythonic_mesh(const coot::simple_mesh_t &mesh, int mesh_mode);
   PyObject *get_pythonic_bonds_mesh(int imol, const std::string &mode, bool against_a_dark_background,
                                     float bond_width, float atom_radius_to_bond_width_ratio,
                                     int smoothness_factor);
   PyObject *get_pythonic_map_mesh(int imol, float x, float y, float z, float radius, float contour_level);
   PyObject *get_pythonic_molecular_representation_mesh(int imol, const std::string &atom_selection,
                                                        const std::string &colour_sheme,
                                                        const std::string &style,
                                                        int secondary_structure_usage_flag);
   PyObject *get_pythonic_gaussian_surface_mesh(int imol, float sigma, float contour_level,
                                                float box_radius, float grid_scale, float fft_b_factor);
   PyObject *get_pythonic_simple_molecule(int imol, const std::string &cid, bool include_hydrogen_atoms_flag);
 
#endif
#endif
 
};
 
#endif // MOLECULES_CONTAINER_HH