MPQC 2.3.1

- Main Page
- Related Pages
- Classes
- Files

- File List

coor.h
1 //
2 // coor.h
3 //
4 // Copyright (C) 1996 Limit Point Systems, Inc.
5 //
6 // Author: Curtis Janssen <cljanss@limitpt.com>
7 // Maintainer: LPS
8 //
9 // This file is part of the SC Toolkit.
10 //
11 // The SC Toolkit is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU Library General Public License as published by
13 // the Free Software Foundation; either version 2, or (at your option)
14 // any later version.
15 //
16 // The SC Toolkit is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU Library General Public License for more details.
20 //
21 // You should have received a copy of the GNU Library General Public License
22 // along with the SC Toolkit; see the file COPYING.LIB. If not, write to
23 // the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24 //
25 // The U.S. Government is granted a limited license as per AL 91-7.
26 //
27
28 #ifndef _chemistry_molecule_coor_h
29 #define _chemistry_molecule_coor_h
30
31 #ifdef __GNUC__
32 #pragma interface
33 #endif
34
35 #include <iostream>
36 #include <vector>
37
38 #include <math/scmat/matrix.h>
39 #include <math/optimize/transform.h>
40 #include <chemistry/molecule/molecule.h>
41
42 namespace sc {
43
46 class IntCoor: public SavableState {
47 protected:
48 // conversion factors from radians, bohr to the preferred units
49 static double bohr_conv;
50 static double radian_conv;
51 char *label_;
52 double value_;
53 public:
54 IntCoor(StateIn&);
55 IntCoor(const IntCoor&);
58 IntCoor(const char* label = 0);
75 IntCoor(const Ref<KeyVal>&);
76
77 virtual ~IntCoor();
78 void save_data_state(StateOut&);
79
81 virtual const char* label() const;
83 virtual double value() const;
85 virtual void set_value(double);
87 virtual double preferred_value() const;
89 virtual const char* ctype() const = 0;
91 virtual void print(std::ostream & o=ExEnv::out0()) const;
92 virtual void print_details(const Ref<Molecule> &, std::ostream& =ExEnv::out0()) const;
95 virtual double force_constant(Ref<Molecule>&) = 0;
97 virtual void update_value(const Ref<Molecule>&) = 0;
99 virtual void bmat(const Ref<Molecule>&,RefSCVector&bmat,double coef=1.0) = 0;
103 virtual int equivalent(Ref<IntCoor>&) = 0;
104 };
105
120 class SumIntCoor: public IntCoor {
121 private:
122 std::vector<double> coef_;
123 std::vector<Ref<IntCoor> > coor_;
124 public:
125 SumIntCoor(StateIn&);
128 SumIntCoor(const char *);
139 SumIntCoor(const Ref<KeyVal>&);
140
141 ~SumIntCoor();
142 void save_data_state(StateOut&);
143
145 int n();
148 void add(Ref<IntCoor>&,double coef);
150 void normalize();
151
152 // IntCoor overrides
154 double preferred_value() const;
156 const char* ctype() const;
158 void print_details(const Ref<Molecule> &, std::ostream& =ExEnv::out0()) const;
160 double force_constant(Ref<Molecule>&);
162 void update_value(const Ref<Molecule>&);
164 void bmat(const Ref<Molecule>&,RefSCVector&bmat,double coef = 1.0);
166 int equivalent(Ref<IntCoor>&);
167 };
168
189 class SetIntCoor: public SavableState {
190 private:
191 std::vector<Ref<IntCoor> > coor_;
192 public:
193 SetIntCoor();
194 SetIntCoor(StateIn&);
205 SetIntCoor(const Ref<KeyVal>&);
206
207 virtual ~SetIntCoor();
208 void save_data_state(StateOut&);
209
211 void add(const Ref<IntCoor>&);
213 void add(const Ref<SetIntCoor>&);
215 void pop();
217 void clear();
219 int n() const;
221 Ref<IntCoor> coor(int i) const;
223 virtual void fd_bmat(const Ref<Molecule>&,RefSCMatrix&);
225 virtual void bmat(const Ref<Molecule>&, RefSCMatrix&);
229 virtual void guess_hessian(Ref<Molecule>&,RefSymmSCMatrix&);
231 virtual void print_details(const Ref<Molecule> &,std::ostream& =ExEnv::out0()) const;
233 virtual void update_values(const Ref<Molecule>&);
235 virtual void values_to_vector(const RefSCVector&);
236 };
237
238
239 // ////////////////////////////////////////////////////////////////////////
240
241 class BitArrayLTri;
242
245 class IntCoorGen: public SavableState
246 {
247 protected:
248 Ref<Molecule> molecule_;
249
250 int linear_bends_;
251 int linear_lbends_;
252 int linear_tors_;
253 int linear_stors_;
254 int nextra_bonds_;
255 int *extra_bonds_;
256 double linear_bend_thres_;
257 double linear_tors_thres_;
258 double radius_scale_factor_;
259
260 void init_constants();
261
262 double cos_ijk(Molecule& m, int i, int j, int k);
263 int hterminal(Molecule& m, BitArrayLTri& bonds, int i);
264 int nearest_contact(int i, Molecule& m);
265
266 void add_bonds(const Ref<SetIntCoor>& list, BitArrayLTri& bonds, Molecule& m);
267 void add_bends(const Ref<SetIntCoor>& list, BitArrayLTri& bonds, Molecule& m);
268 void add_tors(const Ref<SetIntCoor>& list, BitArrayLTri& bonds, Molecule& m);
269 void add_out(const Ref<SetIntCoor>& list, BitArrayLTri& bonds, Molecule& m);
270 public:
274 IntCoorGen(const Ref<Molecule>&, int nextra=0, int *extra=0);
316 IntCoorGen(const Ref<KeyVal>&);
317 IntCoorGen(StateIn&);
318
319 ~IntCoorGen();
320
322 void save_data_state(StateOut&);
323
325 virtual void generate(const Ref<SetIntCoor>&);
326
328 virtual void print(std::ostream& out=ExEnv::out0()) const;
329 };
330
331
332 // ////////////////////////////////////////////////////////////////////////
333
334
338 class MolecularCoor: public SavableState
339 {
340 protected:
341 Ref<Molecule> molecule_;
342 RefSCDimension dnatom3_; // the number of atoms x 3
343 Ref<SCMatrixKit> matrixkit_; // used to construct matrices
344
345 int debug_;
346 public:
347 MolecularCoor(Ref<Molecule>&);
348 MolecularCoor(StateIn&);
365 MolecularCoor(const Ref<KeyVal>&);
366
367 virtual ~MolecularCoor();
368
369 void save_data_state(StateOut&);
370
373 RefSCDimension dim_natom3() { return dnatom3_; }
374
376 Ref<Molecule> molecule() const { return molecule_; }
377
379 virtual void print(std::ostream& =ExEnv::out0()) const = 0;
380 virtual void print_simples(std::ostream& =ExEnv::out0()) const = 0;
381
385 virtual RefSCDimension dim() = 0;
386
390 int to_cartesian(const RefSCVector&internal);
391 virtual int to_cartesian(const Ref<Molecule>&mol,
392 const RefSCVector&internal) = 0;
393
397 virtual int to_internal(RefSCVector&internal) = 0;
398
403 virtual int to_cartesian(RefSCVector&cartesian,RefSCVector&internal) = 0;
404
409 virtual int to_internal(RefSCVector&internal,RefSCVector&cartesian) = 0;
410
414 virtual int to_cartesian(RefSymmSCMatrix&cartesian,
415 RefSymmSCMatrix&internal) =0;
416
420 virtual int to_internal(RefSymmSCMatrix&internal,
421 RefSymmSCMatrix&cartesian) = 0;
422
425 virtual void guess_hessian(RefSymmSCMatrix&hessian) = 0;
426
429 virtual RefSymmSCMatrix inverse_hessian(RefSymmSCMatrix&) = 0;
430
432 virtual int nconstrained();
433
437 virtual Ref<NonlinearTransform> change_coordinates();
438
439 Ref<SCMatrixKit> matrixkit() const { return matrixkit_; }
440 };
441
442
445 class IntMolecularCoor: public MolecularCoor
446 {
447 protected:
448 Ref<IntCoorGen> generator_;
449
450 void form_K_matrix(RefSCDimension& dredundant,
451 RefSCDimension& dfixed,
452 RefSCMatrix& K,
453 int*& is_totally_symmetric);
454
455 RefSCDimension dim_; // corresponds to the number of variable coordinates
456 RefSCDimension dvc_; // the number of variable + constant coordinates
457
458 Ref<SetIntCoor> variable_; // the variable internal coordinates
459 Ref<SetIntCoor> constant_; // the constant internal coordinates
460
461 Ref<SetIntCoor> fixed_;
462 Ref<SetIntCoor> watched_;
463 Ref<IntCoor> followed_;
464
465 // these are all of the basic coordinates
466 Ref<SetIntCoor> bonds_;
467 Ref<SetIntCoor> bends_;
468 Ref<SetIntCoor> tors_;
469 Ref<SetIntCoor> outs_;
470 // these are provided by the user or generated coordinates that
471 // could not be assigned to any of the above catagories
472 Ref<SetIntCoor> extras_;
473
474 Ref<SetIntCoor> all_;
475
476 // Useful relationships
477 // variable_->n() + constant_->n() = 3N-6(5)
478 // symm_->n() + asymm_->n() = 3N-6(5)
479
480 int update_bmat_; // if 1 recompute the b matrix during to_cartesian
481 int only_totally_symmetric_; // only coors with tot. symm comp. are varied
482 double symmetry_tolerance_; // tol used to find coors with tot. sym. comp.
483 double simple_tolerance_; // tol used to see if a simple is included
484 double coordinate_tolerance_; // tol used to see if a coor is included
485 double cartesian_tolerance_; // tol used in intco->cart transformation
486 double scale_bonds_; // scale factor for bonds
487 double scale_bends_; // scale factor for bends
488 double scale_tors_; // scale factor for tors
489 double scale_outs_; // scale factor for outs
490
491 int nextra_bonds_;
492 int* extra_bonds_;
493
494 int given_fixed_values_; // if true make molecule have given fixed values
495
496 int decouple_bonds_;
497 int decouple_bends_;
498
499 int max_update_steps_;
500 double max_update_disp_;
501
505 virtual void init();
508 virtual void new_coords();
510 virtual void read_keyval(const Ref<KeyVal>&);
511
512 // control whether or not to print coordinates when they are formed
513 int form_print_simples_;
514 int form_print_variable_;
515 int form_print_constant_;
516 int form_print_molecule_;
517 public:
518 IntMolecularCoor(StateIn&);
519 IntMolecularCoor(Ref<Molecule>&mol);
624 IntMolecularCoor(const Ref<KeyVal>&);
625
626 virtual ~IntMolecularCoor();
627 void save_data_state(StateOut&);
628
631 virtual void form_coordinates(int keep_variable=0) =0;
632
635 virtual int all_to_cartesian(const Ref<Molecule> &,RefSCVector&internal);
638 virtual int all_to_internal(const Ref<Molecule> &,RefSCVector&internal);
639
642 virtual RefSCDimension dim();
643 virtual int to_cartesian(const Ref<Molecule> &,const RefSCVector&internal);
644 virtual int to_internal(RefSCVector&internal);
645 virtual int to_cartesian(RefSCVector&cartesian,RefSCVector&internal);
646 virtual int to_internal(RefSCVector&internal,RefSCVector&cartesian);
647 virtual int to_cartesian(RefSymmSCMatrix&cart,RefSymmSCMatrix&internal);
648 virtual int to_internal(RefSymmSCMatrix&internal,RefSymmSCMatrix&cart);
649 virtual void print(std::ostream& =ExEnv::out0()) const;
650 virtual void print_simples(std::ostream& =ExEnv::out0()) const;
651 virtual void print_variable(std::ostream& =ExEnv::out0()) const;
652 virtual void print_constant(std::ostream& =ExEnv::out0()) const;
653 int nconstrained();
654 };
655
656 // ///////////////////////////////////////////////////////////////////////
657
667 class SymmMolecularCoor: public IntMolecularCoor
668 {
669 protected:
670 // true if coordinates should be changed during optimization
671 int change_coordinates_;
672 // true if hessian should be transformed too (should always be true)
673 int transform_hessian_;
674 // max value for the condition number if coordinates can be changed
675 double max_kappa2_;
676
677 void init();
678 public:
679 SymmMolecularCoor(Ref<Molecule>&mol);
680 SymmMolecularCoor(StateIn&);
699 SymmMolecularCoor(const Ref<KeyVal>&);
700
701 virtual ~SymmMolecularCoor();
702 void save_data_state(StateOut&);
703
706 void form_coordinates(int keep_variable=0);
707
709 void guess_hessian(RefSymmSCMatrix&hessian);
711 RefSymmSCMatrix inverse_hessian(RefSymmSCMatrix&);
712
715 Ref<NonlinearTransform> change_coordinates();
716
717 void print(std::ostream& =ExEnv::out0()) const;
718 };
719
720 // ///////////////////////////////////////////////////////////////////////
721
724 class RedundMolecularCoor: public IntMolecularCoor
725 {
726
727 public:
728 RedundMolecularCoor(Ref<Molecule>&mol);
729 RedundMolecularCoor(StateIn&);
731 RedundMolecularCoor(const Ref<KeyVal>&);
732
733 virtual ~RedundMolecularCoor();
734 void save_data_state(StateOut&);
735
738 void form_coordinates(int keep_variable=0);
740 void guess_hessian(RefSymmSCMatrix&hessian);
742 RefSymmSCMatrix inverse_hessian(RefSymmSCMatrix&);
743 };
744
745 // ///////////////////////////////////////////////////////////////////////
746
751 class CartMolecularCoor: public MolecularCoor
752 {
753 private:
754 protected:
755 RefSCDimension dim_; // the number of atoms x 3
756
758 virtual void init();
759 public:
760 CartMolecularCoor(Ref<Molecule>&mol);
761 CartMolecularCoor(StateIn&);
763 CartMolecularCoor(const Ref<KeyVal>&);
764
765 virtual ~CartMolecularCoor();
766
767 void save_data_state(StateOut&);
768
770 virtual RefSCDimension dim();
771 virtual int to_cartesian(const Ref<Molecule>&,const RefSCVector&internal);
772 virtual int to_internal(RefSCVector&internal);
773 virtual int to_cartesian(RefSCVector&cartesian,RefSCVector&internal);
774 virtual int to_internal(RefSCVector&internal,RefSCVector&cartesian);
775 virtual int to_cartesian(RefSymmSCMatrix&cart,RefSymmSCMatrix&internal);
776 virtual int to_internal(RefSymmSCMatrix&internal,RefSymmSCMatrix&cart);
777 virtual void print(std::ostream& =ExEnv::out0()) const;
778 virtual void print_simples(std::ostream& =ExEnv::out0()) const;
779 void guess_hessian(RefSymmSCMatrix&hessian);
780 RefSymmSCMatrix inverse_hessian(RefSymmSCMatrix&);
781 };
782
783 }
784
785 #endif
786
787 // Local Variables:
788 // mode: c++
789 // c-file-style: "CLJ"
790 // End: