RDKit
Open-source cheminformatics and machine learning.
RandomSampleAllBBs.h
Go to the documentation of this file.
1 //
2 // Copyright (c) 2015, Novartis Institutes for BioMedical Research Inc.
3 // All rights reserved.
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following
13 // disclaimer in the documentation and/or other materials provided
14 // with the distribution.
15 // * Neither the name of Novartis Institutes for BioMedical Research Inc.
16 // nor the names of its contributors may be used to endorse or promote
17 // products derived from this software without specific prior written
18 // permission.
19 //
20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 //
32 
33 #include <RDGeneral/export.h>
34 #ifndef RGROUP_RANDOM_SAMPLE_ALLBBS_H
35 #define RGROUP_RANDOM_SAMPLE_ALLBBS_H
36 
38 #include <boost/random.hpp>
39 #include <boost/random/uniform_int_distribution.hpp>
40 #include <sstream>
41 
42 namespace RDKit {
43 //! RandomSampleAllBBsStrategy
44 //! Randomly sample rgroup indices
45 
46 //! This is a class for randomly enumerating reagents that ensures all reagents
47 // are sampled.
48 /*!
49  basic usage:
50 
51  \verbatim
52  std::vector<MOL_SPTR_VECT> bbs;
53  bbs.push_back( bbs_for_reactants_1 );
54  bbs.push_back( bbs_for_reactants_2 );
55 
56  RandomSampleAllBBsStrategy rgroups;
57  rgroups.initialize(rxn, bbs);
58  for(size_t i=0; i<num_samples && rgroups; ++i) {
59  MOL_SPTR_VECT rvect = getReactantsFromRGroups(bbs, rgroups.next());
60  std::vector<MOL_SPTR_VECT> lprops = rxn.RunReactants(rvect);
61  ...
62  }
63  \endverbatim
64 
65  See EnumerationStrategyBase for more details and usage.
66 */
67 
69  : public EnumerationStrategyBase {
70  boost::uint64_t m_numPermutationsProcessed;
71  size_t m_offset;
72  size_t m_maxoffset;
73 
74  boost::minstd_rand m_rng;
75  std::vector<boost::random::uniform_int_distribution<>> m_distributions;
76 
77  public:
80  m_numPermutationsProcessed(0),
81  m_offset(0),
82  m_maxoffset(0),
83  m_rng(),
84  m_distributions() {
85  for (size_t i = 0; i < m_permutation.size(); ++i) {
86  m_distributions.push_back(
87  boost::random::uniform_int_distribution<>(0, m_permutation[i] - 1));
88  }
89  }
91 
93  const EnumerationTypes::BBS &) {
94  m_distributions.clear();
95  m_permutation.resize(m_permutationSizes.size());
96  m_permutationSizes = m_permutationSizes;
97  m_offset = 0;
98  m_maxoffset =
99  *std::max_element(m_permutationSizes.begin(), m_permutationSizes.end());
100  for (size_t i = 0; i < m_permutationSizes.size(); ++i) {
101  m_distributions.push_back(boost::random::uniform_int_distribution<>(
102  0, m_permutationSizes[i] - 1));
103  }
104 
105  m_numPermutationsProcessed = 0;
106  }
107 
108  virtual const char *type() const { return "RandomSampleAllBBsStrategy"; }
109 
110  //! The current permutation {r1, r2, ...}
111  virtual const EnumerationTypes::RGROUPS &next() {
112  if (m_offset >= m_maxoffset) {
113  for (size_t i = 0; i < m_permutation.size(); ++i) {
114  m_permutation[i] = m_distributions[i](m_rng);
115  }
116  m_offset = 0;
117  } else {
118  for (size_t i = 0; i < m_permutation.size(); ++i) {
119  m_permutation[i] = (m_permutation[i] + 1) % m_permutationSizes[i];
120  }
121  ++m_offset;
122  }
123  ++m_numPermutationsProcessed;
124 
125  return m_permutation;
126  }
127 
128  virtual boost::uint64_t getPermutationIdx() const {
129  return m_numPermutationsProcessed;
130  }
131 
132  virtual operator bool() const { return true; }
133 
135  return new RandomSampleAllBBsStrategy(*this);
136  }
137 
138  private:
139 #ifdef RDK_USE_BOOST_SERIALIZATION
140  friend class boost::serialization::access;
141 
142  template <class Archive>
143  void save(Archive &ar, const unsigned int /*version*/) const {
144  // invoke serialization of the base class
145  ar << boost::serialization::base_object<const EnumerationStrategyBase>(
146  *this);
147  ar << m_numPermutationsProcessed;
148 
149  std::stringstream random;
150  random << m_rng;
151  std::string s = random.str();
152  ar << s;
153 
154  ar << m_offset;
155  ar << m_maxoffset;
156  }
157 
158  template <class Archive>
159  void load(Archive &ar, const unsigned int /*version*/) {
160  // invoke serialization of the base class
161  ar >> boost::serialization::base_object<EnumerationStrategyBase>(*this);
162  ar >> m_numPermutationsProcessed;
163  std::string s;
164  ar >> s;
165  std::stringstream random(s);
166  random >> m_rng;
167  ar >> m_offset;
168  ar >> m_maxoffset;
169 
170  // reset the uniform distributions
171  m_distributions.clear();
172  for (size_t i = 0; i < m_permutationSizes.size(); ++i) {
173  m_distributions.push_back(boost::random::uniform_int_distribution<>(
174  0, m_permutationSizes[i] - 1));
175  }
176  }
177 
178  template <class Archive>
179  void serialize(Archive &ar, const unsigned int file_version) {
180  boost::serialization::split_member(ar, *this, file_version);
181  }
182 #endif
183 };
184 } // namespace RDKit
185 
186 #ifdef RDK_USE_BOOST_SERIALIZATION
187 BOOST_CLASS_VERSION(RDKit::RandomSampleAllBBsStrategy, 1)
188 #endif
189 
190 #endif
RDKit::RandomSampleAllBBsStrategy::RandomSampleAllBBsStrategy
RandomSampleAllBBsStrategy()
Definition: RandomSampleAllBBs.h:78
EnumerationStrategyBase.h
RDKit::RandomSampleAllBBsStrategy::copy
EnumerationStrategyBase * copy() const
copy the enumeration strategy complete with current state
Definition: RandomSampleAllBBs.h:134
RDKit::RandomSampleAllBBsStrategy
This is a class for randomly enumerating reagents that ensures all reagents.
Definition: RandomSampleAllBBs.h:68
RDKit::RandomSampleAllBBsStrategy::initializeStrategy
void initializeStrategy(const ChemicalReaction &, const EnumerationTypes::BBS &)
Definition: RandomSampleAllBBs.h:92
RDKit::EnumerationTypes::BBS
std::vector< MOL_SPTR_VECT > BBS
Definition: EnumerateTypes.h:42
RDKit::RandomSampleAllBBsStrategy::type
virtual const char * type() const
Definition: RandomSampleAllBBs.h:108
RDKit::RandomSampleAllBBsStrategy::getPermutationIdx
virtual boost::uint64_t getPermutationIdx() const
Returns how many permutations have been processed by this strategy.
Definition: RandomSampleAllBBs.h:128
RDKit::ChemicalReaction
This is a class for storing and applying general chemical reactions.
Definition: Reaction.h:119
RDKit::EnumerationStrategyBase
Definition: EnumerationStrategyBase.h:120
RDKit::EnumerationTypes::RGROUPS
std::vector< boost::uint64_t > RGROUPS
Definition: EnumerateTypes.h:56
RDKit
Std stuff.
Definition: Atom.h:30
RDKit::RandomSampleAllBBsStrategy::next
virtual const EnumerationTypes::RGROUPS & next()
The current permutation {r1, r2, ...}.
Definition: RandomSampleAllBBs.h:111
RDKIT_CHEMREACTIONS_EXPORT
#define RDKIT_CHEMREACTIONS_EXPORT
Definition: export.h:60
RDKit::EnumerationStrategyBase::initialize
void initialize(const ChemicalReaction &reaction, const EnumerationTypes::BBS &building_blocks)
Definition: EnumerationStrategyBase.h:141
export.h