OOPSE/libmdtools/SRI.hpp

#ifndef _SRI_H_
#define _SRI_H_

#include <iostream>

#include "Atom.hpp"
#include "AbstractClasses.hpp"

// a little home-made vector structure

struct vect{
  double x;
  double y;
  double z;
  double length;
};

/************************************************************************
 * 
 * This section describes the base bond, bend, and torsion
 * classes. later these classes will be extended to good/evil ends.
 *
 ************************************************************************/

class Bond : public SRI{

public:
  Bond();
  virtual ~Bond();

  void calc_forces();
  int is_constrained() {return c_is_constrained;}
  Constraint *get_constraint() {return c_constraint;}
  void constrain(double bond_distance);

protected:
  virtual double bond_force(double r_ab) = 0;
  void set_atoms( Atom &, Atom & );

  int c_is_constrained;
  Constraint *c_constraint;
  Atom * c_p_a; /* atom a */
  Atom * c_p_b; /* atom b */
};


class Bend : public SRI{
 
public:
  Bend() {}
  virtual ~Bend() {}
  
  virtual void calc_forces();
  int is_constrained() {return 0;}
  Constraint *get_constraint() {return NULL;}
  void constrain(double bond_distance){} /*meaningless for bends */

protected:
  virtual double bend_force(double theta) = 0;
  void set_atoms( Atom &, Atom &, Atom & );

  Atom * c_p_a; /* atom a */
  Atom * c_p_b; /* atom b */
  Atom * c_p_c; /* atom c */
};

class Torsion : public SRI{

public:
  Torsion() {}
  virtual ~Torsion() {}

  void calc_forces();
  int is_constrained() {return 0;}
  Constraint *get_constraint() {return NULL;}
  void constrain(double bond_distance){} /*meaningless for torsions */

  
protected:

  void set_atoms(Atom &, Atom &, Atom &, Atom &);
  virtual double torsion_force(double cos_phi) = 0;

  Atom * c_p_a;
  Atom * c_p_b;
  Atom * c_p_c;
  Atom * c_p_d;
};

/**********************************************************************
 * 
 * These next classes are extensions of the base classes. These are
 * the actual objects which will be used in the simulation.
 *
 **********************************************************************/

class ConstrainedBond : public Bond{

public:
  ConstrainedBond( Atom &a, Atom &b, double constraint );
  ~ConstrainedBond() {}
  
  void printMe( void ){
    std::cerr << c_p_a->getType() << " - " << c_p_b->getType() 
              << ": " << c_p_a->getIndex() << " - " 
              << c_p_b->getIndex()
              << ", d0 = " << d0 << "\n";
  }

private:
  double bond_force( double r_ab ){ return 0.0; }
  double d0;
};

class HarmonicBond : public Bond{

public:
  HarmonicBond(Atom &a, Atom &b, double theR0, double theK0 );
  ~HarmonicBond(){}

  void printMe( void ){
    std::cerr << c_p_a->getType() << " - " << c_p_b->getType() 
              << ": " << c_p_a->getIndex() << " - " 
              << c_p_b->getIndex()
              << ", d0 = " << d0 << ", k0" << k0 <<"\n";
  }

  private:
  double bond_force( double r_ab );
  double d0;
  double k0;

};

class QuadraticBend : public Bend{

public:
  QuadraticBend( Atom &a, Atom &b, Atom &c );
  ~QuadraticBend(){}

  void setConstants( double the_c1, double the_c2, double the_c3, 
                     double the_Th0 );
  void printMe( void ){
    std::cerr << c_p_a->getType() << " - " << c_p_b->getType() << " - "
              << c_p_c->getType() << " : " 
              << c_p_a->getIndex() << " - " << c_p_b->getIndex() << " - "
              << c_p_c->getIndex() 
              <<", k1 = " << c1 << "; k2 = " << c2 
              << "; k3 = " << c3 << "; theta0 =" << theta0 << "\n";
  }

private:
  double bend_force( double theta );

  double c1, c2, c3;
  double theta0;
};

class GhostBend : public Bend{

public:
  GhostBend( Atom &a, Atom &b );
  ~GhostBend(){}

