gemmi namespace

Contents

Namespaces

namespace cif
namespace impl
namespace impl_fprim
namespace pdb_impl

Classes

struct AlignmentResult
struct AlignmentScoring
struct Assembly
struct Atom
struct AtomAddress
struct AtomGroup
class BasicInput
struct BasicRefinementInfo
template<typename Policy>
struct BidirIterator
struct BondedAtom
struct BondIndex
struct BoundingBox
template<typename T = float>
struct Ccp4
struct CenterOfMass
struct Chain
struct ChainNameGenerator
struct ChemComp
struct ChemLink
struct ChemMod
struct Connection
struct const_CRA
struct ConstAtomGroup
template<typename Filter, typename Value>
struct ConstFilterProxy
struct ConstResidueGroup
struct ConstResidueSpan
template<typename Value, typename Vector = std::vector<Value>>
struct ConstUniqProxy
struct ContactSearch
struct Correlation
struct Covariance
struct CRA
template<typename CraT>
class CraIterPolicy
template<typename CraT, typename ChainsRefT>
struct CraProxy_
struct CrystalInfo
struct DataStats
template<typename Table, typename Real>
struct DensityCalculator
struct DiffractionInfo
template<bool FileOnly = true, typename Filter = impl::IsAnyFile>
class DirWalk
struct Element
struct Entity
template<int N, typename Real>
struct ExpAnisoSum
struct ExperimentInfo
template<int N, typename Real>
struct ExpSum
struct FileStream
template<typename Filter, typename Vector, typename Value>
class FilterIterPolicy
template<typename Filter, typename Value>
struct FilterProxy
struct Fractional
struct FTransform
struct GlobWalk
template<typename T = float>
struct Grid
template<typename T>
struct GridBase
struct GridOp
template<typename Vector, typename Value>
class GroupingIterPolicy
struct GroupOps
struct Helix
template<typename Redirect, typename Value>
class IndirectIterPolicy
template<class Real>
struct IT92
struct LinkHunt
template<typename T, typename V>
struct MaskedGrid
struct Mat33
class MaybeGzipped
struct MemoryStream
struct Metadata
struct Model
struct MonLib
struct Mtz
struct MtzDataProxy
struct MtzExternalDataProxy
template<typename Item>
struct MutableVectorSpan
struct NcsOp
struct Ofstream
struct Op
template<int N>
struct OptionalInt
struct PdbWriteOptions
struct Position
struct ReciprocalAsuChecker
template<typename T>
struct ReciprocalGrid
struct RefinementInfo
struct ReflectionsInfo
struct ReflnBlock
struct ReflnDataProxy
struct Residue
struct ResidueGroup
struct ResidueId
struct ResidueInfo
struct ResidueSpan
struct Restraints
struct Selection
struct SeqId
struct Sheet
struct SmallStructure
template<typename T>
struct SMat33
struct SoftwareItem
struct SpaceGroup
struct SpaceGroupAltName
template<typename Item>
struct Span
template<typename Value>
class StrideIterPolicy
struct Structure
template<typename Table>
class StructureFactorCalculator
struct SubCells
struct SymImage
struct TlsGroup
struct Topo
struct Transform
template<typename Vector, typename Value>
class UniqIterPolicy
template<typename Value, typename Vector = std::vector<Value>>
struct UniqProxy
struct UnitCell
struct UnmergedHklMover
struct Variance
struct Vec3

Enums

