MolLib/Molecule.h

   1 /*
   2  *  Molecule.h
   3  *
   4  *  Created by Toshi Nagata on 06/03/11.
   5  *  Copyright 2006-2008 Toshi Nagata. All rights reserved.
   6  *
   7  This program is free software; you can redistribute it and/or modify
   8  it under the terms of the GNU General Public License as published by
   9  the Free Software Foundation version 2 of the License.
  10
  11  This program is distributed in the hope that it will be useful,
  12  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  GNU General Public License for more details.
  15 */
  16
  17 #ifndef __Molecule_h__
  18 #define __Molecule_h__
  19
  20 #include "Types.h"
  21 #include "Object.h"
  22 #include "IntGroup.h"
  23
  24 #include <stdio.h>
  25
  26 #ifdef __cplusplus
  27 extern "C" {
  28 #endif
  29
  30 #define ATOMS_MAX_SYMMETRY 12
  31 #define ATOMS_MAX_NUMBER 100000000  /*  Sufficiently large value  */
  32
  33 /*  Conversion between kcal/mol and internal energy unit (am*ang^2/fs^2, am = atomic mass) */
  34 #define KCAL2INTERNAL (4.184e-4)
  35 #define INTERNAL2KCAL (1.0/KCAL2INTERNAL)
  36 #define J2INTERNAL (1e-4)
  37 #define INTERNAL2J (1.0/J2INTERNAL)
  38
  39 #define BOLTZMANN (8.31441e-3*J2INTERNAL)
  40 #define PI 3.14159265358979
  41 #define PI2R 0.564189583547756    /*  1.0/sqrt(PI)  */
  42
  43 /*  Anisotropic thermal parameter  */
  44 typedef struct Aniso {
  45         Double  bij[6];    /*  b11, b22, b33, b12, b13, b23 (ORTEP type 0) */
  46         char has_bsig;     /*  Has sigma values?  */
  47         Double  bsig[6];   /*  sigma values  */
  48         Mat33  pmat;      /*  A 3x3 matrix whose three column vectors are the principal axes of the ellipsoid. Note: If the B matrix is not positive definite, the axis length corresponding to the negative eigenvalue is replaced with 0.001.  */
  49     Double eigval[3]; /*  Eigenvalues of the B matrix; this should be all non-negative */
  50 } Aniso;
  51
  52 /*  Symmetry operation  */
  53 /*  If periodic box is defined, dx/dy/dz denote multiples of the axes of the periodic box.
  54     Otherwise, dx/dy/dz denote offset to the x/y/z coordinates of the atoms.  */
  55 typedef struct Symop {
  56         signed int dx : 4;
  57         signed int dy : 4;
  58         signed int dz : 4;
  59         unsigned int sym : 8;
  60         unsigned int alive: 1;
  61 } Symop;
  62
  63 /*  Exflags  */
  64 enum {
  65         kAtomHiddenFlag = 1
  66 };
  67
  68 /*  Atom connection record  */
  69 /*  If nconnects <= ATOM_CONNECT_LIMIT, data[] field is used. Otherwise,
  70     memory is allocated by malloc().  */
  71 #define ATOM_CONNECT_LIMIT 6
  72 typedef struct AtomConnect {
  73         Int    count;  /*  Number of connections  */
  74         union {
  75                 Int *ptr;
  76                 Int data[ATOM_CONNECT_LIMIT];
  77         } u;
  78 } AtomConnect;
  79
  80 typedef struct PiAnchor {
  81         AtomConnect connect;
  82         Int ncoeffs;
  83         Double *coeffs;
  84 } PiAnchor;
  85
  86 /*  Atom record  */
  87 typedef struct Atom {
  88         Int    segSeq;
  89         char   segName[4];
  90         Int    resSeq;
  91         char   resName[4];
  92         char   aname[4];
  93         UInt   type;
  94         Double  charge;
  95         Double  weight;
  96         char   element[4];
  97         Int    atomicNumber;
  98         AtomConnect connect;
  99         Vector r;  /*  position  */
 100         Vector v;  /*  velocity  */
 101         Vector f;  /*  force  */
 102         Vector sigma;   /*  For crystallographic data only; sigma for each crystallographic coordinates  */
 103                                         /*  (Unlike r, these are not converted to the cartesian system)  */
 104         Double  occupancy;
 105         Double  tempFactor;
 106         Aniso  *aniso;
 107         Int    intCharge;
 108         Int    exflags;
 109         Int    nframes;  /*  Multiple frames  */
 110         Vector *frames;
 111         Symop  symop;    /*  For symmetry-expanded atom  */
 112         Int    symbase;  /*  The index of original atom for symmetry-expansion  */
 113         PiAnchor *anchor;  /*  Non-NULL if this atom is a pi-anchor  */
 114         Int    labelid;  /*  The label ID; 0 for no label  */
 115         short  wrap_dx, wrap_dy, wrap_dz; /*  Calculated by md_wrap_coordinates; used only in wrapped output.  */
 116         Double fix_force; /*  0: no fix, >0: fix at fix_pos with harmonic potential, <0: fix at fix_pos without force  */
 117         Vector fix_pos;
 118         Byte   mm_exclude;        /*  If nonzero, then this atom is excluded from MM/MD calculations  */
 119         Byte   periodic_exclude;  /*  If nonzero, then this atom is excluded from periodic calculations  */
 120         char   uff_type[6]; /*  UFF type string  */
 121 } Atom;
 122
 123 extern Int gSizeOfAtomRecord;
 124
 125 #define ATOM_AT_INDEX(p, i)  ((Atom *)((char *)(p) + (i) * gSizeOfAtomRecord))
 126 #define ATOM_NEXT(p)         ((Atom *)((char *)(p) + gSizeOfAtomRecord))
 127 #define ATOM_PREV(p)         ((Atom *)((char *)(p) - gSizeOfAtomRecord))
 128 #define SYMOP_ALIVE(s) ((s.dx || s.dy || s.dz || s.sym) != 0)
 129 #define SYMOP_EQUAL(s1, s2) (s1.dx == s2.dx && s1.dy == s2.dy && s1.dz == s2.dz && s1.sym == s2.sym)
 130 #define SYMMETRY_AT_INDEX(p, i) (*((i) == 0 ? &gIdentityTransform : &p[i]))
 131
 132 /*  atom.connects is a union entry, including direct data for nconnects <= ATOM_CONNECT_LIMIT
 133     and malloc()'ed entry for nconnects > ATOM_CONNECT_LIMIT. The following functions
 134         automatically take care of the memory allocation/deallocation.  */
 135 Int *AtomConnectData(AtomConnect *ac);
 136 void AtomConnectResize(AtomConnect *ac, Int nconnects);
 137 void AtomConnectInsertEntry(AtomConnect *ac, Int idx, Int connect);
 138 void AtomConnectDeleteEntry(AtomConnect *ac, Int idx);
 139
 140 #define ATOM_CONNECT_PTR(ac) ((ac)->count > ATOM_CONNECT_LIMIT ? (ac)->u.ptr : (ac)->u.data)
 141
 142 /*  Duplicate an atom. If dst is non-NULL, *src is copied to *dst and dst is returned. If dst is NULL, a new atom is allocated by malloc() and that atom is returned. It is the called's responsibility to release the returned memory. */
 143 extern Atom *AtomDuplicate(Atom *dst, const Atom *src);
 144
 145 /*  Duplicate an atom, except for the frame entry  */
 146 extern Atom *AtomDuplicateNoFrame(Atom *dst, const Atom *src);
 147
 148 /*  Clean the content of an atom record  */
 149 extern void AtomClean(Atom *ap);
 150
 151 /*  MolEnumerable type code  */
 152 enum {
 153         kAtomKind = 0,
 154         kBondKind = 1,
 155         kAngleKind = 2,
 156         kDihedralKind = 3,
 157         kImproperKind = 4,
 158         kResidueKind = 5,
 159         kEndKind
 160 };
 161
 162 /*  Enumerable class to access to atoms, bonds, etc.  */
 163 typedef struct MolEnumerable {
 164         struct Molecule *mol;
 165         int    kind;
 166 } MolEnumerable;
 167
 168 /*  Atom reference  */
 169 typedef struct AtomRef {
 170         struct Molecule *mol;
 171         int idx;
 172 } AtomRef;
 173
 174 /*  Crystallographic cell parameter (also used as periodic box in MD) */
 175 typedef struct XtalCell {
 176         Double  cell[6];     /*  a, b, c, alpha, beta, gamma (in degree)  */
 177         Double  rcell[6];    /*  Reciprocal cell  */
 178         Vector  axes[3];     /*  Cartesian unit vectors along the three axis  */
 179         Vector  origin;      /*  Cartesian origin of the periodic box  */
 180         char    flags[3];    /*  1 for periodic, 0 for non-periodic  */
 181         char    has_sigma;   /*  Has sigma?  */
 182         Transform tr;        /*  Crystal coord -> cartesian  */
 183         Transform rtr;       /*  Cartesian -> crystal coord  */
 184         Double  cellsigma[6];  /*  For crystallographic data; sigma for the cell parameters  */
 185 } XtalCell;
 186
 187 /*  3-Dimensional distribution  */
 188 typedef struct Cube {
 189         Int idn;             /*  Integer identifier (such as MO number)  */
 190         Vector origin;
 191         Vector dx, dy, dz;
 192         Int nx, ny, nz;
 193         Double *dp;          /*  Value for point (ix, iy, iz) is in dp[(ix*ny+iy)*nz+iz]  */
 194 } Cube;
 195
 196 /*  Gaussian orbital symmetry types  */
 197 enum {
 198         kGTOType_S,
 199         kGTOType_SP,
 200         kGTOType_P,
 201         kGTOType_D,
 202         kGTOType_D5,
 203         kGTOType_F,
 204         kGTOType_F7,
 205         kGTOType_G,
 206         kGTOType_G9,
 207         kGTOType_UU
 208 };
 209
 210 /*  Exponent/coefficient info for a single gaussian primitive  */
 211 typedef struct PrimInfo {
 212         Double A;            /*  Exponent  */
 213         Double C;            /*  Contraction coefficient  */
 214         Double Csp;          /*  P(S=P) contraction coefficient  */
 215 } PrimInfo;
 216
 217 /*  Gaussian orbital shell information  */
 218 typedef struct ShellInfo {
 219         signed char sym;     /*  Symmetry of the basis; S, P, ... */
 220         signed char ncomp;   /*  Number of components (S: 1, P: 3, SP: 4, etc.)  */
 221         signed char nprim;   /*  Number of primitives for this shell  */
 222         Int p_idx;           /*  Index to the PrimInfo (exponent/coefficient) table  */
 223         Int cn_idx;          /*  Index to the normalized (cached) contraction coefficient table  */
 224         Int a_idx;           /*  Index to the atom which this primitive belongs to */
 225         Int m_idx;           /*  Index to the MO matrix  */
 226 } ShellInfo;
 227
 228 /*  Basis set and MO information  */
 229 typedef struct BasisSet {
 230         Int nshells;         /*  Number of gaussian orbital shells  */
 231         ShellInfo *shells;   /*  Gaussian orbital shells  */
 232         Int npriminfos;      /*  Size of primitive information table  */
 233         PrimInfo *priminfos; /*  Primitive information table  */
 234         Int ncns;            /*  Number of normalized (cached) contraction coefficient values  */
 235         Double *cns;         /*  Normalized (cached) contraction coefficients; (up to 10 values for each primitive)  */
 236         Int natoms_bs;       /*  Number of atoms; separately cached here because MO info should be invariant during editing */
 237         Double *nuccharges;  /*  Nuclear charges (for ECP atoms)  */
 238         Int ne_alpha, ne_beta;  /*  Number of alpha/beta electrons  */
 239         Int rflag;           /*  0: UHF, 1: RHF, 2:ROHF  */
 240         Int ncomps;          /*  Number of AO components; equal to sum of shells[i].ncomp  */
 241         Int nmos;            /*  Number of MOs; equal to ncomps if close shell, ncomps*2 if open shell */
 242         Double *mo;          /*  MO matrix (mo[i][j] represents the j-th AO coefficient for the i-th MO)  */
 243                                                  /*  Memory are allocated for (2*nmos+1) entries; the last entry is for displaying arbitrary vector  */
 244         Double *moenergies;  /*  MO energies  */
 245         Double *scfdensities; /*  SCF densities; lower triangle of a symmetric matrix (size nmos*(nmos+1)/2)  */
 246         Int ncubes;          /*  Number of calculated MOs  */
 247         Cube **cubes;        /*  Calculated MOs (an array of pointers to Cubes)  */
 248 } BasisSet;
 249
 250 /*  Marching Cube (for drawing isosurface)  */
 251 typedef struct MCubePoint {
 252         Int key;       /*  key = ((ix*ny+iy)*nz+iz)*3+ii, ii=0/1/2 for x/y/z direction, respectively */
 253         float d;       /*  offset toward the direction; 0 <= d < 1  */
 254         float pos[3];  /*  cartesian coordinate of the point  */
 255         float grad[3]; /*  gradient vector  */
 256 } MCubePoint;
 257
 258 typedef struct MCube {
 259         char hidden;         /*  If non-zero, then this MCube is not drawn  */
 260         Int idn;             /*  MO number  */
 261         Vector origin;       /*  Cube origin */
 262         Double dx, dy, dz;   /*  Cube steps */
 263         Int nx, ny, nz;      /*  Cube dimension (must be multiples of 8)  */
 264         Double thres;        /*  Threshold value  */
 265         Double *dp;          /*  Value for point (ix, iy, iz) is in dp[(ix*ny+iy)*nz+iz]  */
 266         Int nradii;
 267         Double *radii;       /*  Estimated radius (with margin) for each atom  */
 268         Double expand;       /*  Expand the estimated radius by this value (default: 1.0)  */
 269         struct {
 270                 /*  Flags for cube (ix, iy, iz)-(ix+1, iy+1, iz+1). It is an 8-bit */
 271                 /*  integer representing whether the values at the 8 corners are */
 272                 /*  larger than the threshold value or not. As special cases,  */
 273                 /*  the values 0 and 255 (all corners are below or above the threshold) */
 274                 /*  are represented as 255, and the value 0 is used to indicate "yet undefined". */
 275                 unsigned char *fp;
 276                 /*  Cube points and triangles: for positive and negative surfaces  */
 277                 Int ncubepoints;
 278                 MCubePoint *cubepoints;
 279                 Int ntriangles;
 280                 Int *triangles;  /*  Triangles; indices to cubepoints[]  */
 281                 float rgba[4];   /*  Surface color  */
 282         } c[2];
 283 } MCube;
 284
 285 /*  Electrostatic potential  */
 286 typedef struct Elpot {
 287         Vector pos;
 288         Double esp;
 289 } Elpot;
 290
 291 /*  Properties (total energy etc.; specific for each frame)  */
 292 typedef struct MolProp {
 293         char *propname;
 294         Double *propvals;
 295 } MolProp;
 296
 297 /*  Molecule record  */
 298 typedef struct Molecule {
 299         Object base;
 300         Int    natoms;
 301         Atom   *atoms;
 302         Int    nbonds;
 303         Int    *bonds;       /*  The size of array is 2*nbonds  */
 304         Int    nangles;
 305         Int    *angles;      /*  The size of array is 3*nangles  */
 306         Int    ndihedrals;
 307         Int    *dihedrals;   /*  The size of array is 4*ndihedrals  */
 308         Int    nimpropers;
 309         Int    *impropers;   /*  The size of array is 4*nimpropers  */
 310         Int    nresidues;    /*  Number of residues; maximum residue number + 1 (because residue 0 is 'undefined residue')  */
 311         char   (*residues)[4];
 312         XtalCell   *cell;
 313         Int    nsyms;        /*  Symmetry operations; syms are always described in crystallographic units (even when the unit cell is not defined)  */
 314         Transform *syms;
 315
 316         IntGroup *selection;
 317         Int    nframes;      /*  The number of frames (>= 1). This is a cached value, and should be
 318                                                          recalculated from the atoms if it is -1  */
 319         Int    cframe;       /*  The current frame number  */
 320
 321         Int    nframe_cells;
 322         Vector *frame_cells; /*  The cell vectors for frames; (nframe_cells*4) array of Vectors  */
 323
 324         struct MainView *mview;  /*  Reference to the MainView object if present (no retain)  */
 325         Int    modifyCount;  /*  Internal counter for modification. This value is not to be modified
 326                                  manually; instead, call MoleculeIncrementModifyCount() whenever
 327                                                      modification is done, which also takes care necessary notification
 328                                                          to the other part of the application (system dependent)  */
 329
 330         struct MDArena *arena;  /*  Reference to the MDArena record during MM/MD run (no retain)  */
 331
 332         const char *path;     /*  The full path of the molecule, when this molecule is last saved to/loaded from file. Only used in the command-line version. (In GUI version, the path is obtained by the Document mechanism) */
 333
 334         /*  Information from the dcd files  */
 335         Int    startStep;     /*  the timestep for frame 0  */
 336         Int    stepsPerFrame; /*  the number of timesteps between neighboring frames  */
 337         Double psPerStep;     /*  picosecond per step  */
 338
 339         /*  Information for basis sets and MOs  */
 340         BasisSet *bset;
 341
 342         /*  Marching cube  */
 343         MCube *mcube;
 344
 345         /*  Electrostatic potential  */
 346         Int    nelpots;
 347         Elpot  *elpots;
 348
 349         /*  Properties  */
 350         Int    nmolprops;
 351         MolProp *molprops;
 352
 353         /*  Parameters specific for this molecule  */
 354         struct Parameter *par;
 355
 356         /*  Bond order (not to be used in MM/MD, but may be necessary to hold this info)  */
 357         Int    nbondOrders;
 358         Double *bondOrders;
 359
 360         /*  Flag to request rebuilding MD internal information  */
 361         Byte   needsMDRebuild;
 362
 363         /*  Flag to clear selection of the parameter table  */
 364         Byte   parameterTableSelectionNeedsClear;
 365
 366         /*  Flag to request copying coordinates to MD arena  */
 367         Byte   needsMDCopyCoordinates;
 368
 369         /*  Prohibit modification of the topology (to avoid interfering MD) */
 370         Byte   noModifyTopology;
 371
 372         /*  Flag to request aborting a subthread  */
 373         Byte   requestAbortThread;
 374
 375         /*  Flag to signal that a subthread is terminated  */
 376         Byte   threadTerminated;
 377
 378         /*  Mutex object. If non-NULL, it should be locked before modifying molecule  */
 379         void *mutex;
 380
 381         /*  Flag to prohibit modification from user interface  */
 382         Byte   dontModifyFromGUI;
 383
 384         /*  Ruby pointer (see ruby_bind.c)  */
 385         void *exmolobj;
 386         Byte exmolobjProtected;
 387
 388 } Molecule;
 389
 390 int strlen_limit(const char *s, int limit);
 391
 392 void BasisSetRelease(BasisSet *bset);
 393
 394 Molecule *MoleculeNew(void);
 395 int MoleculeLoadFile(Molecule *mp, const char *fname, const char *ftype, char **errbuf);
 396 int MoleculeLoadPsfFile(Molecule *mp, const char *fname, char **errbuf);
 397 int MoleculeLoadTepFile(Molecule *mp, const char *fname, char **errbuf);
 398 int MoleculeLoadShelxFile(Molecule *mp, const char *fname, char **errbuf);
 399 int MoleculeLoadGaussianFchkFile(Molecule *mp, const char *fname, char **errbuf);
 400 int MoleculeLoadMbsfFile(Molecule *mp, const char *fname, char **errbuf);
 401 Molecule *MoleculeNewWithName(const char *name);
 402 Molecule *MoleculeInitWithAtoms(Molecule *mp, const Atom *atoms, int natoms);
 403 Molecule *MoleculeInitWithMolecule(Molecule *mp2, Molecule *mp);
 404 void MoleculeSetName(Molecule *par, const char *name);
 405 const char *MoleculeGetName(Molecule *mp);
 406 void MoleculeSetPath(Molecule *mol, const char *fname);
 407 const char *MoleculeGetPath(Molecule *mol);
 408 Molecule *MoleculeWithName(const char *name);
 409 Molecule *MoleculeRetain(Molecule *mp);
 410 void MoleculeRelease(Molecule *mp);
 411 void MoleculeExchange(Molecule *mp1, Molecule *mp2);
 412
 413 int MoleculeAddGaussianOrbitalShell(Molecule *mol, Int a_idx, Int sym, Int nprims);
 414 int MoleculeAddGaussianPrimitiveCoefficients(Molecule *mol, Double exponent, Double contraction, Double contraction_sp);
 415 int MoleculeGetGaussianComponentInfo(Molecule *mol, Int comp_idx, Int *outAtomIdx, char *outLabel, Int *outShellIdx);
 416 int MoleculeSetMOCoefficients(Molecule *mol, Int idx, Double energy, Int ncomps, Double *coeffs);
 417 int MoleculeGetMOCoefficients(Molecule *mol, Int idx, Double *energy, Int *ncoeffs, Double **coeffs);
 418 int MoleculeSetMOInfo(Molecule *mol, Int rflag, Int ne_alpha, Int ne_beta);
 419
 420 void MoleculeIncrementModifyCount(Molecule *mp);
 421 void MoleculeClearModifyCount(Molecule *mp);
 422
 423 MolEnumerable *MolEnumerableNew(Molecule *mol, int kind);
 424 void MolEnumerableRelease(MolEnumerable *mseq);
 425 AtomRef *AtomRefNew(Molecule *mol, int idx);
 426 void AtomRefRelease(AtomRef *aref);
 427
 428 void MoleculeSetCell(Molecule *mp, Double a, Double b, Double c, Double alpha, Double beta, Double gamma, int convertCoordinates);
 429 void MoleculeSetAniso(Molecule *mp, int n1, int type, Double x11, Double x22, Double x33, Double x12, Double x13, Double x23, const Double *sigmap);
 430 void MoleculeSetAnisoBySymop(Molecule *mp, int idx);
 431 int MoleculeSetPeriodicBox(Molecule *mp, const Vector *ax, const Vector *ay, const Vector *az, const Vector *ao, const char *periodic, int convertCoordinates);
 432 int MoleculeCalculateCellFromAxes(XtalCell *cp, int calc_abc);
 433
 434 int MoleculeReadCoordinatesFromFile(Molecule *mp, const char *fname, const char *ftype, char **errbuf);
 435 int MoleculeReadCoordinatesFromPdbFile(Molecule *mp, const char *fname, char **errbuf);
 436 int MoleculeReadCoordinatesFromDcdFile(Molecule *mp, const char *fname, char **errbuf);
 437
 438 int MoleculeLoadGamessDatFile(Molecule *mol, const char *fname, char **errbuf);
 439
 440 int MoleculeReadExtendedInfo(Molecule *mp, const char *fname, char **errbuf);
 441 int MoleculeWriteExtendedInfo(Molecule *mp, const char *fname, char **errbuf);
 442
 443 int MoleculeWriteToFile(Molecule *mp, const char *fname, const char *ftype, char **errbuf);
 444 int MoleculeWriteToPsfFile(Molecule *mp, const char *fname, char **errbuf);
 445 int MoleculeWriteToPdbFile(Molecule *mp, const char *fname, char **errbuf);
 446 int MoleculeWriteToDcdFile(Molecule *mp, const char *fname, char **errbuf);
 447 int MoleculeWriteToTepFile(Molecule *mp, const char *fname, char **errbuf);
 448 int MoleculeWriteToMbsfFile(Molecule *mp, const char *fname, char **errbuf);
 449 void MoleculeDump(Molecule *mol);
 450
 451 int MoleculePrepareMDArena(Molecule *mol, int check_only, char **retmsg);
 452
 453 char *MoleculeSerialize(Molecule *mp, Int *outLength, Int *timep);
 454 Molecule *MoleculeDeserialize(const char *data, Int length, Int *timep);
 455
 456 void MoleculeCleanUpResidueTable(Molecule *mp);
 457 int MoleculeChangeNumberOfResidues(Molecule *mp, int nresidues);
 458 int MoleculeChangeResidueNumberWithArray(Molecule *mp, IntGroup *group, Int *resSeqs);
 459 int MoleculeChangeResidueNumber(Molecule *mp, IntGroup *group, int resSeq);
 460 int MoleculeOffsetResidueNumbers(Molecule *mp, IntGroup *group, int offset, int nresidues);
 461 int MoleculeChangeResidueNames(Molecule *mp, int argc, Int *resSeqs, char *names);
 462 int MoleculeMaximumResidueNumber(Molecule *mp, IntGroup *group);
 463 int MoleculeMinimumResidueNumber(Molecule *mp, IntGroup *group);
 464
 465 struct MolAction;
 466 #if defined(DEBUG)
 467         int MoleculeCheckSanity(Molecule *mp);
 468 #else
 469 #define MoleculeCheckSanity(mp)
 470 #endif
 471
 472 int MoleculeCreateAnAtom(Molecule *mp, const Atom *ap, int pos);
 473 int MoleculeMerge(Molecule *dst, Molecule *src, IntGroup *where, int resSeqOffset, Int *nactions, struct MolAction ***actions, Int forUndo);
 474 int MoleculeUnmerge(Molecule *src, Molecule **dstp, IntGroup *where, int resSeqOffset, Int *nactions, struct MolAction ***actions, Int forUndo);
 475 int MoleculeExtract(Molecule *src, Molecule **dstp, IntGroup *where, int dummyFlag);
 476 int MoleculeAddBonds(Molecule *mp, Int nbonds, const Int *bonds, IntGroup *where, Int autoGenerate);
 477 int MoleculeDeleteBonds(Molecule *mp, Int *bonds, IntGroup *where, Int **outRemoved, IntGroup **outRemovedPos);
 478 int MoleculeAssignBondOrders(Molecule *mp, const Double *orders, IntGroup *where);
 479 int MoleculeGetBondOrders(Molecule *mp, Double *outOrders, IntGroup *where);
 480 int MoleculeAddAngles(Molecule *mp, const Int *angles, IntGroup *where);
 481 int MoleculeDeleteAngles(Molecule *mp, Int *angles, IntGroup *where);
 482 int MoleculeAddDihedrals(Molecule *mp, const Int *dihedrals, IntGroup *where);
 483 int MoleculeDeleteDihedrals(Molecule *mp, Int *dihedrals, IntGroup *where);
 484 int MoleculeAddImpropers(Molecule *mp, const Int *impropers, IntGroup *where);
 485 int MoleculeDeleteImpropers(Molecule *mp, Int *impropers, IntGroup *where);
 486 int MoleculeLookupBond(Molecule *mp, Int n1, Int n2);
 487 int MoleculeLookupAngle(Molecule *mp, Int n1, Int n2, Int n3);
 488 int MoleculeLookupDihedral(Molecule *mp, Int n1, Int n2, Int n3, Int n4);
 489 int MoleculeLookupImproper(Molecule *mp, Int n1, Int n2, Int n3, Int n4);
 490
 491 Int MoleculeFindMissingAngles(Molecule *mol, Int **outAngles);
 492 Int MoleculeFindMissingDihedrals(Molecule *mol, Int **outDihedrals);
 493 Int MoleculeFindMissingImpropers(Molecule *mol, Int **outImpropers);
 494
 495 IntGroup *MoleculeSearchBondsIncludingAtoms(Molecule *mp, IntGroup *atomgroup);
 496 IntGroup *MoleculeSearchAnglesIncludingAtoms(Molecule *mp, IntGroup *atomgroup);
 497 IntGroup *MoleculeSearchDihedralsIncludingAtoms(Molecule *mp, IntGroup *atomgroup);
 498 IntGroup *MoleculeSearchImpropersIncludingAtoms(Molecule *mp, IntGroup *atomgroup);
 499
 500 IntGroup *MoleculeSearchBondsAcrossAtomGroup(Molecule *mp, IntGroup *atomgroup);
 501
 502 IntGroup *MoleculeSearchAnglesIncludingBond(Molecule *mp, int n1, int n2);
 503 IntGroup *MoleculeSearchDihedralsIncludingBond(Molecule *mp, int n1, int n2);
 504 IntGroup *MoleculeSearchImpropersIncludingBond(Molecule *mp, int n1, int n2);
 505
 506 int MoleculeLookupAtomInResidue(Molecule *mp, int n1, int resno);
 507 int MoleculeAnalyzeAtomName(const char *s, char *resName, int *resSeq, char *atomName);
 508 int MoleculeAtomIndexFromString(Molecule *mp, const char *s);
 509
 510 int MoleculeFindCloseAtoms(Molecule *mp, const Vector *vp, Double radius, Double limit, Int *outNbonds, Int **outBonds, Int triangle);
 511 int MoleculeGuessBonds(Molecule *mp, Double limit, Int *outNbonds, Int **outBonds);
 512 int MoleculeRebuildTablesFromConnects(Molecule *mp);
 513 int MoleculeAreAtomsConnected(Molecule *mol, int idx1, int idx2);
 514
 515 void MoleculeGetAtomName(Molecule *mp, int index, char *buf, int bufsize);
 516
 517 void MoleculeSetSelection(Molecule *mp, IntGroup *select);
 518 IntGroup *MoleculeGetSelection(Molecule *mp);
 519 void MoleculeSelectAtom(Molecule *mp, int n1, int extending);
 520 void MoleculeUnselectAtom(Molecule *mp, int n1);
 521 void MoleculeToggleSelectionOfAtom(Molecule *mp, int n1);
 522 int MoleculeIsAtomSelected(Molecule *mp, int n1);
 523 int MoleculeIsBondSelected(Molecule *mp, int n1, int n2);
 524 IntGroup *MoleculeModifySelectionByRemovingAtoms(Molecule *mp, IntGroup *selection, IntGroup *remove);
 525
 526 int MoleculeGetTransformForSymop(Molecule *mp, Symop symop, Transform *tf, int is_cartesian);
 527 int MoleculeGetSymopForTransform(Molecule *mp, const Transform tf, Symop *symop, int is_cartesian);
 528
 529 int MoleculeTransformBySymop(Molecule *mp, const Vector *vpin, Vector *vpout, Symop symop);
 530 int MoleculeAddExpandedAtoms(Molecule *mp, Symop symop, IntGroup *group, Int *indices, Int allowOverlap);
 531 int MoleculeAmendBySymmetry(Molecule *mp, IntGroup *group, IntGroup **groupout, Vector **vpout);
 532
 533 int MoleculeShowAllAtoms(Molecule *mp);
 534 int MoleculeShowReverse(Molecule *mp);
 535 int MoleculeHideAtoms(Molecule *mp, IntGroup *ig);
 536
 537 int MoleculeRenumberAtoms(Molecule *mp, const Int *new2old, Int *old2new_out, Int isize);
 538
 539 void MoleculeTransform(Molecule *mp, Transform tr, IntGroup *group);
 540 void MoleculeTranslate(Molecule *mp, const Vector *vp, IntGroup *group);
 541 void MoleculeRotate(Molecule *mp, const Vector *axis, Double angle, const Vector *center, IntGroup *group);
 542 int MoleculeCenterOfMass(Molecule *mp, Vector *center, IntGroup *group);
 543 int MoleculeBounds(Molecule *mp, Vector *min, Vector *max, IntGroup *group);
 544
 545 Int *MoleculeSearchEquivalentAtoms(Molecule *mol, IntGroup *ig);
 546
 547 void MoleculeAddExpansion(Molecule *mp, Vector dr, Int symop, IntGroup *group, Double limit);
 548 void MoleculeClearExpansion(Molecule *mp, IntGroup *group);
 549 void MoleculeRemoveExpansion(Molecule *mp, Vector dr, Int symop, IntGroup *group);
 550 void MoleculeAutoExpansion(Molecule *mp, const float *boxstart, const float *boxend, IntGroup *group, Double limit);
 551
 552 void MoleculeXtalToCartesian(Molecule *mp, Vector *dst, const Vector *src);
 553 void MoleculeCartesianToXtal(Molecule *mp, Vector *dst, const Vector *src);
 554 Double MoleculeMeasureBond(Molecule *mp, const Vector *vp1, const Vector *vp2);
 555 Double MoleculeMeasureAngle(Molecule *mp, const Vector *vp1, const Vector *vp2, const Vector *vp3);
 556 Double MoleculeMeasureDihedral(Molecule *mp, const Vector *vp1, const Vector *vp2, const Vector *vp3, const Vector *vp4);
 557
 558 IntGroup *MoleculeFragmentExcludingAtomGroup(Molecule *mp, int n1, IntGroup *exatoms);
 559 IntGroup *MoleculeFragmentExcludingAtoms(Molecule *mp, int n1, int argc, int *argv);
 560 IntGroup *MoleculeFragmentWithAtomGroups(Molecule *mp, IntGroup *inatoms, IntGroup *exatoms);
 561 int MoleculeIsFragmentDetachable(Molecule *mp, IntGroup *group, int *n1, int *n2);
 562 int MoleculeIsFragmentRotatable(Molecule *mp, IntGroup *group, int *n1, int *n2, IntGroup **rotGroup);
 563
 564 int MoleculeGetNumberOfFrames(Molecule *mp);
 565 int MoleculeInsertFrames(Molecule *mp, IntGroup *group, const Vector *inFrame, const Vector *inFrameCell);
 566 int MoleculeRemoveFrames(Molecule *mp, IntGroup *group, Vector *outFrame, Vector *outFrameCell);
 567 int MoleculeSelectFrame(Molecule *mp, int frame, int copyback);
 568 int MoleculeFlushFrames(Molecule *mp);
 569 int MoleculeReorderFrames(Molecule *mp, const Int *old_idx);
 570
 571 int MoleculeCreateProperty(Molecule *mp, const char *name);
 572 int MoleculeLookUpProperty(Molecule *mp, const char *name);
 573 int MoleculeDeletePropertyAtIndex(Molecule *mp, int idx);
 574 int MoleculeSetProperty(Molecule *mp, int idx, IntGroup *ig, const Double *values);
 575 int MoleculeGetProperty(Molecule *mp, int idx, IntGroup *ig, Double *outValues);
 576
 577 void MoleculeUpdatePiAnchorPositions(Molecule *mol);
 578 void MoleculeCalculatePiAnchorPosition(Molecule *mol, int idx);
 579 int MoleculeSetPiAnchorList(Molecule *mol, Int idx, Int nentries, Int *entries, Double *weights, Int *nUndoActions, struct MolAction ***undoActions);
 580
 581 int MoleculeCalcMO(Molecule *mp, Int mono, const Vector *op, const Vector *dxp, const Vector *dyp, const Vector *dzp, Int nx, Int ny, Int nz, int (*callback)(double progress, void *ref), void *ref);
 582 int MoleculeGetDefaultMOGrid(Molecule *mp, Int npoints, Vector *op, Vector *xp, Vector *yp, Vector *zp, Int *nx, Int *ny, Int *nz);
 583 const Cube *MoleculeGetCubeAtIndex(Molecule *mp, Int index);
 584 int MoleculeLookUpCubeWithMONumber(Molecule *mp, Int mono);
 585 int MoleculeClearCubeAtIndex(Molecule *mp, Int index);
 586 int MoleculeOutputCube(Molecule *mp, Int index, const char *fname, const char *comment);
 587
 588 MCube *MoleculeClearMCube(Molecule *mol, Int nx, Int ny, Int nz, const Vector *origin, Double dx, Double dy, Double dz);
 589 int MoleculeUpdateMCube(Molecule *mol, int idn);
 590 void MoleculeDeallocateMCube(MCube *mcube);
 591
 592 extern char *gMoleculePasteboardType;
 593 extern char *gParameterPasteboardType;
 594 extern char *gLoadSaveErrorMessage;
 595
 596 STUB void MoleculeRetainExternalObj(Molecule *mol);
 597 STUB void MoleculeReleaseExternalObj(Molecule *mol);
 598
 599 STUB int MoleculeCallback_writeToPasteboard(const char *type, const void *data, int length);
 600 STUB int MoleculeCallback_readFromPasteboard(const char *type, void **dptr, int *length);
 601 STUB int MoleculeCallback_isDataInPasteboard(const char *type);
 602
 603 STUB Molecule *MoleculeCallback_openNewMolecule(const char *fname);
 604 STUB void MoleculeCallback_notifyModification(Molecule *mp, int now_flag);
 605 STUB Molecule *MoleculeCallback_currentMolecule(void);
 606 STUB Molecule *MoleculeCallback_moleculeAtIndex(int idx);
 607 STUB Molecule *MoleculeCallback_moleculeAtOrderedIndex(int idx);
 608 STUB void MoleculeCallback_displayName(Molecule *mol, char *buf, int bufsize);
 609 STUB void MoleculeCallback_pathName(Molecule *mol, char *buf, int bufsize);
 610 STUB int MoleculeCallback_setDisplayName(Molecule *mol, const char *name);
 611
 612 STUB void MoleculeCallback_lockMutex(void *mutex);
 613 STUB void MoleculeCallback_unlockMutex(void *mutex);
 614 STUB void MoleculeCallback_disableModificationFromGUI(Molecule *mol);
 615 STUB void MoleculeCallback_enableModificationFromGUI(Molecule *mol);
 616
 617 STUB void MoleculeCallback_cannotModifyMoleculeDuringMDError(Molecule *mol);
 618
 619 STUB int MoleculeCallback_callSubProcessAsync(Molecule *mol, const char **argv, int (*callback)(Molecule *, int), int (*timerCallback)(Molecule *, int), FILE *output, FILE *errout);
 620
 621 /*  This is also defined in Molby_extern.h, but it may be called from functions in Molecule.c  */
 622 STUB int MyAppCallback_checkInterrupt(void);
 623
 624 void MoleculeLock(Molecule *mol);
 625 void MoleculeUnlock(Molecule *mol);
 626
 627 #if 0
 628 #define __MoleculeLock(mol) MoleculeLock(mol)
 629 #define __MoleculeUnlock(mol) MoleculeUnlock(mol)
 630 #else
 631 #define __MoleculeLock(mol)
 632 #define __MoleculeUnlock(mol)
 633 #endif
 634
 635 #ifdef __cplusplus
 636 }
 637 #endif
 638
 639 #endif /* __Molecule_h__ */