forqs module reference
Forward simulation of Recombination, Quantitative traits, and Selection
 All Classes Groups Pages
VariantIndicator.hpp
1 //
2 // VariantIndicator.hpp
3 //
4 // Created by Darren Kessner with John Novembre
5 //
6 // Copyright (c) 2013 Regents of the University of California
7 // All rights reserved.
8 //
9 // Redistribution and use in source and binary forms, with or without
10 // modification, are permitted provided that the following conditions are met:
11 //
12 // * Redistributions of source code must retain the above copyright notice,
13 // this list of conditions and the following disclaimer.
14 //
15 // * Redistributions in binary form must reproduce the above copyright notice,
16 // this list of conditions and the following disclaimer in the documentation
17 // and/or other materials provided with the distribution.
18 //
19 // * Neither UCLA nor the names of its contributors may be used to endorse or
20 // promote products derived from this software without specific prior
21 // written permission.
22 //
23 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
24 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
27 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 //
34 
35 
36 #ifndef _VARIANTINDICATOR_HPP_
37 #define _VARIANTINDICATOR_HPP_
38 
39 
40 #include "Configurable.hpp"
41 #include "Locus.hpp"
42 #include "MSFormat.hpp"
43 #include "Reporter.hpp"
44 #include "Simulator.hpp"
45 #include "boost/filesystem.hpp"
46 #include "boost/filesystem/fstream.hpp"
47 
48 
54 
55 
56 //
57 // VariantIndicator
58 //
59 
63 
64 class VariantIndicator : public virtual Configurable
65 {
66  public:
67 
68  virtual unsigned int operator()(unsigned int chunk_id, const Locus& locus) const = 0;
69  virtual void write_file(const std::string& filename) const;
70  virtual unsigned int mutate(unsigned int old_chunk_id, const Locus& locus, unsigned int value); // returns new chunk id
71  virtual ~VariantIndicator() {}
72 
73  // Configurable interface
74 
75  virtual std::string class_name() const;
76  virtual Parameters parameters() const;
77  virtual void configure(const Parameters& parameters, const Registry& registry);
78 
79  protected:
80 
81  // Note: the compiler needs this because Configurable has no default
82  // constructor (by design). However, this call to Configurable(id) never
83  // actually happens. Configurable is a virtual base, so derived classes
84  // must call Configurable(id) directly in their constructors, and this
85  // call is ignored by compiler.
86  VariantIndicator() : Configurable("dummy_id_variant_indicator") {}
87 };
88 
89 
90 typedef shared_ptr<VariantIndicator> VariantIndicatorPtr;
91 
92 
93 //
94 // VariantIndicator_Trivial
95 //
96 
104 
106 {
107  public:
108 
109  VariantIndicator_Trivial(const std::string& id) : Configurable(id) {}
110 
111  virtual unsigned int operator()(unsigned int chunk_id, const Locus& locus) const {return 0;}
112 
113  // Configurable interface
114 
115  virtual std::string class_name() const {return "VariantIndicator_Trivial";}
116  virtual Parameters parameters() const {return Parameters();}
117  virtual void configure(const Parameters& parameters, const Registry& registry) {}
118 };
119 
120 
121 //
122 // VariantIndicator_IDRange
123 //
124 
136 
138 {
139  public:
140 
141  VariantIndicator_IDRange(const std::string& id) : Configurable(id) {}
142 
143  virtual unsigned int operator()(unsigned int chunk_id, const Locus& locus) const;
144 
145  // Configurable interface
146 
147  virtual std::string class_name() const {return "VariantIndicator_IDRange";}
148  virtual Parameters parameters() const;
149  virtual void configure(const Parameters& parameters, const Registry& registry);
150  virtual void write_child_configurations(std::ostream& os, std::set<std::string>& written) const;
151 
152  protected:
153 
154  struct Entry
155  {
156  unsigned int id_start;
157  unsigned int id_count;
158  unsigned int id_step;
159  unsigned int value;
160 
161  Entry(unsigned int _id_start, unsigned int _id_count, unsigned int _id_step, unsigned int _value)
162  : id_start(_id_start), id_count(_id_count), id_step(_id_step), value(_value)
163  {}
164  };
165 
166  typedef std::multimap<Locus,Entry> EntryMap;
167  EntryMap entries_;
168 };
169 
170 
171 //
172 // VariantIndicator_IDSet
173 //
174 
186 
188 {
189  public:
190 
191  VariantIndicator_IDSet(const std::string& id) : Configurable(id) {}
192  virtual unsigned int operator()(unsigned int chunk_id, const Locus& locus) const;
193  virtual void write_file(const std::string& filename) const;
194 
195  // Configurable interface
196 
197  virtual std::string class_name() const {return "VariantIndicator_IDSet";}
198  virtual Parameters parameters() const;
199  virtual void configure(const Parameters& parameters, const Registry& registry);
200  virtual void write_child_configurations(std::ostream& os, std::set<std::string>& written) const;
201 
202  struct Entry
203  {
204  unsigned int value;
205  std::set<unsigned int> ids;
206 
207  Entry(unsigned int _value = -1ul, std::set<unsigned int> _ids = std::set<unsigned int>())
208  : value(_value), ids(_ids)
209  {}
210  };
211 
212  typedef std::map<Locus,Entry> EntryMap;
213 
214  const EntryMap& entries() const {return entries_;} // for testing
215 
216  protected:
217 
218  EntryMap entries_;
219 };
220 
221 
222 //
223 // VariantIndicator_Random
224 //
225 
242 
244 {
245  public:
246 
247  VariantIndicator_Random(const std::string& id) : Configurable(id), VariantIndicator_IDSet(id) {}
248 
249  // Configurable interface
250 
251  virtual std::string class_name() const {return "VariantIndicator_Random";}
252  virtual Parameters parameters() const;
253  virtual void configure(const Parameters& parameters, const Registry& registry);
254  virtual void initialize(const SimulatorConfig& simconfig);
255  virtual void write_child_configurations(std::ostream& os, std::set<std::string>& written) const;
256 
257  private:
258 
259  struct LocusListInfo
260  {
261  size_t population_index;
262  LocusListPtr locus_list;
263  std::vector<double> frequencies;
264  Random::DistributionPtr distribution;
265 
266  LocusListInfo(size_t _population_index, const LocusListPtr& _locus_list,
267  std::vector<double> _frequencies)
268  : population_index(_population_index), locus_list(_locus_list), frequencies(_frequencies)
269  {}
270 
271  LocusListInfo(size_t _population_index, const LocusListPtr& _locus_list,
272  Random::DistributionPtr _distribution)
273  : population_index(_population_index), locus_list(_locus_list), distribution(_distribution)
274  {}
275  };
276 
277  typedef std::vector<LocusListInfo> LocusListInfos;
278  LocusListInfos locus_list_infos_;
279 };
280 
281 
282 //
283 // VariantIndicator_File
284 //
285 
301 
303 {
304  public:
305 
306  VariantIndicator_File(const std::string& id) : Configurable(id) {}
307 
308  virtual unsigned int operator()(unsigned int chunk_id, const Locus& locus) const;
309 
310  // Configurable interface
311 
312  virtual std::string class_name() const {return "VariantIndicator_File";}
313  virtual Parameters parameters() const;
314  virtual void configure(const Parameters& parameters, const Registry& registry);
315  virtual void write_child_configurations(std::ostream& os, std::set<std::string>& written) const;
316 
317  private:
318 
319  std::string msfile_;
320  MSFormatPtr ms_;
321  std::vector<Locus> loci_;
322  std::map<Locus, size_t> locus_index_map_;
323 };
324 
325 
326 //
327 // VariantIndicator_SingleLocusHardyWeinberg
328 //
329 
350 
352 {
353  public:
354 
355  VariantIndicator_SingleLocusHardyWeinberg(const std::string& id,
356  Locus locus = Locus("id_dummy"),
357  double allele_frequency = 0);
358  // Configurable interface
359 
360  virtual std::string class_name() const {return "VariantIndicator_SingleLocusHardyWeinberg";}
361  virtual Parameters parameters() const;
362  virtual void configure(const Parameters& parameters, const Registry& registry);
363  virtual void initialize(const SimulatorConfig& simconfig);
364  virtual void write_child_configurations(std::ostream& os, std::set<std::string>& written) const;
365 
366  private:
367 
368  Locus locus_;
369  double allele_frequency_;
370 };
371 
372 
373 //
374 // VariantIndicator_TwoLocusLD
375 //
376 
397 
399 {
400  public:
401 
402  VariantIndicator_TwoLocusLD(const std::string& id,
403  size_t population_size = 0,
404  Locus locus_1 = Locus("id_dummy_1"),
405  double allele_frequency_1 = 0,
406  Locus locus_2 = Locus("id_dummy_2"),
407  double allele_frequency_2 = 0,
408  double D = 0,
409  unsigned int id_offset_step = 0);
410 
411  virtual unsigned int operator()(unsigned int chunk_id, const Locus& locus) const;
412 
413  // Configurable interface
414 
415  virtual std::string class_name() const {return "VariantIndicator_TwoLocusLD";}
416  virtual Parameters parameters() const;
417  virtual void configure(const Parameters& parameters, const Registry& registry);
418  virtual void write_child_configurations(std::ostream& os, std::set<std::string>& written) const;
419 
420  private:
421 
422  size_t population_size_;
423  Locus locus_1_;
424  double allele_frequency_1_;
425  Locus locus_2_;
426  double allele_frequency_2_;
427  double D_;
428  unsigned int id_offset_step_;
429 
430  size_t max_00_;
431  size_t max_01_;
432  size_t max_10_;
433  size_t max_11_;
434 
435  void initialize();
436 };
437 
438 
439 #endif // _VARIANTINDICATOR_HPP_
440