---

csymlib.h

Go to the documentation of this file.

/*
     csymlib.h: header file for csymlib.c
     Copyright (C) 2001  CCLRC, Martyn Winn

     This library is free software and is distributed under the terms and
     conditions of the CCP4 licence agreement as `Part 0' (Annex 2)
     software, which is version 2.1 of the GNU Lesser General Public
     Licence (LGPL) with the following additional clause:

        `You may also combine or link a "work that uses the Library" to
        produce a work containing portions of the Library, and distribute
        that work under terms of your choice, provided that you give
        prominent notice with each copy of the work that the specified
        version of the Library is used in it, and that you include or
        provide public access to the complete corresponding
        machine-readable source code for the Library including whatever
        changes were used in the work. (i.e. If you make changes to the
        Library you must distribute those, but you do not need to
        distribute source or object code to those portions of the work
        not covered by this licence.)'

     Note that this clause grants an additional right and does not impose
     any additional restriction, and so does not affect compatibility
     with the GNU General Public Licence (GPL). If you wish to negotiate
     other terms, please contact the maintainer.

     You can redistribute it and/or modify the library under the terms of
     the GNU Lesser General Public License as published by the Free Software
     Foundation; either version 2.1 of the License, or (at your option) any
     later version.

     This library is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.

     You should have received a copy of the CCP4 licence and/or GNU
     Lesser General Public License along with this library; if not, write
     to the CCP4 Secretary, Daresbury Laboratory, Warrington WA4 4AD, UK.
     The GNU Lesser General Public can also be obtained by writing to the
     Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
     MA 02111-1307 USA
*/

#ifndef __CSymLib__
#define __CSymLib__

static char rcsidhs[] = "$Id: csymlib_8h-source.html,v 1.8 2004/07/05 14:36:56 mdw Exp $";

/* note that definitions in ccp4_spg.h are within the CSym namespace */
#include "ccp4_spg.h"

#ifdef  __cplusplus
namespace CSym {
extern "C" {
#endif

CCP4SPG *ccp4spg_load_by_standard_num(const int numspg); 

CCP4SPG *ccp4spg_load_by_ccp4_num(const int ccp4numspg); 

CCP4SPG *ccp4spg_load_by_spgname(const char *spgname);

CCP4SPG *ccp4spg_load_by_ccp4_spgname(const char *ccp4spgname);

CCP4SPG * ccp4_spgrp_reverse_lookup(const int nsym1, const ccp4_symop *op1);

CCP4SPG *ccp4spg_load_spacegroup(const int numspg, const int ccp4numspg,
        const char *spgname, const char *ccp4spgname, 
        const int nsym1, const ccp4_symop *op1); 

void ccp4spg_mem_tidy(void);

int symfr_driver (const char *line, float rot[][4][4]);

void ccp4spg_free(CCP4SPG **sp);

void ccp4spg_register_by_ccp4_num(int numspg);

void ccp4spg_register_by_symops(int nops, float rsm[][4][4]);

int ccp4_spg_get_centering(const char *symbol_Hall, float cent_ops[4][3]);

int ccp4spg_load_laue(CCP4SPG* spacegroup, const int nlaue);

int ASU_1b   (const int h, const int k, const int l);

int ASU_2_m  (const int h, const int k, const int l);

int ASU_mmm  (const int h, const int k, const int l);

int ASU_4_m  (const int h, const int k, const int l);

int ASU_4_mmm(const int h, const int k, const int l);

int ASU_3b   (const int h, const int k, const int l);

int ASU_3bm  (const int h, const int k, const int l);

int ASU_3bmx (const int h, const int k, const int l);

int ASU_6_m  (const int h, const int k, const int l);

int ASU_6_mmm(const int h, const int k, const int l);

int ASU_m3b  (const int h, const int k, const int l);

int ASU_m3bm  (const int h, const int k, const int l);

char *ccp4spg_symbol_Hall(CCP4SPG* sp);

ccp4_symop ccp4_symop_invert( const ccp4_symop op1 );

int ccp4spg_name_equal(const char *spgname1, const char *spgname2);

int ccp4spg_name_equal_to_lib(const char *spgname_lib, const char *spgname_match);

char *ccp4spg_to_shortname(char *shortname, const char *longname);

void ccp4spg_name_de_colon(char *name);

int ccp4spg_pgname_equal(const char *pgname1, const char *pgname2);

ccp4_symop *ccp4spg_norm_trans(ccp4_symop *op);

int ccp4_spgrp_equal( int nsym1, const ccp4_symop *op1, int nsym2, const ccp4_symop *op2);

int ccp4_symop_code(ccp4_symop op);

int ccp4_int_compare( const void *p1, const void *p2 );

int ccp4spg_is_in_pm_asu(const CCP4SPG* sp, const int h, const int k, const int l);

int ccp4spg_is_in_asu(const CCP4SPG* sp, const int h, const int k, const int l);

int ccp4spg_put_in_asu(const CCP4SPG* sp, const int hin, const int kin, const int lin,
                       int *hout, int *kout, int *lout );

void ccp4spg_generate_indices(const CCP4SPG* sp, const int isym,
                  const int hin, const int kin, const int lin,
                              int *hout, int *kout, int *lout );

float ccp4spg_phase_shift(const int hin, const int kin, const int lin,
                          const float phasin, const float trans[3], const int isign);

int ccp4spg_do_chb(const float chb[3][3]);

void ccp4spg_set_centric_zones(CCP4SPG* sp);

int ccp4spg_is_centric(const CCP4SPG* sp, const int h, const int k, const int l);

int ccp4spg_check_centric_zone(const int nzone, const int h, const int k, const int l);

float ccp4spg_centric_phase(const CCP4SPG* sp, const int h, const int k, const int l);

void ccp4spg_print_centric_zones(const CCP4SPG* sp);

char *ccp4spg_describe_centric_zone(const int nzone, char *centric_zone);

void ccp4spg_set_epsilon_zones(CCP4SPG* sp);

int ccp4spg_get_multiplicity(const CCP4SPG* sp, const int h, const int k, const int l);

int ccp4spg_check_epsilon_zone(const int nzone, const int h, const int k, const int l);

void ccp4spg_print_epsilon_zones(const CCP4SPG* sp);

char *ccp4spg_describe_epsilon_zone(const int nzone, char *epsilon_zone);


int ccp4spg_is_sysabs(const CCP4SPG* sp, const int h, const int k, const int l);

int ccp4spg_generate_origins(const char *namspg, const int nsym, const float rsym[][4][4],
                             float origins[][3], int *polarx, int *polary, int *polarz,
                             const int iprint);

void ccp4spg_print_recip_spgrp(const CCP4SPG* sp);

void ccp4spg_print_recip_ops(const CCP4SPG* sp);

int range_to_limits(const char *range, float limits[2]);

void set_fft_grid(CCP4SPG* sp, const int nxmin, const int nymin, const int nzmin, 
                  const float sample, int *nx, int *ny, int *nz);

int all_factors_le_19(const int n);

int get_grid_sample(const int minsmp, const int nmul, const float sample);

int ccp4spg_check_symm_cell(int nsym, float rsym[][4][4], float cell[6]);

#ifdef __cplusplus
} }
#endif
#endif