enum class HowToNameCopiedChains { Short, AddNumber, Dup }
enum class GridSetup { ReorderOnly, ResizeOnly, Full, FullCheck }
enum class BondType { Unspec, Single, Double, Triple, Aromatic, Deloc, Metal }
enum class ChiralityType { Positive, Negative, Both }
enum class ChemCompModel { Xyz, Example, Ideal }
enum class El: unsigned char { X =0, H =1, He, Li, Be, B, C, N, O, F, Ne, Na, Mg, Al, Si, P, S, Cl, Ar, K, Ca, Sc, Ti, V, Cr, Mn, Fe, Co, Ni, Cu, Zn, Ga, Ge, As, Se, Br, Kr, Rb, Sr, Y, Zr, Nb, Mo, Tc, Ru, Rh, Pd, Ag, Cd, In, Sn, Sb, Te, I, Xe, Cs, Ba, La, Ce, Pr, Nd, Pm, Sm, Eu, Gd, Tb, Dy, Ho, Er, Tm, Yb, Lu, Hf, Ta, W, Re, Os, Ir, Pt, Au, Hg, Tl, Pb, Bi, Po, At, Rn, Fr, Ra, Ac, Th, Pa, U, Np, Pu, Am, Cm, Bk, Cf, Es, Fm, Md, No, Lr, Rf, Db, Sg, Bh, Hs, Mt, Ds, Rg, Cn, Nh, Fl, Mc, Lv, Ts, Og, D, END }
enum class AxisOrder: unsigned char { Unknown, XYZ, ZYX }
enum class CoorFormat { Unknown, UnknownAny, Pdb, Mmcif, Mmjson, ChemComp }
enum class EntityType: unsigned char { Unknown, Polymer, NonPolymer, Water }
enum class PolymerType: unsigned char { Unknown, PeptideL, PeptideD, Dna, Rna, DnaRnaHybrid, SaccharideD, SaccharideL, Pna, CyclicPseudoPeptide, Other }
enum class CrystalSystem: unsigned char { Triclinic =0, Monoclinic, Orthorhombic, Tetragonal, Trigonal, Hexagonal, Cubic }
enum class PointGroup: unsigned char { C1 =0, Ci, C2, Cs, C2h, D2, C2v, D2h, C4, S4, C4h, D4, C4v, D2d, D4h, C3, C3i, D3, C3v, D3d, C6, C3h, C6h, D6, C6v, D3h, D6h, T, Th, O, Td, Oh }
enum class Laue: unsigned char { L1 =0, L2m, Lmmm, L4m, L4mmm, L3, L3m, L6m, L6mmm, Lm3, Lm3m }
enum class Asu: unsigned char { Same, Different, Any }

Typedefs

using CifWalk = DirWalk<true, impl::IsCifFile>
using MmCifWalk = DirWalk<true, impl::IsMmCifFile>
using PdbWalk = DirWalk<true, impl::IsPdbFile>
using CoorFileWalk = DirWalk<true, impl::IsCoordinateFile>
using fileptr_t = std::unique_ptr<std::FILE, decltype(&std::fclose)>
template<typename T>
using FPhiGrid = ReciprocalGrid<std::complex<T>>
template<typename Value>
using StrideIter = BidirIterator<StrideIterPolicy<Value>>
template<typename Redirect, typename Value>
using IndirectIter = BidirIterator<IndirectIterPolicy<Redirect, Value>>
template<typename Vector, typename Value>
using UniqIter = BidirIterator<UniqIterPolicy<Vector, Value>>
template<typename Vector, typename Value>
using GroupingIter = BidirIterator<GroupingIterPolicy<Vector, Value>>
template<typename Filter, typename Vector, typename Value>
using FilterIter = BidirIterator<FilterIterPolicy<Filter, Vector, Value>>
using CraProxy = CraProxy_<CRA, std::vector<Chain>&>
using ConstCraProxy = CraProxy_<const_CRA, const std::vector<Chain>&>
using read_cif_func = cif::Document(*)(const std::string&)
using spacegroup_tables = impl::Tables_<void>
using Miller = std::array<int, 3>

Functions

