Main Page Class Hierarchy Compound List File List Compound Members Related Pages

# simple.h

    00001
    00002 /* simple.h -- definition of the simple internal coordinate classes
    00003  *
    00004  *      THIS SOFTWARE FITS THE DESCRIPTION IN THE U.S. COPYRIGHT ACT OF A
    00005  *      "UNITED STATES GOVERNMENT WORK".  IT WAS WRITTEN AS A PART OF THE
    00006  *      AUTHOR'S OFFICIAL DUTIES AS A GOVERNMENT EMPLOYEE.  THIS MEANS IT
    00007  *      CANNOT BE COPYRIGHTED.  THIS SOFTWARE IS FREELY AVAILABLE TO THE
    00008  *      PUBLIC FOR USE WITHOUT A COPYRIGHT NOTICE, AND THERE ARE NO
    00009  *      RESTRICTIONS ON ITS USE, NOW OR SUBSEQUENTLY.
    00010  *
    00011  *  Author:
    00012  *      E. T. Seidl
    00013  *      Bldg. 12A, Rm. 2033
    00014  *      Computer Systems Laboratory
    00015  *      Division of Computer Research and Technology
    00016  *      National Institutes of Health
    00017  *      Bethesda, Maryland 20892
    00018  *      Internet: seidl@alw.nih.gov
    00019  *      February, 1993
    00020  */
    00021
    00022 #ifndef _intco_simple_h
    00023 #define _intco_simple_h
    00024
    00025 #ifdef __GNUC__
    00026 #pragma interface
    00027 #endif
    00028
    00029
    00030 #include <iostream>
    00031
    00032 #include <util/class/class.h>
    00033 #include <util/state/state.h>
    00034 #include <util/keyval/keyval.h>
    00035 #include <chemistry/molecule/molecule.h>
    00036 #include <chemistry/molecule/coor.h>
    00037
    00038 #include <math/scmat/vector3.h>
    00039
    00040 namespace sc {
    00041
    00042 // ////////////////////////////////////////////////////////////////////////
    00043
    00083 class SimpleCo : public IntCoor {
    00084   protected:
    00085     int natoms_;
    00086     int *atoms;
    00087
    00088   public:
    00089     SimpleCo();
    00094     SimpleCo(int,const char* =0);
    00096     SimpleCo(const Ref<KeyVal>&,int natom);
    00097
    00098     virtual ~SimpleCo();
    00099
    00101     int natoms() const;
    00103     int operator[](int i) const;
    00104
    00105     void save_data_state(StateOut&);
    00106     SimpleCo(StateIn&);
    00107
    00108     virtual int operator==(SimpleCo&);
    00109     int operator!=(SimpleCo&u);
    00110
    00111     // these IntCoor members are implemented in term of
    00112     // the calc_force_con and calc_intco members.
    00114     double force_constant(Ref<Molecule>&);
    00117     void update_value(const Ref<Molecule>&);
    00119     void bmat(const Ref<Molecule>&,RefSCVector&bmat,double coef = 1.0);
    00120
    00122     virtual double calc_force_con(Molecule&) = 0;
    00127     virtual double calc_intco(Molecule&, double* =0, double =1) = 0;
    00128
    00130     void print_details(const Ref<Molecule> &,
    00131                        std::ostream& = ExEnv::out0()) const;
    00132
    00135     int equivalent(Ref<IntCoor>&);
    00136   };
    00137
    00138
    00139
    00140 // ///////////////////////////////////////////////////////////////////////
    00141
    00142 #define SimpleCo_DECLARE(classname)                                           \
    00143   public:                                                                     \
    00144     virtual classname& operator=(const classname&);                           \
    00145     SimpleCo& operator=(const SimpleCo&);                                     \
    00146     double calc_force_con(Molecule&);                                         \
    00147     double calc_intco(Molecule&, double* =0, double =1);                      \
    00148     classname(StateIn&);                                                      \
    00149     void save_data_state(StateOut&);                                          \
    00150   private:
    00151
    00152 #define SimpleCo_IMPL_eq(classname)                                           \
    00153 SimpleCo& classname::operator=(const SimpleCo& c)                             \
    00154 {                                                                             \
    00155   classname *cp = dynamic_cast<classname*>((SimpleCo*)&c);                            \
    00156   if(cp) {                                                                    \
    00157       *this=*cp;                                                              \
    00158     }                                                                         \
    00159   else {                                                                      \
    00160       natoms_ = 0;                                                            \
    00161       atoms = 0;                                                              \
    00162     }                                                                         \
    00163                                                                               \
    00164   return *this;                                                               \
    00165   }
    00166
    00167 #define SimpleCo_IMPL_StateIn(classname)                                      \
    00168 classname::classname(StateIn&si):                                             \
    00169   SimpleCo(si)                                                                \
    00170 {                                                                             \
    00171 }
    00172
    00173 #define SimpleCo_IMPL_save_data_state(classname)                              \
    00174 void classname::save_data_state(StateOut&so)                                  \
    00175 {                                                                             \
    00176   SimpleCo::save_data_state(so);                                              \
    00177 }
    00178
    00179 #define SimpleCo_IMPL(classname)                \
    00180         SimpleCo_IMPL_eq(classname)             \
    00181         SimpleCo_IMPL_StateIn(classname)        \
    00182         SimpleCo_IMPL_save_data_state(classname)
    00183
    00184 // ///////////////////////////////////////////////////////////////////////
    00185
    00194 class StreSimpleCo : public SimpleCo {
    00195 SimpleCo_DECLARE(StreSimpleCo)
    00196   public:
    00197     StreSimpleCo();
    00198     StreSimpleCo(const StreSimpleCo&);
    00202     StreSimpleCo(const char*, int, int);
    00205     StreSimpleCo(const Ref<KeyVal>&);
    00206
    00207     ~StreSimpleCo();
    00208
    00210     const char * ctype() const;
    00211
    00213     double bohr() const;
    00215     double angstrom() const;
    00217     double preferred_value() const;
    00218   };
    00219
    00220 typedef StreSimpleCo Stre;
    00221
    00222 // ///////////////////////////////////////////////////////////////////////
    00223
    00224 static const double rtd = 180.0/3.14159265358979323846;
    00225
    00239 class BendSimpleCo : public SimpleCo {
    00240 SimpleCo_DECLARE(BendSimpleCo)
    00241   public:
    00242     BendSimpleCo();
    00243     BendSimpleCo(const BendSimpleCo&);
    00247     BendSimpleCo(const char*, int, int, int);
    00250     BendSimpleCo(const Ref<KeyVal>&);
    00251
    00252     ~BendSimpleCo();
    00253
    00255     const char * ctype() const;
    00256
    00258     double radians() const;
    00260     double degrees() const;
    00262     double preferred_value() const;
    00263   };
    00264
    00265 typedef BendSimpleCo Bend;
    00266
    00267 // ///////////////////////////////////////////////////////////////////////
    00268
    00297 class TorsSimpleCo : public SimpleCo {
    00298 SimpleCo_DECLARE(TorsSimpleCo)
    00299   public:
    00300     TorsSimpleCo();
    00301     TorsSimpleCo(const TorsSimpleCo&);
    00305     TorsSimpleCo(const char *refr, int, int, int, int);
    00308     TorsSimpleCo(const Ref<KeyVal>&);
    00309
    00310     ~TorsSimpleCo();
    00311
    00313     const char * ctype() const;
    00314
    00316     double radians() const;
    00318     double degrees() const;
    00320     double preferred_value() const;
    00321   };
    00322
    00323 typedef TorsSimpleCo Tors;
    00324
    00325 // ///////////////////////////////////////////////////////////////////////
    00326
    00358 class ScaledTorsSimpleCo : public SimpleCo {
    00359 SimpleCo_DECLARE(ScaledTorsSimpleCo)
    00360   private:
    00361     double old_torsion_;
    00362   public:
    00363     ScaledTorsSimpleCo();
    00364     ScaledTorsSimpleCo(const ScaledTorsSimpleCo&);
    00368     ScaledTorsSimpleCo(const char *refr, int, int, int, int);
    00371     ScaledTorsSimpleCo(const Ref<KeyVal>&);
    00372
    00373     ~ScaledTorsSimpleCo();
    00374
    00376     const char * ctype() const;
    00377
    00379     double radians() const;
    00381     double degrees() const;
    00383     double preferred_value() const;
    00384   };
    00385
    00386 typedef ScaledTorsSimpleCo ScaledTors;
    00387
    00388 // ///////////////////////////////////////////////////////////////////////
    00389
    00390 /*
    00391 The OutSimpleCo class describes an out-of-plane internal coordinate
    00392 of a molecule.  The input is described in the documentation of its parent
    00393 class SimpleCo.
    00394
    00395 Designating the four atoms as \f$a\f$, \f$b\f$, \f$c\f$, and \f$d\f$ and
    00396 their cartesian positions as \f$\bar{r}_a\f$, \f$\bar{r}_b\f$,
    00397 \f$\bar{r}_c\f$, and \f$\bar{r}_d\f$, the value of the coordinate,
    00398 \f$\tau\f$, is given by
    00399
    00400 \f[ \bar{u}_{ab} = \frac{\bar{r}_a - \bar{r}_b}{\| \bar{r}_a - \bar{r}_b \|}\f]
    00401 \f[ \bar{u}_{cb} = \frac{\bar{r}_b - \bar{r}_c}{\| \bar{r}_c - \bar{r}_b \|}\f]
    00402 \f[ \bar{u}_{db} = \frac{\bar{r}_c - \bar{r}_d}{\| \bar{r}_c - \bar{r}_b \|}\f]
    00403 \f[ \bar{n}_{bcd}= \frac{\bar{u}_{cb} \times \bar{u}_{db}}
    00404                      {\| \bar{u}_{cb} \times \bar{u}_{db} \|}\f]
    00405 \f[ \phi         = \arcsin ( \bar{u}_{ab} \cdot \bar{n}_{bcd} )\f]
    00406
    00407 */
    00408 class OutSimpleCo : public SimpleCo {
    00409 SimpleCo_DECLARE(OutSimpleCo)
    00410   public:
    00411     OutSimpleCo();
    00412     OutSimpleCo(const OutSimpleCo&);
    00417     OutSimpleCo(const char *refr, int, int, int, int);
    00420     OutSimpleCo(const Ref<KeyVal>&);
    00421
    00422     ~OutSimpleCo();
    00423
    00425     const char * ctype() const;
    00426
    00428     double radians() const;
    00430     double degrees() const;
    00432     double preferred_value() const;
    00433   };
    00434
    00435 typedef OutSimpleCo Out;
    00436
    00437 // ///////////////////////////////////////////////////////////////////////
    00438
    00460 class LinIPSimpleCo : public SimpleCo {
    00461 SimpleCo_DECLARE(LinIPSimpleCo)
    00462   private:
    00463     SCVector3 u2;
    00464   public:
    00465     LinIPSimpleCo();
    00466     LinIPSimpleCo(const LinIPSimpleCo&);
    00472     LinIPSimpleCo(const char *refr, int, int, int, const SCVector3 &u);
    00475     LinIPSimpleCo(const Ref<KeyVal>&);
    00476
    00477     ~LinIPSimpleCo();
    00478
    00480     const char * ctype() const;
    00481
    00483     double radians() const;
    00485     double degrees() const;
    00487     double preferred_value() const;
    00488   };
    00489
    00490 typedef LinIPSimpleCo LinIP;
    00491
    00492 // ///////////////////////////////////////////////////////////////////////
    00493
    00518 class LinOPSimpleCo : public SimpleCo {
    00519 SimpleCo_DECLARE(LinOPSimpleCo)
    00520   private:
    00521     SCVector3 u2;
    00522   public:
    00523     LinOPSimpleCo();
    00524     LinOPSimpleCo(const LinOPSimpleCo&);
    00530     LinOPSimpleCo(const char *refr, int, int, int, const SCVector3 &u);
    00533     LinOPSimpleCo(const Ref<KeyVal>&);
    00534
    00535     ~LinOPSimpleCo();
    00536
    00538     const char * ctype() const;
    00539
    00541     double radians() const;
    00543     double degrees() const;
    00545     double preferred_value() const;
    00546   };
    00547
    00548 typedef LinOPSimpleCo LinOP;
    00549
    00550 }
    00551
    00552 #endif /* _intco_simple_h */
    00553
    00554 // Local Variables:
    00555 // mode: c++
    00556 // c-file-style: "CLJ"
    00557 // End: