Rosetta 3.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
RotamerTrieBase.hh
Go to the documentation of this file.
1 // -*- mode:c++;tab-width:2;indent-tabs-mode:t;show-trailing-whitespace:t;rm-trailing-spaces:t -*-
2 // vi: set ts=2 noet:
3 //
4 // (c) Copyright Rosetta Commons Member Institutions.
5 // (c) This file is part of the Rosetta software suite and is made available under license.
6 // (c) The Rosetta software is developed by the contributing members of the Rosetta Commons.
7 // (c) For more information, see http://www.rosettacommons.org. Questions about this can be
8 // (c) addressed to University of Washington UW TechTransfer, email: license@u.washington.edu.
9 
10 /// @file core/scoring/trie/trie_vs_trie.hh
11 /// @brief
12 /// @author Andrew Leaver-Fay (aleaverfay@gmail.com)
13 
14 #ifndef INCLUDED_core_scoring_trie_RotamerTrieBase_hh
15 #define INCLUDED_core_scoring_trie_RotamerTrieBase_hh
16 
17 // Unit Headers
18 #include <core/scoring/trie/RotamerTrieBase.fwd.hh>
19 
20 #include <core/scoring/trie/RotamerTrie.fwd.hh>
21 #include <core/scoring/trie/TrieCountPairBase.fwd.hh>
22 
23 /// Package Headers
24 #include <core/scoring/etable/Etable.fwd.hh>
25 #include <core/scoring/etable/etrie/EtableAtom.fwd.hh>
26 #include <core/scoring/etable/etrie/CountPairData_1_1.fwd.hh>
27 #include <core/scoring/etable/etrie/CountPairData_1_2.fwd.hh>
28 #include <core/scoring/etable/etrie/CountPairData_1_3.fwd.hh>
29 #include <core/scoring/etable/etrie/CountPairDataGeneric.fwd.hh>
30 
31 #include <core/scoring/hackelec/ElecAtom.fwd.hh>
32 #include <core/scoring/hackelec/HackElecEnergy.fwd.hh>
33 
34 #include <core/scoring/hbonds/hbtrie/HBAtom.fwd.hh>
35 #include <core/scoring/hbonds/HBondEnergy.fwd.hh>
36 #include <core/scoring/hbonds/hbtrie/HBCPData.fwd.hh>
37 
38 #include <core/scoring/mm/mmtrie/MMEnergyTableAtom.fwd.hh>
39 #include <core/scoring/methods/MMLJEnergyInter.fwd.hh>
40 
41 // Project Headers
42 #include <core/conformation/AbstractRotamerTrie.hh>
43 
44 #include <core/scoring/etable/EtableEnergy.fwd.hh>
45 //XRW_B_T1
46 //#include <core/scoring/etable/CoarseEtableEnergy.fwd.hh>
47 //XRW_E_T1
48 #include <core/types.hh>
49 
50 // Utility Headers
51 #include <utility/pointer/ReferenceCount.hh>
52 #include <utility/vector1.fwd.hh>
53 
54 // ObjexxFCL Headers
55 #include <ObjexxFCL/FArray2D.fwd.hh>
56 
57 // STL Headers
58 #include <map>
59 
60 //Auto Headers
61 namespace core {
62 namespace scoring {
63 namespace trie {
64 
65 class RotamerTrieBase : public conformation::AbstractRotamerTrie
66 {
67 public:
68  virtual ~RotamerTrieBase() {}
69 
70  /// Useful Functions
71  virtual
72  void print() const = 0;
73 
74  //virtual
75  //void
76  //point_count_pair_data_at_residue( Size other_residue ) const = 0;
77 
78  /// The trie contains mutable data to record which peice of count-pair data it is
79  /// to use in the upcoming/current trie-vs-trie application. This data could be held
80  /// externally to the trie, and passed in as a parameter to the tvt call, but I believe
81  /// the code will be faster if there is no ambiguity over where to look for count pair
82  /// information.
83  ///
84  /// Depricated
85  //virtual
86  //void
87  //set_count_pair_data_to_use(
88  // Size connection_id
89  //) const = 0;
90 
91 public:
92  void
93  set_resid_2_connection_entry( Size resid, Size connid ) {
94  resid_2_connid_map_[ resid ] = connid - 1; // index from 0 -- adjust indices here.
95  }
96 
97  bool
98  connection_exists_to_residue( Size resid ) const {
99  return resid_2_connid_map_.find( resid ) != resid_2_connid_map_.end();
100  }
101 
102  Size
103  connection_id_for_residue( Size resid ) const {
104  /*
105  std::cout << "map contents: " << std::endl;
106  for ( std::map< Size, Size >::const_iterator iter = resid_2_connid_map_.begin(),
107  iter_end = resid_2_connid_map_.end(); iter != iter_end; ++iter ) {
108  std::cout << iter->first << " " << iter->second << std::endl;
109  }
110  */
111  return resid_2_connid_map_.find( resid )->second;
112  }
113 
114 
115  Size
116  get_count_pair_data_for_residue( Size other_residue ) const
117  {
118  if ( ! connection_exists_to_residue( other_residue ) ) return 0;
119 
120  Size connid = connection_id_for_residue( other_residue );
121  //std::cout << "other_residue: " << other_residue << " connid: " << connid << std::endl;
122  return connid;
123  }
124 
125 private:
126 
127  std::map< Size, Size > resid_2_connid_map_;
128 
129 public:
130  // Type resolution Function
131  virtual
132  void
133  trie_vs_trie(
134  RotamerTrieBase const & other,
135  TrieCountPairBase & cp,
136  etable::TableLookupEvaluator const & sfxn,
137  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
138  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
139  ) const = 0;
140 
141  virtual
142  void
143  resolve_trie_vs_trie(
144  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_1 > const & other,
145  TrieCountPairBase & cp,
146  etable::TableLookupEvaluator const & sfxn,
147  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
148  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
149  ) const = 0;
150 
151  virtual
152  void
153  resolve_trie_vs_trie(
154  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_2 > const & other,
155  TrieCountPairBase & cp,
156  etable::TableLookupEvaluator const & sfxn,
157  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
158  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
159  ) const = 0;
160 
161  virtual
162  void
163  resolve_trie_vs_trie(
164  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_3 > const & other,
165  TrieCountPairBase & cp,
166  etable::TableLookupEvaluator const & sfxn,
167  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
168  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
169  ) const = 0;
170 
171  virtual
172  void
173  resolve_trie_vs_trie(
174  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairDataGeneric > const & other,
175  TrieCountPairBase & cp,
176  etable::TableLookupEvaluator const & sfxn,
177  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
178  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
179  ) const = 0;
180 
181 
182  /// This function is called when the etable energy function get mixed up with non-etable tries.
183  /// It produces a utility_exit call.
184  virtual
185  void
186  resolve_trie_vs_trie(
187  RotamerTrieBase const & other,
188  TrieCountPairBase & cp,
189  etable::TableLookupEvaluator const & sfxn,
190  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
191  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
192  ) const = 0;
193 
194  /// Four trie-vs-path type resolution functions
195  virtual
196  void
197  trie_vs_path(
198  RotamerTrieBase const & other,
199  TrieCountPairBase & cp,
200  etable::TableLookupEvaluator const & sfxn,
201  utility::vector1< core::PackerEnergy > & pair_energy_vector,
202  utility::vector1< core::PackerEnergy > & temp_vector
203  ) const = 0;
204 
205 
206  virtual
207  void
208  resolve_trie_vs_path(
209  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_1 > const & other,
210  TrieCountPairBase & cp,
211  etable::TableLookupEvaluator const & sfxn,
212  utility::vector1< core::PackerEnergy > & pair_energy_vector,
213  utility::vector1< core::PackerEnergy > & temp_vector
214  ) const = 0;
215 
216 
217  virtual
218  void
219  resolve_trie_vs_path(
220  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_2 > const & other,
221  TrieCountPairBase & cp,
222  etable::TableLookupEvaluator const & sfxn,
223  utility::vector1< core::PackerEnergy > & pair_energy_vector,
224  utility::vector1< core::PackerEnergy > & temp_vector
225  ) const = 0;
226 
227 
228 
229  virtual
230  void
231  resolve_trie_vs_path(
232  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_3 > const & other,
233  TrieCountPairBase & cp,
234  etable::TableLookupEvaluator const & sfxn,
235  utility::vector1< core::PackerEnergy > & pair_energy_vector,
236  utility::vector1< core::PackerEnergy > & temp_vector
237  ) const = 0;
238 
239 
240  virtual
241  void
242  resolve_trie_vs_path(
243  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairDataGeneric > const & other,
244  TrieCountPairBase & cp,
245  etable::TableLookupEvaluator const & sfxn,
246  utility::vector1< core::PackerEnergy > & pair_energy_vector,
247  utility::vector1< core::PackerEnergy > & temp_vector
248  ) const = 0;
249 
250  /// This function is called when the etable energy function get mixed up with non-etable tries.
251  /// It produces a utility_exit call.
252  virtual
253  void
254  resolve_trie_vs_path(
255  RotamerTrieBase const & other,
256  TrieCountPairBase & cp,
257  etable::TableLookupEvaluator const & sfxn,
258  utility::vector1< core::PackerEnergy > & pair_energy_vector,
259  utility::vector1< core::PackerEnergy > & temp_vector
260  ) const = 0;
261 
262 
263  ////////////////////////////////////////////////////////////////////////////////////////////
264  //////////// the same methods again --- overloaded to accept a AnalyticEnergyEvaluator /////
265  ////////////////////////////////////////////////////////////////////////////////////////////
266 
267  virtual
268  void
269  trie_vs_trie(
270  RotamerTrieBase const & other,
271  TrieCountPairBase & cp,
272  etable::AnalyticEtableEvaluator const & sfxn,
273  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
274  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
275  ) const = 0;
276 
277  virtual
278  void
279  resolve_trie_vs_trie(
280  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_1 > const & other,
281  TrieCountPairBase & cp,
282  etable::AnalyticEtableEvaluator const & sfxn,
283  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
284  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
285  ) const = 0;
286 
287  virtual
288  void
289  resolve_trie_vs_trie(
290  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_2 > const & other,
291  TrieCountPairBase & cp,
292  etable::AnalyticEtableEvaluator const & sfxn,
293  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
294  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
295  ) const = 0;
296 
297  virtual
298  void
299  resolve_trie_vs_trie(
300  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_3 > const & other,
301  TrieCountPairBase & cp,
302  etable::AnalyticEtableEvaluator const & sfxn,
303  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
304  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
305  ) const = 0;
306 
307  virtual
308  void
309  resolve_trie_vs_trie(
310  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairDataGeneric > const & other,
311  TrieCountPairBase & cp,
312  etable::AnalyticEtableEvaluator const & sfxn,
313  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
314  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
315  ) const = 0;
316 
317 
318  /// This function is called when the coarse etable energy function get mixed up with non-etable tries.
319  /// It produces a utility_exit call.
320  virtual
321  void
322  resolve_trie_vs_trie(
323  RotamerTrieBase const & other,
324  TrieCountPairBase & cp,
325  etable::AnalyticEtableEvaluator const & sfxn,
326  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
327  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
328  ) const = 0;
329 
330  /// Four trie-vs-path type resolution functions
331  virtual
332  void
333  trie_vs_path(
334  RotamerTrieBase const & other,
335  TrieCountPairBase & cp,
336  etable::AnalyticEtableEvaluator const & sfxn,
337  utility::vector1< core::PackerEnergy > & pair_energy_vector,
338  utility::vector1< core::PackerEnergy > & temp_vector
339  ) const = 0;
340 
341 
342  virtual
343  void
344  resolve_trie_vs_path(
345  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_1 > const & other,
346  TrieCountPairBase & cp,
347  etable::AnalyticEtableEvaluator const & sfxn,
348  utility::vector1< core::PackerEnergy > & pair_energy_vector,
349  utility::vector1< core::PackerEnergy > & temp_vector
350  ) const = 0;
351 
352 
353  virtual
354  void
355  resolve_trie_vs_path(
356  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_2 > const & other,
357  TrieCountPairBase & cp,
358  etable::AnalyticEtableEvaluator const & sfxn,
359  utility::vector1< core::PackerEnergy > & pair_energy_vector,
360  utility::vector1< core::PackerEnergy > & temp_vector
361  ) const = 0;
362 
363 
364 
365  virtual
366  void
367  resolve_trie_vs_path(
368  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairData_1_3 > const & other,
369  TrieCountPairBase & cp,
370  etable::AnalyticEtableEvaluator const & sfxn,
371  utility::vector1< core::PackerEnergy > & pair_energy_vector,
372  utility::vector1< core::PackerEnergy > & temp_vector
373  ) const = 0;
374 
375  virtual
376  void
377  resolve_trie_vs_path(
378  RotamerTrie< etable::etrie::EtableAtom, etable::etrie::CountPairDataGeneric > const & other,
379  TrieCountPairBase & cp,
380  etable::AnalyticEtableEvaluator const & sfxn,
381  utility::vector1< core::PackerEnergy > & pair_energy_vector,
382  utility::vector1< core::PackerEnergy > & temp_vector
383  ) const = 0;
384 
385 
386  /// This function is called when the coarse etable energy function get mixed up with non-etable tries.
387  /// It produces a utility_exit call.
388  virtual
389  void
390  resolve_trie_vs_path(
391  RotamerTrieBase const & other,
392  TrieCountPairBase & cp,
393  etable::AnalyticEtableEvaluator const & sfxn,
394  utility::vector1< core::PackerEnergy > & pair_energy_vector,
395  utility::vector1< core::PackerEnergy > & temp_vector
396  ) const = 0;
397 
398  //// The same methods, again, for the HBondEnergies
399 
400  virtual
401  void
402  trie_vs_trie(
403  RotamerTrieBase const & other,
404  TrieCountPairBase & cp,
405  hbonds::HBondEnergy const & sfxn,
406  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
407  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
408  ) const = 0;
409 
410 
411  /// This function is called when hbond energy function get mixed up with non-hbond tries.
412  /// It produces a utility_exit call.
413  virtual
414  void
415  resolve_trie_vs_trie(
416  RotamerTrieBase const & other,
417  TrieCountPairBase & cp,
418  hbonds::HBondEnergy const & sfxn,
419  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
420  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
421  ) const = 0;
422 
423  virtual
424  void
425  resolve_trie_vs_trie(
426  RotamerTrie< hbonds::hbtrie::HBAtom, hbonds::hbtrie::HBCPData > const & other,
427  TrieCountPairBase & cp,
428  hbonds::HBondEnergy const & sfxn,
429  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
430  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
431  ) const = 0;
432 
433  virtual
434  void
435  trie_vs_path(
436  RotamerTrieBase const & other,
437  TrieCountPairBase & cp,
438  hbonds::HBondEnergy const & sfxn,
439  utility::vector1< core::PackerEnergy > & pair_energy_vector,
440  utility::vector1< core::PackerEnergy > & temp_vector
441  ) const = 0;
442 
443  /// This function is called when hbond energy function gets mixed up with non-hbond tries.
444  /// It produces a utility_exit call.
445  virtual
446  void
447  resolve_trie_vs_path(
448  RotamerTrieBase const & other,
449  TrieCountPairBase & cp,
450  hbonds::HBondEnergy const & sfxn,
451  utility::vector1< core::PackerEnergy > & pair_energy_vector,
452  utility::vector1< core::PackerEnergy > & temp_vector
453  ) const = 0;
454 
455 
456  virtual
457  void
458  resolve_trie_vs_path(
459  RotamerTrie< hbonds::hbtrie::HBAtom, hbonds::hbtrie::HBCPData > const & other,
460  TrieCountPairBase & cp,
461  hbonds::HBondEnergy const & sfxn,
462  utility::vector1< core::PackerEnergy > & pair_energy_vector,
463  utility::vector1< core::PackerEnergy > & temp_vector
464  ) const = 0;
465 
466 /// The same methods again, for Hack Elec E
467  virtual
468  void
469  trie_vs_trie(
470  RotamerTrieBase const & other,
471  TrieCountPairBase & cp,
472  hackelec::HackElecEnergy const & sfxn,
473  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
474  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
475  ) const = 0;
476 
477  virtual
478  void
479  resolve_trie_vs_trie(
480  RotamerTrie< hackelec::ElecAtom, etable::etrie::CountPairData_1_1 > const & other,
481  TrieCountPairBase & cp,
482  hackelec::HackElecEnergy const & sfxn,
483  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
484  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
485  ) const = 0;
486 
487  virtual
488  void
489  resolve_trie_vs_trie(
490  RotamerTrie< hackelec::ElecAtom, etable::etrie::CountPairData_1_2 > const & other,
491  TrieCountPairBase & cp,
492  hackelec::HackElecEnergy const & sfxn,
493  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
494  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
495  ) const = 0;
496 
497  virtual
498  void
499  resolve_trie_vs_trie(
500  RotamerTrie< hackelec::ElecAtom, etable::etrie::CountPairData_1_3 > const & other,
501  TrieCountPairBase & cp,
502  hackelec::HackElecEnergy const & sfxn,
503  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
504  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
505  ) const = 0;
506 
507  virtual
508  void
509  resolve_trie_vs_trie(
510  RotamerTrie< hackelec::ElecAtom, etable::etrie::CountPairDataGeneric > const & other,
511  TrieCountPairBase & cp,
512  hackelec::HackElecEnergy const & sfxn,
513  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
514  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
515  ) const = 0;
516 
517 
518  /// This function is called when the etable energy function get mixed up with non-etable tries.
519  /// It produces a utility_exit call.
520  virtual
521  void
522  resolve_trie_vs_trie(
523  RotamerTrieBase const & other,
524  TrieCountPairBase & cp,
525  hackelec::HackElecEnergy const & sfxn,
526  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
527  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
528  ) const = 0;
529 
530  /// Four trie-vs-path type resolution functions
531  virtual
532  void
533  trie_vs_path(
534  RotamerTrieBase const & other,
535  TrieCountPairBase & cp,
536  hackelec::HackElecEnergy const & sfxn,
537  utility::vector1< core::PackerEnergy > & pair_energy_vector,
538  utility::vector1< core::PackerEnergy > & temp_vector
539  ) const = 0;
540 
541 
542  virtual
543  void
544  resolve_trie_vs_path(
545  RotamerTrie< hackelec::ElecAtom, etable::etrie::CountPairData_1_1 > const & other,
546  TrieCountPairBase & cp,
547  hackelec::HackElecEnergy const & sfxn,
548  utility::vector1< core::PackerEnergy > & pair_energy_vector,
549  utility::vector1< core::PackerEnergy > & temp_vector
550  ) const = 0;
551 
552 
553  virtual
554  void
555  resolve_trie_vs_path(
556  RotamerTrie< hackelec::ElecAtom, etable::etrie::CountPairData_1_2 > const & other,
557  TrieCountPairBase & cp,
558  hackelec::HackElecEnergy const & sfxn,
559  utility::vector1< core::PackerEnergy > & pair_energy_vector,
560  utility::vector1< core::PackerEnergy > & temp_vector
561  ) const = 0;
562 
563 
564 
565  virtual
566  void
567  resolve_trie_vs_path(
568  RotamerTrie< hackelec::ElecAtom, etable::etrie::CountPairData_1_3 > const & other,
569  TrieCountPairBase & cp,
570  hackelec::HackElecEnergy const & sfxn,
571  utility::vector1< core::PackerEnergy > & pair_energy_vector,
572  utility::vector1< core::PackerEnergy > & temp_vector
573  ) const = 0;
574 
575  virtual
576  void
577  resolve_trie_vs_path(
578  RotamerTrie< hackelec::ElecAtom, etable::etrie::CountPairDataGeneric > const & other,
579  TrieCountPairBase & cp,
580  hackelec::HackElecEnergy const & sfxn,
581  utility::vector1< core::PackerEnergy > & pair_energy_vector,
582  utility::vector1< core::PackerEnergy > & temp_vector
583  ) const = 0;
584 
585 
586 
587  /// This function is called when non-hackelec tries get mixed up with the HackElecEnergy function
588  /// It produces a utility_exit call.
589  virtual
590  void
591  resolve_trie_vs_path(
592  RotamerTrieBase const & other,
593  TrieCountPairBase & cp,
594  hackelec::HackElecEnergy const & sfxn,
595  utility::vector1< core::PackerEnergy > & pair_energy_vector,
596  utility::vector1< core::PackerEnergy > & temp_vector
597  ) const = 0;
598 
599 ///////////////////////////////////////////////////////////////////////////////////////
600 //////////// the same methods again --- overloaded for MMLJEnergyTable ////////////////
601 ///////////////////////////////////////////////////////////////////////////////////////
602 
603  virtual
604  void
605  trie_vs_trie(
606  RotamerTrieBase const & other,
607  TrieCountPairBase & cp,
608  methods::MMLJEnergyInter const & sfxn,
609  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
610  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
611  ) const = 0;
612 
613  virtual
614  void
615  resolve_trie_vs_trie(
616  RotamerTrie< core::scoring::mm::mmtrie::MMEnergyTableAtom, etable::etrie::CountPairData_1_1 > const & other,
617  TrieCountPairBase & cp,
618  methods::MMLJEnergyInter const & sfxn,
619  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
620  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
621  ) const = 0;
622 
623  virtual
624  void
625  resolve_trie_vs_trie(
626  RotamerTrie< core::scoring::mm::mmtrie::MMEnergyTableAtom, etable::etrie::CountPairData_1_2 > const & other,
627  TrieCountPairBase & cp,
628  methods::MMLJEnergyInter const & sfxn,
629  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
630  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
631  ) const = 0;
632 
633  virtual
634  void
635  resolve_trie_vs_trie(
636  RotamerTrie< core::scoring::mm::mmtrie::MMEnergyTableAtom, etable::etrie::CountPairData_1_3 > const & other,
637  TrieCountPairBase & cp,
638  methods::MMLJEnergyInter const & sfxn,
639  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
640  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
641  ) const = 0;
642 
643  /// This function is called when the mm lj inter energy function get mixed up with other tries.
644  /// It produces a utility_exit call.
645  virtual
646  void
647  resolve_trie_vs_trie(
648  RotamerTrieBase const & other,
649  TrieCountPairBase & cp,
650  methods::MMLJEnergyInter const & sfxn,
651  ObjexxFCL::FArray2D< core::PackerEnergy > & pair_energy_table,
652  ObjexxFCL::FArray2D< core::PackerEnergy > & temp_table
653  ) const = 0;
654 
655  /// Four trie-vs-path type resolution functions
656  virtual
657  void
658  trie_vs_path(
659  RotamerTrieBase const & other,
660  TrieCountPairBase & cp,
661  methods::MMLJEnergyInter const & sfxn,
662  utility::vector1< core::PackerEnergy > & pair_energy_vector,
663  utility::vector1< core::PackerEnergy > & temp_vector
664  ) const = 0;
665 
666 
667  virtual
668  void
669  resolve_trie_vs_path(
670  RotamerTrie< core::scoring::mm::mmtrie::MMEnergyTableAtom, etable::etrie::CountPairData_1_1 > const & other,
671  TrieCountPairBase & cp,
672  methods::MMLJEnergyInter const & sfxn,
673  utility::vector1< core::PackerEnergy > & pair_energy_vector,
674  utility::vector1< core::PackerEnergy > & temp_vector
675  ) const = 0;
676 
677 
678  virtual
679  void
680  resolve_trie_vs_path(
681  RotamerTrie< core::scoring::mm::mmtrie::MMEnergyTableAtom, etable::etrie::CountPairData_1_2 > const & other,
682  TrieCountPairBase & cp,
683  methods::MMLJEnergyInter const & sfxn,
684  utility::vector1< core::PackerEnergy > & pair_energy_vector,
685  utility::vector1< core::PackerEnergy > & temp_vector
686  ) const = 0;
687 
688 
689 
690  virtual
691  void
692  resolve_trie_vs_path(
693  RotamerTrie< core::scoring::mm::mmtrie::MMEnergyTableAtom, etable::etrie::CountPairData_1_3 > const & other,
694  TrieCountPairBase & cp,
695  methods::MMLJEnergyInter const & sfxn,
696  utility::vector1< core::PackerEnergy > & pair_energy_vector,
697  utility::vector1< core::PackerEnergy > & temp_vector
698  ) const = 0;
699 
700  /// This function is called when the mm lj inter energy function get mixed up with other tries.
701  /// It produces a utility_exit call.
702  virtual
703  void
704  resolve_trie_vs_path(
705  RotamerTrieBase const & other,
706  TrieCountPairBase & cp,
707  methods::MMLJEnergyInter const & sfxn,
708  utility::vector1< core::PackerEnergy > & pair_energy_vector,
709  utility::vector1< core::PackerEnergy > & temp_vector
710  ) const = 0;
711 
712 
713 };
714 
715 
716 } // namespace trie
717 } // namespace scoring
718 } // namespace core
719 
720 #endif
Generated on Sat Jun 1 2013 11:40:20 for Rosetta 3.5 by   doxygen 1.8.4