auto make_assembly(const Assembly& assembly, const Model& model, HowToNameCopiedChains how, std::ostream* out) -> Model
void change_to_assembly(Structure& st, const std::string& assembly_name, HowToNameCopiedChains how, std::ostream* out)
void rename_chain(Structure& st, Chain& chain, const std::string& new_name)
void shorten_chain_names(Structure& st)
auto is_space(char c) -> bool
auto is_blank(char c) -> bool
auto is_digit(char c) -> bool
auto skip_blank(const char* p) -> const char*
auto skip_word(const char* p) -> const char*
auto read_word(const char* line) -> std::string
auto read_word(const char* line, const char** endptr) -> std::string
auto string_to_int(const char* p, bool checked, size_t length = 0) -> int
auto string_to_int(const std::string& str, bool checked) -> int
auto simple_atoi(const char* p, const char** endptr = nullptr) -> int
auto no_sign_atoi(const char* p, const char** endptr = nullptr) -> int
auto simple_atof(const char* p, const char** endptr = nullptr) -> double
template<class T>
auto count_atom_sites(const T& obj) -> size_t
template<>
auto count_atom_sites(const Residue& res) -> size_t
template<class T>
auto count_occupancies(const T& obj) -> double
template<>
auto count_occupancies(const Atom& atom) -> double
template<class T>
auto calculate_mass(const T& obj) -> double
template<>
auto calculate_mass(const Atom& atom) -> double
template<class T>
auto calculate_center_of_mass(const T& obj) -> CenterOfMass
template<>
auto calculate_center_of_mass(const Atom& atom) -> CenterOfMass
auto calculate_b_est(const Atom& atom) -> double
auto calculate_angle_v(const Vec3& a, const Vec3& b) -> double
auto calculate_angle(const Position& p0, const Position& p1, const Position& p2) -> double
auto calculate_dihedral(const Position& p0, const Position& p1, const Position& p2, const Position& p3) -> double
auto calculate_dihedral_from_atoms(const Atom* a, const Atom* b, const Atom* c, const Atom* d) -> double
auto calculate_omega(const Residue& res, const Residue& next) -> double
auto calculate_chiral_volume(const Position& actr, const Position& a1, const Position& a2, const Position& a3) -> double
auto calculate_phi_psi(const Residue* prev, const Residue& res, const Residue* next) -> std::array<double, 2>
auto find_best_plane(const std::vector<Atom*>& atoms) -> std::array<double, 4>
auto get_distance_from_plane(const Position& pos, const std::array<double, 4>& coeff) -> double
auto angle_abs_diff(double a, double b) -> double
template<typename Restr>
auto angle_z(double value_rad, const Restr& restr) -> double
auto bond_type_from_string(const std::string& s) -> BondType
auto bond_type_to_string(BondType btype) -> const char*
auto order_of_bond_type(BondType btype) -> float
auto chirality_from_string(const std::string& s) -> ChiralityType
auto chirality_to_string(ChiralityType chir_type) -> const char*
auto make_chemcomp_from_block(const cif::Block& block_) -> ChemComp
auto make_chemcomp_from_cif(const std::string& name, const cif::Document& doc) -> ChemComp
auto make_residue_from_chemcomp_block(const cif::Block& block, ChemCompModel kind) -> Residue
auto make_model_from_chemcomp_block(const cif::Block& block, ChemCompModel kind) -> Model
auto make_structure_from_chemcomp_block(const cif::Block& block) -> Structure
auto check_chemcomp_block_number(const cif::Document& doc) -> int
auto make_structure_from_chemcomp_doc(const cif::Document& doc) -> Structure
auto as_utf8(const _tinydir_char_t* path) -> std::string
auto glob_match(const std::string& pattern, const std::string& str) -> bool
auto is_hydrogen(El el) -> bool
auto is_metal(El el) -> bool
auto molecular_weight(El el) -> double
auto covalent_radius(El el) -> float
auto element_name(El el) -> const char*
auto element_uppercase_name(El el) -> elname_t&
auto find_element(const char* symbol) -> El
auto entity_type_to_string(EntityType entity_type) -> std::string
auto entity_type_from_string(const std::string& t) -> EntityType
auto polymer_type_to_qstring(PolymerType polymer_type) -> std::string
auto polymer_type_from_string(const std::string& t) -> PolymerType
auto software_classification_to_string(SoftwareItem::Classification c) -> std::string
auto software_classification_from_string(const std::string& str) -> SoftwareItem::Classification
void fail(const std::string& msg)
template<typename T, typename... Args>
void fail(std::string&& str, T&& arg1, Args && ... args)
template<typename T, typename... Args>
void fail(const std::string& str, T&& arg1, Args && ... args)
void unreachable()
auto path_basename(const std::string& path, std::initializer_list<const char*> exts) -> std::string
auto file_open(const char* path, const char* mode) -> fileptr_t
auto file_open_or(const char* path, const char* mode, std::FILE* dash_stream) -> fileptr_t
auto file_size(std::FILE* f, const std::string& path) -> std::size_t
auto is_pdb_code(const std::string& str) -> bool
auto expand_pdb_code_to_path(const std::string& code, char type) -> std::string
auto expand_if_pdb_code(const std::string& input, char type = 'M') -> std::string
auto is_little_endian() -> bool
void swap_two_bytes(void* start)
void swap_four_bytes(void* start)
template<typename T>
auto phase_in_angles(const std::complex<T>& v) -> double
template<typename DataProxy>
auto get_size_for_hkl(const DataProxy& data, std::array<int, 3> min_size, double sample_rate) -> std::array<int, 3>
template<typename DataProxy>
auto data_fits_into(const DataProxy& data, std::array<int, 3> size) -> bool
auto friedel_mate_value(float v) -> float
auto friedel_mate_value(double v) -> double
template<typename T>
auto friedel_mate_value(const std::complex<T>& v) -> std::complex<T>
template<typename T>
void add_friedel_mates(ReciprocalGrid<T>& grid)
template<typename T, typename DataProxy>
void initialize_hkl_grid(ReciprocalGrid<T>& grid, const DataProxy& data, std::array<int, 3> size, bool half_l, AxisOrder axis_order)
template<typename T, typename DataProxy>
auto get_f_phi_on_grid(const DataProxy& data, size_t f_col, size_t phi_col, std::array<int, 3> size, bool half_l, AxisOrder axis_order = AxisOrder::XYZ) -> FPhiGrid<T>
template<typename T, typename DataProxy>
auto get_value_on_grid(const DataProxy& data, size_t column, std::array<int, 3> size, bool half_l, AxisOrder axis_order = AxisOrder::XYZ) -> ReciprocalGrid<T>
template<typename T>
void transform_f_phi_grid_to_map_(FPhiGrid<T>&& hkl, Grid<T>& map)
template<typename T>
auto transform_f_phi_grid_to_map(FPhiGrid<T>&& hkl) -> Grid<T>
template<typename T, typename DataProxy>
auto transform_f_phi_to_map(const DataProxy& data, size_t f_col, size_t phi_col, std::array<int, 3> size, double sample_rate, bool exact_size = false, AxisOrder order = AxisOrder::XYZ) -> Grid<T>
template<typename T>
auto transform_map_to_f_phi(const Grid<T>& map, bool half_l) -> FPhiGrid<T>
void cromer_libermann_for_array(int z, int npts, const double* energy, double* fp, double* fpp)
auto cromer_libermann(int z, double energy, double* fpp) -> double
auto modulo(int a, int n) -> int
auto has_small_factorization(int n) -> bool
auto good_grid_size(const std::array<double, 3>& limit, bool denser, const SpaceGroup* sg) -> std::array<int, 3>
void check_grid_factors(const SpaceGroup* sg, int u, int v, int w)
auto lerp_(double a, double b, double t) -> double
template<typename T>
auto lerp_(std::complex<T> a, std::complex<T> b, double t) -> std::complex<T>
auto estimate_uncompressed_size(const std::string& path) -> size_t
auto big_gzread(gzFile file, void* buf, size_t len) -> size_t
auto read_cif_gz(const std::string& path) -> cif::Document
auto read_mmjson_gz(const std::string& path) -> cif::Document
auto read_cif_or_mmjson_gz(const std::string& path) -> cif::Document
auto read_structure_gz(const std::string& path, CoorFormat format = CoorFormat::Unknown) -> Structure
auto read_pdb_gz(const std::string& path, int linelen = 0) -> Structure
auto coor_format_from_ext_gz(const std::string& path) -> CoorFormat
auto prepare_blosum62_scoring() -> AlignmentScoring
auto prepare_free_gapo(const ConstResidueSpan& polymer, PolymerType polymer_type) -> std::vector<bool>
auto align_sequence_to_polymer(const std::vector<std::string>& full_seq, const ConstResidueSpan& polymer, PolymerType polymer_type, const AlignmentScoring& scoring) -> AlignmentResult
auto seqid_matches_seqres(const ConstResidueSpan& polymer, const Entity& ent) -> bool
void assign_label_seq_id(ResidueSpan& polymer, const Entity* ent)
void clear_label_seq_id(Structure& st)
void assign_label_seq_id(Structure& st, bool force)
void setup_for_mmcif(Structure& st)
auto pi() -> double constexpr
auto hc() -> double constexpr
auto deg(double angle) -> double constexpr
auto rad(double angle) -> double constexpr
auto sq(float x) -> float constexpr
auto sq(double x) -> double constexpr
auto iround(double d) -> int
auto operator*(double d, const Vec3& v) -> Vec3
template<typename T>
auto calculate_data_statistics(const std::vector<T>& data) -> DataStats
auto make_structure_from_block(const cif::Block& block) -> Structure
auto coor_format_from_ext(const std::string& path) -> CoorFormat
auto make_structure(const cif::Document& doc) -> Structure
template<typename T>
auto read_structure(T&& input, CoorFormat format = CoorFormat::Unknown) -> Structure
auto read_structure_file(const std::string& path, CoorFormat format = CoorFormat::Unknown) -> Structure
auto is_polypeptide(PolymerType pt) -> bool
auto is_polynucleotide(PolymerType pt) -> bool
auto is_same_conformer(char altloc1, char altloc2) -> bool
auto atom_str(const std::string& chain_name, const ResidueId& res_id, const std::string& atom_name, char altloc) -> std::string
auto atom_str(const Chain& chain, const ResidueId& res_id, const Atom& atom) -> std::string
auto atom_str(const const_CRA& cra) -> std::string
auto atom_matches(const const_CRA& cra, const AtomAddress& addr) -> bool
auto get_mmcif_connection_type_id(Connection::Type t) -> const char*
auto get_entity_of(const ConstResidueSpan& sub, const std::vector<Entity>& entities) -> const Entity*
void add_distinct_altlocs(const Residue& res, std::string& altlocs)
auto read_link_restraints(const cif::Block& block_) -> Restraints
auto chemcomp_group_to_kind(const std::string& group) -> ResidueInfo::Kind
template<typename T>
void insert_comp_list(cif::Document& doc, T& ri_map)
void insert_chemlinks(cif::Document& doc, std::map<std::string, ChemLink>& links)
auto chem_mod_type(const std::string& str) -> int
auto read_restraint_modifications(const cif::Block& block_) -> Restraints
void insert_chemmods(cif::Document& doc, std::map<std::string, ChemMod>& mods)
auto read_monomer_cif(const std::string& path, read_cif_func read_cif) -> MonLib
auto read_monomer_lib(std::string monomer_dir, const std::vector<std::string>& resnames, read_cif_func read_cif) -> MonLib
template<typename T, typename FP = typename std::iterator_traits<T>::value_type>
auto calculate_min_max_disregarding_nans(T begin, T end) -> std::array<FP, 2>
auto read_mtz_file(const std::string& path) -> Mtz
template<typename Input>
auto read_mtz(Input&& input, bool with_data) -> Mtz
auto read_pdb_file(const std::string& path, int linelen = 0) -> Structure
auto read_pdb_from_memory(const char* data, size_t size, const std::string& name, int linelen = 0) -> Structure
auto read_pdb_string(const std::string& str, const std::string& name) -> Structure
template<typename T>
auto read_pdb(T&& input, int linelen = 0) -> Structure
void add_hydrogens(const ChemComp& cc, Residue& res)
auto position_from_angle_and_torsion(const Position& x1, const Position& x2, const Position& x3, double dist, double theta, double tau) -> Position
auto rotate_about_axis(const Vec3& v, const Vec3& axis, double theta) -> Vec3
auto get_vector_to_line(const Position& point, const Position& point_on_the_line, const Vec3& unit_vector) -> Vec3
auto trilaterate(const Position& p1, double r1sq, const Position& p2, double r2sq, const Position& p3, double r3sq) -> std::pair<Position, Position>
auto position_from_two_angles(const Position& p1, const Position& p2, const Position& p3, double dist14, double theta214, double theta314) -> std::pair<Position, Position>
void place_hydrogens(const Atom& atom, Topo::ResInfo& ri, const Topo& topo)
auto check_polymer_type(const ConstResidueSpan& polymer) -> PolymerType
auto calculate_sequence_weight(const std::vector<std::string>& seq, double unknown = 0.) -> double
auto one_letter_code(const std::vector<std::string>& seq) -> std::string
auto one_letter_code(const ConstResidueSpan& polymer) -> std::string
auto is_polymer_residue(const Residue& res, PolymerType ptype) -> bool
auto are_connected(const Residue& r1, const Residue& r2, PolymerType ptype) -> bool
auto are_connected2(const Residue& r1, const Residue& r2, PolymerType ptype) -> bool
auto are_connected3(const Residue& r1, const Residue& r2, PolymerType ptype) -> bool
auto make_one_letter_sequence(const ConstResidueSpan& polymer) -> std::string
auto has_subchains_assigned(const Chain& chain) -> bool
void add_entity_types(Chain& chain, bool overwrite)
void add_entity_types(Structure& st, bool overwrite)
void assign_subchain_names(Chain& chain)
void assign_subchains(Structure& st, bool force)
void ensure_entities(Structure& st)
auto operator==(const Entity::DbRef& a, const Entity::DbRef& b) -> bool
void deduplicate_entities(Structure& st)
void setup_entities(Structure& st)
template<class T>
void remove_alternative_conformations(T& obj)
template<class T>
void uniquify_items(std::vector<T>& items)
template<>
void remove_alternative_conformations(Chain& chain)
template<class T>
void remove_hydrogens(T& obj)
template<>
void remove_hydrogens(Residue& res)
template<class T>
void remove_waters(T& obj)
template<>
void remove_waters(Chain& ch)
void remove_ligands_and_waters(Chain& ch)
void remove_ligands_and_waters(Structure& st)
void remove_empty_chains(Model& m)
void remove_empty_chains(Structure& st)
auto trim_to_alanine(Residue& res) -> bool
void trim_to_alanine(Chain& chain)
auto as_refln_blocks(std::vector<cif::Block>&& blocks) -> std::vector<ReflnBlock>
auto get_refln_block(std::vector<cif::Block>&& blocks, const std::vector<std::string>& labels, const char* block_name = nullptr) -> ReflnBlock
auto hkl_cif_as_refln_block(cif::Block& block) -> ReflnBlock
auto remark_number(const std::string& remark) -> int
void read_metadata_from_remarks(Structure& st)
auto read_remark_290(const std::vector<std::string>& raw_remarks) -> std::vector<Op>
auto find_tabulated_residue(const std::string& name) -> ResidueInfo
auto expand_protein_one_letter(char c) -> const char*
template<typename F>
auto determine_cutoff_radius(const F& func, float cutoff_level) -> double
auto parse_cid(const std::string& cid) -> Selection
auto align_sequences(const std::vector<std::uint8_t>& query, const std::vector<std::uint8_t>& target, const std::vector<bool>& free_gapo, std::uint8_t m, const AlignmentScoring& scoring) -> AlignmentResult
auto align_string_sequences(const std::vector<std::string>& query, const std::vector<std::string>& target, const std::vector<bool>& free_gapo, const AlignmentScoring& scoring) -> AlignmentResult
auto calculate_sf_part(const Fractional& fpos, const Miller& hkl) -> std::complex<double>
template<typename T>
void split_element_and_charge(const std::string& label, T* dest)
auto make_small_structure_from_block(const cif::Block& block_) -> SmallStructure
auto to_str(double d) -> std::string
auto to_str(float d) -> std::string
template<int Prec>
auto to_str_prec(double d) -> std::string
auto gf_snprintf(char* buf, int count, char const* fmt, ...) -> int
auto operator==(const Op& a, const Op& b) -> bool
auto operator!=(const Op& a, const Op& b) -> bool
auto operator*(const Op& a, const Op& b) -> Op
auto operator*=(Op& a, const Op& b) -> Op&
auto parse_triplet_part(const std::string& s) -> std::array<int, 4>
auto parse_triplet(const std::string& s) -> Op
auto make_triplet_part(int x, int y, int z, int w, char style = 'x') -> std::string
auto centring_vectors(char lattice_symbol) -> std::vector<Op::Tran>
auto split_centering_vectors(const std::vector<Op>& ops) -> GroupOps
auto hall_rotation_z(int N) -> Op::Rot
auto hall_translation_from_symbol(char symbol) -> Op::Tran
auto hall_matrix_symbol(const char* start, const char* end, int pos, int& prev) -> Op
auto parse_hall_change_of_basis(const char* start, const char* end) -> Op
auto generators_from_hall(const char* hall) -> GroupOps
auto symops_from_hall(const char* hall) -> GroupOps
auto crystal_system_str(CrystalSystem system) -> const char*
auto point_group_hm(PointGroup pg) -> const char*
auto pointgroup_to_laue(PointGroup pg) -> Laue
auto laue_to_pointgroup(Laue laue) -> PointGroup
auto laue_class_str(Laue laue) -> const char*
auto crystal_system(Laue laue) -> CrystalSystem
auto crystal_system(PointGroup pg) -> CrystalSystem
auto point_group_index_and_category(int space_group_number) -> unsigned char
auto point_group(int space_group_number) -> PointGroup
auto is_sohncke(int space_group_number) -> bool
auto is_enantiomorphic(int space_group_number) -> bool
auto get_basisop(int basisop_idx) -> const char*
auto find_spacegroup_by_number(int ccp4) -> const SpaceGroup* noexcept
auto get_spacegroup_by_number(int ccp4) -> const SpaceGroup&
auto get_spacegroup_reference_setting(int number) -> const SpaceGroup&
auto find_spacegroup_by_name(std::string name, double alpha = 0., double gamma = 0.) -> const SpaceGroup* noexcept
auto get_spacegroup_by_name(const std::string& name) -> const SpaceGroup&
auto get_spacegroup_p1() -> const SpaceGroup&
auto find_spacegroup_by_ops(const GroupOps& gops) -> const SpaceGroup*
auto find_spacegroup_by_change_of_basis(const SpaceGroup* sg, const Op& cob) -> const SpaceGroup*
void update_cif_block(const Structure& st, cif::Block& block, bool with_atoms)
auto make_mmcif_document(const Structure& st) -> cif::Document
auto make_mmcif_headers(const Structure& st) -> cif::Block
void write_pdb(const Structure& st, std::ostream& os, PdbWriteOptions opt = PdbWriteOptions())
void write_minimal_pdb(const Structure& st, std::ostream& os, PdbWriteOptions opt = PdbWriteOptions())
auto make_pdb_headers(const Structure& st) -> std::string
auto padded_atom_name(const Atom& atom) -> std::string
template<typename T, typename... Args>
auto tostr(T&& value, Args && ... args) -> std::string
auto UTF8_to_wchar(const char* in) -> std::wstring
auto wchar_to_UTF8(const wchar_t* in) -> std::string
auto starts_with(const std::string& str, const std::string& prefix) -> bool
template<size_t N>
auto starts_with(const char* a, const char(&b)[N]) -> bool
auto ends_with(const std::string& str, const std::string& suffix) -> bool
auto iequal(const std::string& str, const std::string& low) -> bool
auto istarts_with(const std::string& str, const std::string& prefix) -> bool
auto iends_with(const std::string& str, const std::string& suffix) -> bool
auto giends_with(const std::string& str, const std::string& suffix) -> bool
auto to_lower(std::string str) -> std::string
auto to_upper(std::string str) -> std::string
auto alpha_up(char c) -> char
auto trim_str(const std::string& str) -> std::string
auto rtrim_str(const std::string& str) -> std::string
auto rtrim_cstr(const char* start, const char* end = nullptr) -> const char*
template<typename S>
void split_str_into(const std::string& str, S sep, std::vector<std::string>& result)
template<typename S>
auto split_str(const std::string& str, S sep) -> std::vector<std::string>
void split_str_into_multi(const std::string& str, const char* seps, std::vector<std::string>& result)
auto split_str_multi(const std::string& str, const char* seps = " \t") -> std::vector<std::string>
template<typename T, typename S, typename F>
auto join_str(T begin, T end, const S& sep, const F& getter) -> std::string
template<typename T, typename S>
auto join_str(T begin, T end, const S& sep) -> std::string
template<typename T, typename S, typename F>
auto join_str(const T& iterable, const S& sep, const F& getter) -> std::string
template<typename T, typename S>
auto join_str(const T& iterable, const S& sep) -> std::string
template<typename T, typename S>
void string_append_sep(std::string& str, S sep, const T& item)
void replace_all(std::string& s, const std::string& old, const std::string& new_)
template<class T>
auto in_vector(const T& x, const std::vector<T>& v) -> bool
template<typename F, typename T>
auto in_vector_f(F f, const std::vector<T>& v) -> bool
template<class T>
auto vector_end_ptr(std::vector<T>& v) -> T*
template<class T>
auto vector_end_ptr(const std::vector<T>& v) -> const T*
template<class T>
void vector_move_extend(std::vector<T>& dst, std::vector<T>&& src)
template<class T, typename F>
void vector_remove_if(std::vector<T>& v, F&& condition)
auto ialpha4_id(const char* s) -> int constexpr
auto ialpha3_id(const char* s) -> int constexpr

Variables

const typedef char elname_t