  void calc_forces( void );

  void setConstants( double the_c1, double the_c2, double the_c3, 
                     double the_Th0 );
  void printMe( void ){
    std::cerr << c_p_a->getType() << " - " << c_p_b->getType()
              << " : " 
              << c_p_a->getIndex() << " - " << c_p_b->getIndex() << " - "
              <<", k1 = " << c1 << "; k2 = " << c2 
              << "; k3 = " << c3 << "; theta0 =" << theta0 << "\n";
  }

private:
  double bend_force( double theta );

  double c1, c2, c3;
  double theta0;

  DirectionalAtom* atomB;
};

class CubicTorsion : public Torsion{

public:
  CubicTorsion( Atom &a, Atom &b, Atom &c, Atom &d );
  ~CubicTorsion() {}

  void setConstants( double the_k1, double the_k2, double the_k3,
                     double the_k4 );
  void printMe( void ){
    std::cerr << c_p_a->getType() << " - " << c_p_b->getType() << " - "
              << c_p_c->getType() << " - " << c_p_d->getType() << ": "
              << c_p_a->getIndex() << " - " << c_p_b->getIndex() << " - "
              << c_p_c->getIndex() << " - " << c_p_d->getIndex()
              << ", k1 = " << k1 << "; k2 = " << k2 
              << "; k3 = " << k3 << "; k4 =" << k4 << "\n";
  }
  
private:
  
  double torsion_force( double cos_phi );
  
  double k1, k2, k3, k4;
};
  
