Update Colvars to version 2018-12-18
[namd.git] / src / colvarproxy_namd.h
1 // -*- c++ -*-
2
3 // This file is part of the Collective Variables module (Colvars).
4 // The original version of Colvars and its updates are located at:
5 // https://github.com/colvars/colvars
6 // Please update all Colvars source files before making any changes.
7 // If you wish to distribute your changes, please submit them to the
8 // Colvars repository at GitHub.
9
10 #ifndef COLVARPROXY_NAMD_H
11 #define COLVARPROXY_NAMD_H
12
13 #include "colvarproxy_namd_version.h"
14
15 #include "Vector.h"
16 #include "ResizeArray.h"
17 #include "NamdTypes.h"
18 #include "SimParameters.h"
19 #include "Lattice.h"
20 #include "GlobalMaster.h"
21 #include "Random.h"
22
23 #include "colvarmodule.h"
24 #include "colvarproxy.h"
25 #include "colvarvalue.h"
26
27 // For replica exchange
28 #include "converse.h"
29 #include "DataExchanger.h"
30
31 /// \brief Communication between colvars and NAMD (implementation of
32 /// \link colvarproxy \endlink)
33 class colvarproxy_namd : public colvarproxy, public GlobalMaster {
34
35 protected:
36
37   /// \brief Array of atom indices (relative to the colvarproxy arrays),
38   /// usedfor faster copy of atomic data
39   std::vector<int> atoms_map;
40
41   /// Pointer to the NAMD simulation input object
42   SimParameters const *simparams;
43
44   /// Self-explained
45   BigReal thermostat_temperature;
46
47   /// NAMD-style PRNG object
48   Random random;
49
50   /// How often NAMD is instructed to write state files
51   size_t restart_frequency_s;
52
53   bool first_timestep;
54   size_t previous_NAMD_step;
55
56   bool total_force_requested;
57
58   /// Used to submit restraint energy as MISC
59   SubmitReduction *reduction;
60
61   void init_tcl_pointers();
62
63 public:
64
65   friend class cvm::atom;
66
67   colvarproxy_namd();
68   ~colvarproxy_namd();
69
70   int setup();
71   int reset();
72
73   // synchronize the local arrays with requested or forced atoms
74   int update_atoms_map(AtomIDList::const_iterator begin,
75                        AtomIDList::const_iterator end);
76
77   void calculate();
78
79   void log(std::string const &message);
80   void error(std::string const &message);
81   void fatal_error(std::string const &message);
82   void exit(std::string const &message);
83   void add_energy(cvm::real energy);
84   void request_total_force(bool yesno);
85
86   bool total_forces_enabled() const
87   {
88     return total_force_requested;
89   }
90
91   int run_force_callback();
92   int run_colvar_callback(std::string const &name,
93                           std::vector<const colvarvalue *> const &cvcs,
94                           colvarvalue &value);
95   int run_colvar_gradient_callback(std::string const &name,
96                                    std::vector<const colvarvalue *> const &cvcs,
97                                    std::vector<cvm::matrix2d<cvm::real> > &gradient);
98
99   cvm::real unit_angstrom()
100   {
101     return 1.0;
102   }
103
104   cvm::real boltzmann()
105   {
106     return 0.001987191;
107   }
108
109   cvm::real temperature()
110   {
111     return thermostat_temperature;
112   }
113
114   cvm::real rand_gaussian()
115   {
116     return random.gaussian();
117   }
118
119   cvm::real dt()
120   {
121     return simparams->dt;
122   }
123
124 #if CMK_SMP && USE_CKLOOP
125   int smp_enabled()
126   {
127     if (b_smp_active) {
128       return COLVARS_OK;
129     }
130     return COLVARS_ERROR;
131   }
132
133   int smp_colvars_loop();
134
135   int smp_biases_loop();
136
137   int smp_biases_script_loop();
138
139   friend void calc_colvars_items_smp(int first, int last, void *result, int paramNum, void *param);
140   friend void calc_cv_biases_smp(int first, int last, void *result, int paramNum, void *param);
141   friend void calc_cv_scripted_forces(int paramNum, void *param);
142
143   int smp_thread_id()
144   {
145     return CkMyRank();
146   }
147
148   int smp_num_threads()
149   {
150     return CkMyNodeSize();
151   }
152
153 protected:
154
155   CmiNodeLock charm_lock_state;
156
157 public:
158
159   int smp_lock()
160   {
161     charm_lock_state = CmiCreateLock();
162     return COLVARS_OK;
163   }
164
165   int smp_trylock()
166   {
167     return COLVARS_NOT_IMPLEMENTED;
168   }
169
170   int smp_unlock()
171   {
172     CmiDestroyLock(charm_lock_state);
173     return COLVARS_OK;
174   }
175
176 #endif // #if CMK_SMP && USE_CKLOOP
177
178   // Replica communication functions.
179   bool replica_enabled() {
180 #if CMK_HAS_PARTITION
181     return true;
182 #else
183     return false;
184 #endif
185   }
186
187   int replica_index() {
188     return CmiMyPartition();
189   }
190
191   int replica_num() {
192     return CmiNumPartitions();
193   }
194
195   void replica_comm_barrier() {
196     replica_barrier();
197   }
198
199   int replica_comm_recv(char* msg_data, int buf_len, int src_rep) {
200     DataMessage *recvMsg = NULL;
201     replica_recv(&recvMsg, src_rep, CkMyPe());
202     CmiAssert(recvMsg != NULL);
203     int retval = recvMsg->size;
204     if (buf_len >= retval) {
205       memcpy(msg_data,recvMsg->data,retval);
206     } else {
207       retval = 0;
208     }
209     CmiFree(recvMsg);
210     return retval;
211   }
212
213   int replica_comm_send(char* msg_data, int msg_len, int dest_rep) {
214     replica_send(msg_data, msg_len, dest_rep, CkMyPe());
215     return msg_len;
216   }
217
218   int replica_comm_send()
219   {
220     return COLVARS_OK;
221   }
222
223   int replica_comm_async_send()
224   {
225     return COLVARS_OK;
226   }
227
228   inline size_t restart_frequency()
229   {
230     return restart_frequency_s;
231   }
232
233   int init_atom(int atom_number);
234   int check_atom_id(int atom_number);
235   int init_atom(cvm::residue_id const &residue,
236                 std::string const     &atom_name,
237                 std::string const     &segment_id);
238   int check_atom_id(cvm::residue_id const &residue,
239                     std::string const     &atom_name,
240                     std::string const     &segment_id);
241   void clear_atom(int index);
242
243   void update_atom_properties(int index);
244
245   cvm::rvector position_distance(cvm::atom_pos const &pos1,
246                                  cvm::atom_pos const &pos2) const;
247
248   int load_atoms(char const *filename,
249                  cvm::atom_group &atoms,
250                  std::string const &pdb_field,
251                  double const pdb_field_value = 0.0);
252
253   int load_coords(char const *filename,
254                   std::vector<cvm::atom_pos> &pos,
255                   const std::vector<int> &indices,
256                   std::string const &pdb_field,
257                   double const pdb_field_value = 0.0);
258
259
260   int scalable_group_coms()
261   {
262     return COLVARS_OK;
263   }
264   int init_atom_group(std::vector<int> const &atoms_ids);
265   void clear_atom_group(int index);
266   int update_group_properties(int index);
267
268   std::ostream * output_stream(std::string const &output_name,
269                                std::ios_base::openmode mode);
270   int flush_output_stream(std::ostream *os);
271   int close_output_stream(std::string const &output_name);
272   int backup_file(char const *filename);
273
274   char const *script_obj_to_str(unsigned char *obj);
275   std::vector<std::string> script_obj_to_str_vector(unsigned char *obj);
276 };
277
278
279 #endif