#endif
Revision:	564
Committed:	Tue Jun 24 19:57:54 2003 UTC (21 years ago) by mmeineke
File size:	4877 byte(s)
Log Message:	added Harmonic bod into the DUFF forcefield and BondExtensions.cpp
#	User	Rev	Content
1	mmeineke	377	#ifndef _SRI_H_
2			#define _SRI_H_
3
4			#include <iostream>
5
6			#include "Atom.hpp"
7			#include "AbstractClasses.hpp"
8
9			// a little home-made vector structure
10
11			struct vect{
12			double x;
13			double y;
14			double z;
15			double length;
16			};
17
18			/************************************************************************
19			*
20			* This section describes the base bond, bend, and torsion
21			* classes. later these classes will be extended to good/evil ends.
22			*
23			************************************************************************/
24
25			class Bond : public SRI{
26
27			public:
28			Bond();
29			virtual ~Bond();
30
31			void calc_forces();
32			int is_constrained() {return c_is_constrained;}
33			Constraint *get_constraint() {return c_constraint;}
34			void constrain(double bond_distance);
35
36			protected:
37			virtual double bond_force(double r_ab) = 0;
38			void set_atoms( Atom &, Atom & );
39
40			int c_is_constrained;
41			Constraint *c_constraint;
42			Atom * c_p_a; /* atom a */
43			Atom * c_p_b; /* atom b */
44			};
45
46
47			class Bend : public SRI{
48
49			public:
50			Bend() {}
51			virtual ~Bend() {}
52
53			virtual void calc_forces();
54			int is_constrained() {return 0;}
55			Constraint *get_constraint() {return NULL;}
56			void constrain(double bond_distance){} /meaningless for bends /
57
58			protected:
59			virtual double bend_force(double theta) = 0;
60			void set_atoms( Atom &, Atom &, Atom & );
61
62			Atom * c_p_a; /* atom a */
63			Atom * c_p_b; /* atom b */
64			Atom * c_p_c; /* atom c */
65			};
66
67			class Torsion : public SRI{
68
69			public:
70			Torsion() {}
71			virtual ~Torsion() {}
72
73			void calc_forces();
74			int is_constrained() {return 0;}
75			Constraint *get_constraint() {return NULL;}
76			void constrain(double bond_distance){} /meaningless for torsions /
77
78
79
80			protected:
81
82			void set_atoms(Atom &, Atom &, Atom &, Atom &);
83			virtual double torsion_force(double cos_phi) = 0;
84
85			Atom * c_p_a;
86			Atom * c_p_b;
87			Atom * c_p_c;
88			Atom * c_p_d;
89			};
90
91			/**********************************************************************
92			*
93			* These next classes are extensions of the base classes. These are
94			* the actual objects which will be used in the simulation.
95			*
96			**********************************************************************/
97
98			class ConstrainedBond : public Bond{
99
100			public:
101			ConstrainedBond( Atom &a, Atom &b, double constraint );
102			~ConstrainedBond() {}
103
104			void printMe( void ){
105			std::cerr << c_p_a->getType() << " - " << c_p_b->getType()
106	mmeineke	435	<< ": " << c_p_a->getIndex() << " - "
107			<< c_p_b->getIndex()
108	mmeineke	377	<< ", d0 = " << d0 << "\n";
109			}
110
111			private:
112			double bond_force( double r_ab ){ return 0.0; }
113			double d0;
114			};
115
116	mmeineke	564	class HarmonicBond : public Bond{
117
118			public:
119			HarmonicBond(Atom &a, Atom &b, double theR0, double theK0 );
120			~HarmonicBond(){}
121
122			void printMe( void ){
123			std::cerr << c_p_a->getType() << " - " << c_p_b->getType()
124			<< ": " << c_p_a->getIndex() << " - "
125			<< c_p_b->getIndex()
126			<< ", d0 = " << d0 << ", k0" << k0 <<"\n";
127			}
128
129			private:
130			double bond_force( double r_ab );
131			double d0;
132			double k0;
133
134			};
135
136	mmeineke	377	class QuadraticBend : public Bend{
137
138			public:
139			QuadraticBend( Atom &a, Atom &b, Atom &c );
140			~QuadraticBend(){}
141
142			void setConstants( double the_c1, double the_c2, double the_c3,
143			double the_Th0 );
144			void printMe( void ){
145			std::cerr << c_p_a->getType() << " - " << c_p_b->getType() << " - "
146			<< c_p_c->getType() << " : "
147			<< c_p_a->getIndex() << " - " << c_p_b->getIndex() << " - "
148			<< c_p_c->getIndex()
149			<<", k1 = " << c1 << "; k2 = " << c2
150			<< "; k3 = " << c3 << "; theta0 =" << theta0 << "\n";
151			}
152
153			private:
154			double bend_force( double theta );
155
156			double c1, c2, c3;
157			double theta0;
158			};
159
160			class GhostBend : public Bend{
161
162			public:
163			GhostBend( Atom &a, Atom &b );
164			~GhostBend(){}
165
166			void calc_forces( void );
167
168			void setConstants( double the_c1, double the_c2, double the_c3,
169			double the_Th0 );
170			void printMe( void ){
171			std::cerr << c_p_a->getType() << " - " << c_p_b->getType()
172			<< " : "
173			<< c_p_a->getIndex() << " - " << c_p_b->getIndex() << " - "
174			<<", k1 = " << c1 << "; k2 = " << c2
175			<< "; k3 = " << c3 << "; theta0 =" << theta0 << "\n";
176			}
177
178			private:
179			double bend_force( double theta );
180
181			double c1, c2, c3;
182			double theta0;
183
184			DirectionalAtom* atomB;
185			};
186
187			class CubicTorsion : public Torsion{
188
189			public:
190			CubicTorsion( Atom &a, Atom &b, Atom &c, Atom &d );
191			~CubicTorsion() {}
192
193			void setConstants( double the_k1, double the_k2, double the_k3,
194			double the_k4 );
195			void printMe( void ){
196			std::cerr << c_p_a->getType() << " - " << c_p_b->getType() << " - "
197	mmeineke	435	<< c_p_c->getType() << " - " << c_p_d->getType() << ": "
198			<< c_p_a->getIndex() << " - " << c_p_b->getIndex() << " - "
199			<< c_p_c->getIndex() << " - " << c_p_d->getIndex()
200	mmeineke	377	<< ", k1 = " << k1 << "; k2 = " << k2
201			<< "; k3 = " << k3 << "; k4 =" << k4 << "\n";
202			}
203
204			private:
205
206			double torsion_force( double cos_phi );
207
208			double k1, k2, k3, k4;
209			};
210
211			#endif