1 /* _______________________________________________________________________
2
3 DAKOTA: Design Analysis Kit for Optimization and Terascale Applications
4 Copyright 2014-2020 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
5 This software is distributed under the GNU Lesser General Public License.
6 For more information, see the README file in the top Dakota directory.
7 _______________________________________________________________________ */
8
9 //- Class: Variables
10 //- Description: Base class for variables
11 //- Owner: Mike Eldred
12 //- Version: $Id: DakotaVariables.hpp 7037 2010-10-23 01:18:08Z mseldre $
13
14 #ifndef DAKOTA_VARIABLES_H
15 #define DAKOTA_VARIABLES_H
16
17 #include "dakota_data_types.hpp"
18 #include "dakota_global_defs.hpp" // for BaseConstructor
19 #include "SharedVariablesData.hpp"
20 #include "dakota_data_io.hpp"
21
22 namespace Dakota {
23
24 // forward declarations
25 class ProblemDescDB;
26 class MPIPackBuffer;
27 class MPIUnpackBuffer;
28
29 /// Utility used in derived read_core to read in generic format
30 class GeneralReader {
31 public:
32 template<typename ArrayType>
operator ()(std::istream & s,size_t start_index,size_t num_items,ArrayType & array_data,StringMultiArrayView label_array)33 void operator()(std::istream& s, size_t start_index, size_t num_items,
34 ArrayType& array_data, StringMultiArrayView label_array) {
35 read_data_partial(s, start_index, num_items, array_data, label_array);
36 }
37 };
38
39 /// Utility used in derived read_core to read values in tabular format
40 class TabularReader {
41 public:
42 template<typename ArrayType>
operator ()(std::istream & s,size_t start_index,size_t num_items,ArrayType & array_data,StringMultiArrayView label_array)43 void operator()(std::istream& s, size_t start_index, size_t num_items,
44 ArrayType& array_data, StringMultiArrayView label_array) {
45 /// The tabular reader doesn't forward the label arrays
46 read_data_partial_tabular(s, start_index, num_items, array_data);
47 }
48 };
49
50 /// Utility used in derived write_core to write in generic format
51 class GeneralWriter {
52 public:
53 template<typename ArrayType>
operator ()(std::ostream & s,size_t start_index,size_t num_items,const ArrayType & array_data,StringMultiArrayConstView label_array)54 void operator()(std::ostream& s, size_t start_index, size_t num_items,
55 const ArrayType& array_data,
56 StringMultiArrayConstView label_array) {
57 write_data_partial(s, start_index, num_items, array_data, label_array);
58 }
59 };
60
61 /// Utility used in derived write_core to write in aprepro format
62 class ApreproWriter {
63 public:
64 template<typename ArrayType>
operator ()(std::ostream & s,size_t start_index,size_t num_items,const ArrayType & array_data,StringMultiArrayConstView label_array)65 void operator()(std::ostream& s, size_t start_index, size_t num_items,
66 const ArrayType& array_data,
67 StringMultiArrayConstView label_array) {
68 write_data_partial_aprepro(s, start_index, num_items, array_data,
69 label_array);
70 }
71 };
72
73 /// Utility used in derived write_core to write values in tabular format
74 class TabularWriter {
75 public:
76 template<typename ArrayType>
operator ()(std::ostream & s,size_t start_index,size_t num_items,const ArrayType & array_data,StringMultiArrayConstView label_array)77 void operator()(std::ostream& s, size_t start_index, size_t num_items,
78 const ArrayType& array_data,
79 StringMultiArrayConstView label_array) {
80 /// The tabular writer doesn't forward the label arrays
81 write_data_partial_tabular(s, start_index, num_items, array_data);
82 }
83 };
84
85 /// Utility used in derived write_core to write labels in tabular format
86 class LabelsWriter {
87 public:
88 template<typename ArrayType>
operator ()(std::ostream & s,size_t start_index,size_t num_items,const ArrayType & array_data,StringMultiArrayConstView label_array)89 void operator()(std::ostream& s, size_t start_index, size_t num_items,
90 const ArrayType& array_data,
91 StringMultiArrayConstView label_array) {
92 /// The tabular labels writer only forwards the label arrays
93 write_data_partial_tabular(s, start_index, num_items, label_array);
94 }
95 };
96
97
98 /// Base class for the variables class hierarchy.
99
100 /** The Variables class is the base class for the class hierarchy
101 providing design, uncertain, and state variables for continuous
102 and discrete domains within a Model. Using the fundamental
103 arrays from the input specification, different derived classes
104 define different views of the data. For memory efficiency and
105 enhanced polymorphism, the variables hierarchy employs the
106 "letter/envelope idiom" (see Coplien "Advanced C++", p. 133), for
107 which the base class (Variables) serves as the envelope and one of
108 the derived classes (selected in Variables::get_variables())
109 serves as the letter. */
110
111 class Variables
112 {
113 //
114 //- Heading: Friends
115 //
116
117 /// for serializing private data members
118 friend class boost::serialization::access;
119
120 /// strict equality operator (for boost hash-based lookups)
121 friend bool operator==(const Variables& vars1, const Variables& vars2);
122 /// strict inequality operator
123 friend bool operator!=(const Variables& vars1, const Variables& vars2);
124
125 /// tolerance-based equality operator
126 friend bool nearby(const Variables& vars1, const Variables& vars2,
127 Real rel_tol);
128
129 /// hash_value
130 friend std::size_t hash_value(const Variables& vars);
131
132 public:
133
134 //
135 //- Heading: Constructors, destructor, assignment operator
136 //
137
138 /// default constructor
139 Variables();
140 /// standard constructor (explicit disallows its use for implicit
141 /// type conversion)
142 explicit Variables(const ProblemDescDB& problem_db);
143 /// alternate constructor for instantiations on the fly (explicit
144 /// disallows its use for implicit type conversion)
145 explicit Variables(const SharedVariablesData& svd);
146 /// copy constructor
147 Variables(const Variables& vars);
148
149 /// destructor
150 virtual ~Variables();
151
152 /// assignment operator
153 Variables operator=(const Variables& vars);
154
155 //
156 //- Heading: Virtual functions
157 //
158
159 // INPUT/OUTPUT
160
161 /// read a variables object from an std::istream
162 virtual void read(std::istream& s);
163 /// write a variables object to an std::ostream, e.g., the console,
164 /// optionally specifying which partition (all/active/inactive)
165 virtual void write(std::ostream& s, unsigned short vars_part = ALL_VARS) const;
166 /// write a variables object to an std::ostream in aprepro format,
167 /// e.g., a parameters file
168 virtual void write_aprepro(std::ostream& s) const;
169
170 // For neutral file I/O (restart translation to/from neutral):
171 /// read a variables object in annotated format from an istream
172 virtual void read_annotated(std::istream& s);
173 /// write a variables object in annotated format to an std::ostream
174 virtual void write_annotated(std::ostream& s) const;
175
176 /// read a variables object in tabular format from an istream,
177 /// optionally specifying which partition (all/active/inactive)
178 virtual void read_tabular(std::istream& s,
179 unsigned short vars_part = ALL_VARS);
180 /// write a variables object in tabular format to an std::ostream,
181 /// optionally specifying which partition (all/active/inactive)
182 virtual void write_tabular(std::ostream& s,
183 unsigned short vars_part = ALL_VARS) const;
184
185 /// write the labels in input spec order to a std::ostream,
186 /// optionally specifying which partition (all/active/inactive)
187 virtual void write_tabular_labels(std::ostream& s,
188 unsigned short vars_part = ALL_VARS) const;
189
190 /// read a variables object from a packed MPI buffer
191 virtual void read(MPIUnpackBuffer& s);
192 /// write a variables object to a packed MPI buffer
193 virtual void write(MPIPackBuffer& s) const;
194
195 //
196 //- Heading: Member functions
197 //
198
199 size_t tv() const; ///< total number of vars
200 size_t total_active() const; ///< total number of active vars
201 size_t cv() const; ///< number of active continuous vars
202 size_t cv_start() const; ///< start index of active continuous vars
203 size_t div() const; ///< number of active discrete int vars
204 size_t div_start() const; ///< start index of active discrete int vars
205 size_t dsv() const; ///< number of active discrete string vars
206 size_t dsv_start() const; ///< start index of active discrete string vars
207 size_t drv() const; ///< number of active discrete real vars
208 size_t drv_start() const; ///< start index of active discrete real vars
209 size_t icv() const; ///< number of inactive continuous vars
210 size_t icv_start() const; ///< start index of inactive continuous vars
211 size_t idiv() const; ///< number of inactive discrete int vars
212 size_t idiv_start() const; ///< start index of inactive discrete int vars
213 size_t idsv() const; ///< number of inactive discrete string vars
214 size_t idsv_start() const; ///< start index of inactive discrete string vars
215 size_t idrv() const; ///< number of inactive discrete real vars
216 size_t idrv_start() const; ///< start index of inactive discrete real vars
217 size_t acv() const; ///< total number of continuous vars
218 size_t adiv() const; ///< total number of discrete integer vars
219 size_t adsv() const; ///< total number of discrete string vars
220 size_t adrv() const; ///< total number of discrete real vars
221
222 /// return sharedVarsData
223 const SharedVariablesData& shared_data() const;
224 /// return sharedVarsData
225 SharedVariablesData& shared_data();
226
227 /// shape a Variables object based on sharedVarsData
228 void shape();
229 /// reshape an existing Variables object based on updated sharedVarsData
230 void reshape();
231
232 // ACTIVE VARIABLES
233
234 /// return an active continuous variable
235 Real continuous_variable(size_t index) const;
236 /// return the active continuous variables (Note: returns a view by const
237 /// reference, but initializing a RealVector from this reference invokes
238 /// the Teuchos matrix copy constructor to create a Teuchos::Copy instance;
239 /// to obtain a mutable view, use continuous_variables_view())
240 const RealVector& continuous_variables() const;
241 /// set an active continuous variable
242 void continuous_variable(Real c_var, size_t index);
243 /// set the active continuous variables
244 void continuous_variables(const RealVector& c_vars);
245
246 /// return an active discrete integer variable
247 int discrete_int_variable(size_t index) const;
248 /// return the active discrete integer variables (Note: returns a view by
249 /// const reference, but initializing an IntVector from this reference
250 /// invokes the Teuchos matrix copy constructor to create a Teuchos::Copy
251 /// instance; to obtain a mutable view, use discrete_int_variables_view())
252 const IntVector& discrete_int_variables() const;
253 /// set an active discrete integer variable
254 void discrete_int_variable(int di_var, size_t index);
255 /// set the active discrete integer variables
256 void discrete_int_variables(const IntVector& di_vars);
257
258 /// return an active discrete string variable
259 const String& discrete_string_variable(size_t index) const;
260 /// return the active discrete string variables (Note: returns a view by
261 /// const reference, but initializing a StringArray from this reference
262 /// invokes the Teuchos matrix copy constructor to create a Teuchos::Copy
263 /// instance; to obtain a mutable view, use discrete_string_variables_view())
264 StringMultiArrayConstView discrete_string_variables() const;
265 /// set an active discrete string variable
266 void discrete_string_variable(const String& ds_var, size_t index);
267 /// set the active discrete string variables
268 void discrete_string_variables(StringMultiArrayConstView ds_vars);
269
270 /// return an active discrete real variable
271 Real discrete_real_variable(size_t index) const;
272 /// return the active discrete real variables (Note: returns a view by
273 /// const reference, but initializing a RealVector from this reference
274 /// invokes the Teuchos matrix copy constructor to create a Teuchos::Copy
275 /// instance; to obtain a mutable view, use discrete_real_variables_view())
276 const RealVector& discrete_real_variables() const;
277 /// set an active discrete real variable
278 void discrete_real_variable(Real dr_var, size_t index);
279 /// set the active discrete real variables
280 void discrete_real_variables(const RealVector& dr_vars);
281
282 /// copy the active cv/div/dsv/drv variables from vars
283 void active_variables(const Variables& vars);
284 /// copy all cv/div/dsv/drv variables from vars
285 void all_variables(const Variables& vars);
286
287 /// return a mutable view of the active continuous variables
288 RealVector& continuous_variables_view();
289 /// return a mutable view of the active discrete integer variables
290 IntVector& discrete_int_variables_view();
291 /// return a mutable view of the active discrete string variables
292 StringMultiArrayView discrete_string_variables_view();
293 /// return a mutable view of the active discrete real variables
294 RealVector& discrete_real_variables_view();
295
296 /// return the active continuous variable labels
297 StringMultiArrayConstView continuous_variable_labels() const;
298 /// set the active continuous variable labels
299 void continuous_variable_labels(StringMultiArrayConstView cv_labels);
300 /// set an active continuous variable label
301 void continuous_variable_label(const String& cv_label, size_t index);
302
303 /// return the active discrete integer variable labels
304 StringMultiArrayConstView discrete_int_variable_labels() const;
305 /// set the active discrete integer variable labels
306 void discrete_int_variable_labels(StringMultiArrayConstView div_labels);
307 /// set an active discrete integer variable label
308 void discrete_int_variable_label(const String& div_label, size_t index);
309
310 /// return the active discrete string variable labels
311 StringMultiArrayConstView discrete_string_variable_labels() const;
312 /// set the active discrete string variable labels
313 void discrete_string_variable_labels(StringMultiArrayConstView dsv_labels);
314 /// set an active discrete string variable label
315 void discrete_string_variable_label(const String& dsv_label, size_t index);
316
317 /// return the active discrete real variable labels
318 StringMultiArrayConstView discrete_real_variable_labels() const;
319 /// set the active discrete real variable labels
320 void discrete_real_variable_labels(StringMultiArrayConstView drv_labels);
321 /// set an active discrete real variable label
322 void discrete_real_variable_label(const String& drv_label, size_t index);
323
324 /// return the active continuous variable types
325 UShortMultiArrayConstView continuous_variable_types() const;
326 /// set the active continuous variable types
327 void continuous_variable_types(UShortMultiArrayConstView cv_types);
328 /// set an active continuous variable type
329 void continuous_variable_type(unsigned short cv_type, size_t index);
330
331 /// return the active discrete integer variable types
332 UShortMultiArrayConstView discrete_int_variable_types() const;
333 /// set the active discrete integer variable types
334 void discrete_int_variable_types(UShortMultiArrayConstView div_types);
335 /// set an active discrete integer variable type
336 void discrete_int_variable_type(unsigned short div_type, size_t index);
337
338 /// return the active discrete string variable types
339 UShortMultiArrayConstView discrete_string_variable_types() const;
340 /// set the active discrete string variable types
341 void discrete_string_variable_types(UShortMultiArrayConstView dsv_types);
342 /// set an active discrete string variable type
343 void discrete_string_variable_type(unsigned short dsv_type, size_t index);
344
345 /// return the active discrete real variable types
346 UShortMultiArrayConstView discrete_real_variable_types() const;
347 /// set the active discrete real variable types
348 void discrete_real_variable_types(UShortMultiArrayConstView drv_types);
349 /// set an active discrete real variable type
350 void discrete_real_variable_type(unsigned short drv_type, size_t index);
351
352 /// return the active continuous variable position identifiers
353 SizetMultiArrayConstView continuous_variable_ids() const;
354 /// set the active continuous variable position identifiers
355 void continuous_variable_ids(SizetMultiArrayConstView cv_ids);
356 /// set an active continuous variable position identifier
357 void continuous_variable_id(size_t cv_id, size_t index);
358
359 // returns the set of discrete variable ids relaxed into a continuous array
360 //const SizetArray& relaxed_discrete_ids() const;
361
362 // INACTIVE VARIABLES
363
364 /// return the inactive continuous variables
365 const RealVector& inactive_continuous_variables() const;
366 /// set the inactive continuous variables
367 void inactive_continuous_variables(const RealVector& ic_vars);
368 /// set an inactive continuous variable
369 void inactive_continuous_variable(Real ic_var, size_t index);
370
371 /// return the inactive discrete int variables
372 const IntVector& inactive_discrete_int_variables() const;
373 /// set the inactive discrete int variables
374 void inactive_discrete_int_variables(const IntVector& idi_vars);
375 /// set an inactive discrete int variable
376 void inactive_discrete_int_variable(int idi_var, size_t index);
377
378 /// return the inactive discrete string variables
379 StringMultiArrayConstView inactive_discrete_string_variables() const;
380 /// set the inactive discrete string variables
381 void inactive_discrete_string_variables(StringMultiArrayConstView ids_vars);
382 /// set an inactive discrete string variable
383 void inactive_discrete_string_variable(const String& ids_var, size_t index);
384
385 /// return the inactive discrete real variables
386 const RealVector& inactive_discrete_real_variables() const;
387 /// set the inactive discrete real variables
388 void inactive_discrete_real_variables(const RealVector& idr_vars);
389 /// set an inactive discrete real variable
390 void inactive_discrete_real_variable(Real idr_var, size_t index);
391
392 /// return the inactive continuous variable labels
393 StringMultiArrayConstView inactive_continuous_variable_labels() const;
394 /// set the inactive continuous variable labels
395 void inactive_continuous_variable_labels(StringMultiArrayConstView ic_vars);
396
397 /// return the inactive discrete variable labels
398 StringMultiArrayConstView inactive_discrete_int_variable_labels() const;
399 /// set the inactive discrete variable labels
400 void inactive_discrete_int_variable_labels(
401 StringMultiArrayConstView idi_vars);
402
403 /// return the inactive discrete variable labels
404 StringMultiArrayConstView inactive_discrete_string_variable_labels() const;
405 /// set the inactive discrete variable labels
406 void inactive_discrete_string_variable_labels(
407 StringMultiArrayConstView ids_vars);
408
409 /// return the inactive discrete variable labels
410 StringMultiArrayConstView inactive_discrete_real_variable_labels() const;
411 /// set the inactive discrete variable labels
412 void inactive_discrete_real_variable_labels(
413 StringMultiArrayConstView idr_vars);
414
415 /// return the inactive continuous variable types
416 UShortMultiArrayConstView inactive_continuous_variable_types() const;
417 /// return the inactive discrete integer variable types
418 UShortMultiArrayConstView inactive_discrete_int_variable_types() const;
419 /// return the inactive discrete string variable types
420 UShortMultiArrayConstView inactive_discrete_string_variable_types() const;
421 /// return the inactive discrete real variable types
422 UShortMultiArrayConstView inactive_discrete_real_variable_types() const;
423
424 /// return the inactive continuous variable position identifiers
425 SizetMultiArrayConstView inactive_continuous_variable_ids() const;
426
427 // ALL VARIABLES
428
429 /// returns a single array with all continuous variables
430 const RealVector& all_continuous_variables() const;
431 /// sets all continuous variables using a single array
432 void all_continuous_variables(const RealVector& ac_vars);
433 /// set a variable within the all continuous array
434 void all_continuous_variable(Real ac_var, size_t index);
435
436 /// returns a single array with all discrete variables
437 const IntVector& all_discrete_int_variables() const;
438 /// sets all discrete variables using a single array
439 void all_discrete_int_variables(const IntVector& adi_vars);
440 /// set a variable within the all discrete array
441 void all_discrete_int_variable(int adi_var, size_t index);
442
443 /// returns a single array with all discrete variables
444 StringMultiArrayConstView all_discrete_string_variables() const;
445 /// sets all discrete variables using a single array
446 void all_discrete_string_variables(StringMultiArrayConstView ads_vars);
447 /// set a variable within the all discrete array
448 void all_discrete_string_variable(const String& ads_var, size_t index);
449
450 /// returns a single array with all discrete variables
451 const RealVector& all_discrete_real_variables() const;
452 /// sets all discrete variables using a single array
453 void all_discrete_real_variables(const RealVector& adr_vars);
454 /// set a variable within the all discrete array
455 void all_discrete_real_variable(Real adr_var, size_t index);
456
457 /// get the active variables as a vector of reals, converting string
458 /// values to zero-based set indices
459 void as_vector(const StringSetArray& dss_vals, RealVector& var_values) const;
460
461 /// returns a single array with all continuous variable labels
462 StringMultiArrayView all_continuous_variable_labels() const;
463 /// sets all continuous variable labels using a single array
464 void all_continuous_variable_labels(StringMultiArrayConstView acv_labels);
465 /// set a label within the all continuous label array
466 void all_continuous_variable_label(const String& acv_label,size_t index);
467
468 /// returns a single array with all discrete variable labels
469 StringMultiArrayView all_discrete_int_variable_labels() const;
470 /// sets all discrete variable labels using a single array
471 void all_discrete_int_variable_labels(StringMultiArrayConstView adiv_labels);
472 /// set a label within the all discrete label array
473 void all_discrete_int_variable_label(const String& adiv_label, size_t index);
474
475 /// returns a single array with all discrete variable labels
476 StringMultiArrayView all_discrete_string_variable_labels() const;
477 /// sets all discrete variable labels using a single array
478 void all_discrete_string_variable_labels(StringMultiArrayConstView
479 adsv_labels);
480 /// set a label within the all discrete label array
481 void all_discrete_string_variable_label(const String& adsv_label,
482 size_t index);
483
484 /// returns a single array with all discrete variable labels
485 StringMultiArrayView all_discrete_real_variable_labels() const;
486 /// sets all discrete variable labels using a single array
487 void all_discrete_real_variable_labels(StringMultiArrayConstView adrv_labels);
488 /// set a label within the all discrete label array
489 void all_discrete_real_variable_label(const String& adrv_label, size_t index);
490
491 /// return all continuous variable types
492 UShortMultiArrayConstView all_continuous_variable_types() const;
493 /// return all discrete variable types
494 UShortMultiArrayConstView all_discrete_int_variable_types() const;
495 /// return all discrete variable types
496 UShortMultiArrayConstView all_discrete_string_variable_types() const;
497 /// return all discrete variable types
498 UShortMultiArrayConstView all_discrete_real_variable_types() const;
499
500 /// return all continuous variable position identifiers
501 SizetMultiArrayConstView all_continuous_variable_ids() const;
502 /// return all discrete integer variable position identifiers
503 SizetMultiArrayConstView all_discrete_int_variable_ids() const;
504 /// return all discrete string variable position identifiers
505 SizetMultiArrayConstView all_discrete_string_variable_ids() const;
506 /// return all discrete real variable position identifiers
507 SizetMultiArrayConstView all_discrete_real_variable_ids() const;
508
509 /// get all or active labels in input spec order
510 StringArray ordered_labels(unsigned short vars_part = ALL_VARS) const;
511
512 /// a deep variables copy for use in history mechanisms
513 /// (SharedVariablesData uses a shallow copy by default)
514 Variables copy(bool deep_svd = false) const;
515
516 /// returns variablesView
517 const std::pair<short,short>& view() const;
518 /// defines variablesView from problem_db attributes
519 std::pair<short,short> get_view(const ProblemDescDB& problem_db) const;
520 /// sets the inactive view based on higher level (nested) context
521 void inactive_view(short view2);
522
523 /// returns the variables identifier string
524 const String& variables_id() const;
525
526 /// returns the number of variables for each of the constitutive components
527 const SizetArray& variables_components_totals() const;
528
529 /// function to check variablesRep (does this envelope contain a letter)
530 bool is_null() const;
531
532 protected:
533
534 //
535 //- Heading: Constructors
536 //
537
538 /// constructor initializes the base class part of letter classes
539 /// (BaseConstructor overloading avoids infinite recursion in the
540 /// derived class constructors - Coplien, p. 139)
541 Variables(BaseConstructor, const ProblemDescDB& problem_db,
542 const std::pair<short,short>& view);
543 /// constructor initializes the base class part of letter classes
544 /// (BaseConstructor overloading avoids infinite recursion in the
545 /// derived class constructors - Coplien, p. 139)
546 Variables(BaseConstructor, const SharedVariablesData& svd);
547
548 //
549 //- Heading: Member functions
550 //
551
552 /// construct active/inactive views of all variables arrays
553 void build_views();
554 /// construct active views of all variables arrays
555 void build_active_views();
556 /// construct inactive views of all variables arrays
557 void build_inactive_views();
558
559 //
560 //- Heading: Data
561 //
562
563 /// reference-counted instance of shared variables data: id's, labels, counts
564 SharedVariablesData sharedVarsData;
565
566 /// array combining all of the continuous variables
567 RealVector allContinuousVars;
568 /// array combining all of the discrete integer variables
569 IntVector allDiscreteIntVars;
570 /// array combining all of the discrete string variables
571 StringMultiArray allDiscreteStringVars;
572 /// array combining all of the discrete real variables
573 RealVector allDiscreteRealVars;
574
575 //
576 //- Heading: Data views
577 //
578
579 /// the active continuous variables array view
580 RealVector continuousVars;
581 /// the active discrete integer variables array view
582 IntVector discreteIntVars;
583 // the active discrete string variables view
584 /* don't cache an explicit view; rather generate on the fly as for labels */
585 //StringMultiArrayView discreteStringVars;
586 /// the active discrete real variables array view
587 RealVector discreteRealVars;
588
589 /// the inactive continuous variables array view
590 RealVector inactiveContinuousVars;
591 /// the inactive discrete integer variables array view
592 IntVector inactiveDiscreteIntVars;
593 // the inactive discrete string variables view
594 /* don't cache an explicit view; rather generate on the fly as for labels */
595 //StringMultiArrayView inactiveDiscreteStringVars;
596 /// the inactive discrete real variables array view
597 RealVector inactiveDiscreteRealVars;
598
599 private:
600
601 //
602 //- Heading: Member functions
603 //
604
605 /// Used by the standard envelope constructor to instantiate the
606 /// correct letter class
607 std::shared_ptr<Variables> get_variables(const ProblemDescDB& problem_db);
608 /// Used by the alternate envelope constructors, by read functions,
609 /// and by copy() to instantiate a new letter class
610 std::shared_ptr<Variables> get_variables(const SharedVariablesData& svd) const;
611
612 /// infer domain from method selection
613 short method_map(short view_spec, bool relaxed) const;
614 /// infer domain from method selection
615 short method_domain(const ProblemDescDB& problem_db) const;
616 /// infer view from method selection
617 short method_view(const ProblemDescDB& problem_db) const;
618 /// infer view from type of response data set
619 short response_view(const ProblemDescDB& problem_db) const;
620
621 /// perform sanity checks on view.first and view.second after update
622 void check_view_compatibility();
623
624 /// read a Variables object from an archive
625 template<class Archive>
626 void load(Archive& ar, const unsigned int version);
627
628 /// write a Variables object to an archive
629 template<class Archive>
630 void save(Archive& ar, const unsigned int version) const;
631
632 BOOST_SERIALIZATION_SPLIT_MEMBER()
633
634
635 //
636 //- Heading: Data
637 //
638
639 /// pointer to the letter (initialized only for the envelope)
640 std::shared_ptr<Variables> variablesRep;
641 };
642
643
shared_data() const644 inline const SharedVariablesData& Variables::shared_data() const
645 { return (variablesRep) ? variablesRep->sharedVarsData : sharedVarsData; }
646
647
shared_data()648 inline SharedVariablesData& Variables::shared_data()
649 { return (variablesRep) ? variablesRep->sharedVarsData : sharedVarsData; }
650
651
652 // nonvirtual functions can access letter attributes directly (only need to fwd
653 // member function call when the function could be redefined).
tv() const654 inline size_t Variables::tv() const
655 {
656 return (variablesRep) ? variablesRep->tv() :
657 allContinuousVars.length() + allDiscreteIntVars.length() +
658 allDiscreteStringVars.size() + allDiscreteRealVars.length();
659 }
660
661
total_active() const662 inline size_t Variables::total_active() const
663 {
664 return (variablesRep) ? variablesRep->total_active() :
665 cv() + div() + dsv() + drv();
666 }
667
668
cv() const669 inline size_t Variables::cv() const
670 { return shared_data().cv(); }
671
672
cv_start() const673 inline size_t Variables::cv_start() const
674 { return shared_data().cv_start(); }
675
676
div() const677 inline size_t Variables::div() const
678 { return shared_data().div(); }
679
680
div_start() const681 inline size_t Variables::div_start() const
682 { return shared_data().div_start(); }
683
684
dsv() const685 inline size_t Variables::dsv() const
686 { return shared_data().dsv(); }
687
688
dsv_start() const689 inline size_t Variables::dsv_start() const
690 { return shared_data().dsv_start(); }
691
692
drv() const693 inline size_t Variables::drv() const
694 { return shared_data().drv(); }
695
696
drv_start() const697 inline size_t Variables::drv_start() const
698 { return shared_data().drv_start(); }
699
700
icv() const701 inline size_t Variables::icv() const
702 { return shared_data().icv(); }
703
704
icv_start() const705 inline size_t Variables::icv_start() const
706 { return shared_data().icv_start(); }
707
708
idiv() const709 inline size_t Variables::idiv() const
710 { return shared_data().idiv(); }
711
712
idiv_start() const713 inline size_t Variables::idiv_start() const
714 { return shared_data().idiv_start(); }
715
716
idsv() const717 inline size_t Variables::idsv() const
718 { return shared_data().idsv(); }
719
720
idsv_start() const721 inline size_t Variables::idsv_start() const
722 { return shared_data().idsv_start(); }
723
724
idrv() const725 inline size_t Variables::idrv() const
726 { return shared_data().idrv(); }
727
728
idrv_start() const729 inline size_t Variables::idrv_start() const
730 { return shared_data().idrv_start(); }
731
732
acv() const733 inline size_t Variables::acv() const
734 {
735 return (variablesRep) ? variablesRep->allContinuousVars.length() :
736 allContinuousVars.length();
737 }
738
739
adiv() const740 inline size_t Variables::adiv() const
741 {
742 return (variablesRep) ? variablesRep->allDiscreteIntVars.length() :
743 allDiscreteIntVars.length();
744 }
745
746
adsv() const747 inline size_t Variables::adsv() const
748 {
749 return (variablesRep) ? variablesRep->allDiscreteStringVars.size() :
750 allDiscreteStringVars.size();
751 }
752
753
adrv() const754 inline size_t Variables::adrv() const
755 {
756 return (variablesRep) ? variablesRep->allDiscreteRealVars.length() :
757 allDiscreteRealVars.length();
758 }
759
760
continuous_variable(Real c_var,size_t index)761 inline void Variables::continuous_variable(Real c_var, size_t index)
762 {
763 if (variablesRep) variablesRep->continuousVars[index] = c_var;
764 else continuousVars[index] = c_var;
765 }
766
767
continuous_variable(size_t index) const768 inline Real Variables::continuous_variable(size_t index) const
769 {
770 if (variablesRep) return variablesRep->continuousVars[index];
771 else return continuousVars[index];
772 }
773
774
continuous_variables() const775 inline const RealVector& Variables::continuous_variables() const
776 { return (variablesRep) ? variablesRep->continuousVars : continuousVars; }
777
778
779 inline void Variables::
continuous_variables(const RealVector & c_vars)780 continuous_variables(const RealVector& c_vars)
781 {
782 // continuousVars is a view; use assign() to update the data it points to
783 if (variablesRep) variablesRep->continuousVars.assign(c_vars);
784 else continuousVars.assign(c_vars);
785 }
786
787
discrete_int_variable(int di_var,size_t index)788 inline void Variables::discrete_int_variable(int di_var, size_t index)
789 {
790 if (variablesRep) variablesRep->discreteIntVars[index] = di_var;
791 else discreteIntVars[index] = di_var;
792 }
793
794
discrete_int_variable(size_t index) const795 inline int Variables::discrete_int_variable(size_t index) const
796 {
797 if (variablesRep) return variablesRep->discreteIntVars[index];
798 else return discreteIntVars[index];
799 }
800
801
discrete_int_variables() const802 inline const IntVector& Variables::discrete_int_variables() const
803 { return (variablesRep) ? variablesRep->discreteIntVars : discreteIntVars; }
804
805
discrete_int_variables(const IntVector & di_vars)806 inline void Variables::discrete_int_variables(const IntVector& di_vars)
807 {
808 // discreteIntVars is a view; use assign() to update the data it points to
809 if (variablesRep) variablesRep->discreteIntVars.assign(di_vars);
810 else discreteIntVars.assign(di_vars);
811 }
812
813
814 inline void Variables::
discrete_string_variable(const String & ds_var,size_t index)815 discrete_string_variable(const String& ds_var, size_t index)
816 {
817 if (variablesRep)
818 variablesRep->discrete_string_variable(ds_var, index);
819 else
820 allDiscreteStringVars[sharedVarsData.dsv_start()+index] = ds_var;
821 }
822
823
discrete_string_variable(size_t index) const824 inline const String& Variables::discrete_string_variable(size_t index) const
825 {
826 if (variablesRep)
827 return variablesRep->discrete_string_variable(index);
828 else
829 return allDiscreteStringVars[sharedVarsData.dsv_start()+index];
830 }
831
832
discrete_string_variables() const833 inline StringMultiArrayConstView Variables::discrete_string_variables() const
834 {
835 return (variablesRep) ?
836 variablesRep->discrete_string_variables() :
837 allDiscreteStringVars[boost::indices[idx_range(sharedVarsData.dsv_start(),
838 sharedVarsData.dsv())]];
839 }
840
841
842 inline void Variables::
discrete_string_variables(StringMultiArrayConstView ds_vars)843 discrete_string_variables(StringMultiArrayConstView ds_vars)
844 {
845 if (variablesRep)
846 variablesRep->discrete_string_variables(ds_vars);
847 else
848 allDiscreteStringVars[boost::indices[
849 idx_range(sharedVarsData.dsv_start(), sharedVarsData.dsv())]] = ds_vars;
850 }
851
852
853 inline void Variables::
discrete_real_variable(Real dr_var,size_t index)854 discrete_real_variable(Real dr_var, size_t index)
855 {
856 if (variablesRep) variablesRep->discreteRealVars[index] = dr_var;
857 else discreteRealVars[index] = dr_var;
858 }
859
860
discrete_real_variable(size_t index) const861 inline Real Variables::discrete_real_variable(size_t index) const
862 {
863 if (variablesRep) return variablesRep->discreteRealVars[index];
864 else return discreteRealVars[index];
865 }
866
867
discrete_real_variables() const868 inline const RealVector& Variables::discrete_real_variables() const
869 { return (variablesRep) ? variablesRep->discreteRealVars : discreteRealVars; }
870
871
discrete_real_variables(const RealVector & dr_vars)872 inline void Variables::discrete_real_variables(const RealVector& dr_vars)
873 {
874 // discreteRealVars is a view; use assign() to update the data it points to
875 if (variablesRep) variablesRep->discreteRealVars.assign(dr_vars);
876 else discreteRealVars.assign(dr_vars);
877 }
878
879
active_variables(const Variables & vars)880 inline void Variables::active_variables(const Variables& vars)
881 {
882 // Set active variables only, leaving remainder of data unchanged (e.g.,
883 // so that inactive vars can vary between iterators/models w/i a strategy).
884 if (variablesRep)
885 variablesRep->active_variables(vars);
886 else {
887 if (vars.cv()) continuous_variables(vars.continuous_variables());
888 if (vars.div()) discrete_int_variables(vars.discrete_int_variables());
889 if (vars.dsv()) discrete_string_variables(vars.discrete_string_variables());
890 if (vars.drv()) discrete_real_variables(vars.discrete_real_variables());
891 }
892 }
893
894
all_variables(const Variables & vars)895 inline void Variables::all_variables(const Variables& vars)
896 {
897 // Set all variables
898 if (variablesRep)
899 variablesRep->all_variables(vars);
900 else {
901 if (vars.acv())
902 all_continuous_variables(vars.all_continuous_variables());
903 if (vars.adiv())
904 all_discrete_int_variables(vars.all_discrete_int_variables());
905 if (vars.adsv())
906 all_discrete_string_variables(vars.all_discrete_string_variables());
907 if (vars.adrv())
908 all_discrete_real_variables(vars.all_discrete_real_variables());
909 }
910 }
911
912
continuous_variables_view()913 inline RealVector& Variables::continuous_variables_view()
914 { return (variablesRep) ? variablesRep->continuousVars : continuousVars; }
915
916
discrete_int_variables_view()917 inline IntVector& Variables::discrete_int_variables_view()
918 { return (variablesRep) ? variablesRep->discreteIntVars : discreteIntVars; }
919
920
921 /** same as discrete_string_variables(), except mutable view */
discrete_string_variables_view()922 inline StringMultiArrayView Variables::discrete_string_variables_view()
923 {
924 return (variablesRep) ?
925 variablesRep->discrete_string_variables_view() :
926 allDiscreteStringVars[boost::indices[idx_range(sharedVarsData.dsv_start(),
927 sharedVarsData.dsv())]];
928 }
929
930
discrete_real_variables_view()931 inline RealVector& Variables::discrete_real_variables_view()
932 { return (variablesRep) ? variablesRep->discreteRealVars : discreteRealVars; }
933
934
continuous_variable_labels() const935 inline StringMultiArrayConstView Variables::continuous_variable_labels() const
936 {
937 const SharedVariablesData& svd = shared_data();
938 return svd.all_continuous_labels(svd.cv_start(), svd.cv());
939 }
940
941
942 inline void Variables::
continuous_variable_labels(StringMultiArrayConstView cv_labels)943 continuous_variable_labels(StringMultiArrayConstView cv_labels)
944 {
945 SharedVariablesData& svd = shared_data();
946 svd.all_continuous_labels(cv_labels, svd.cv_start(), svd.cv());
947 }
948
949
950 inline void Variables::
continuous_variable_label(const String & cv_label,size_t index)951 continuous_variable_label(const String& cv_label, size_t index)
952 {
953 SharedVariablesData& svd = shared_data();
954 svd.all_continuous_label(cv_label, svd.cv_start()+index);
955 }
956
957
discrete_int_variable_labels() const958 inline StringMultiArrayConstView Variables::discrete_int_variable_labels() const
959 {
960 const SharedVariablesData& svd = shared_data();
961 return svd.all_discrete_int_labels(svd.div_start(), svd.div());
962 }
963
964
965 inline void Variables::
discrete_int_variable_labels(StringMultiArrayConstView div_labels)966 discrete_int_variable_labels(StringMultiArrayConstView div_labels)
967 {
968 SharedVariablesData& svd = shared_data();
969 svd.all_discrete_int_labels(div_labels, svd.div_start(), svd.div());
970 }
971
972
973 inline void Variables::
discrete_int_variable_label(const String & div_label,size_t index)974 discrete_int_variable_label(const String& div_label, size_t index)
975 {
976 SharedVariablesData& svd = shared_data();
977 svd.all_discrete_int_label(div_label, svd.div_start()+index);
978 }
979
980
981 inline StringMultiArrayConstView Variables::
discrete_string_variable_labels() const982 discrete_string_variable_labels() const
983 {
984 const SharedVariablesData& svd = shared_data();
985 return svd.all_discrete_string_labels(svd.dsv_start(), svd.dsv());
986 }
987
988
989 inline void Variables::
discrete_string_variable_labels(StringMultiArrayConstView dsv_labels)990 discrete_string_variable_labels(StringMultiArrayConstView dsv_labels)
991 {
992 SharedVariablesData& svd = shared_data();
993 svd.all_discrete_string_labels(dsv_labels, svd.dsv_start(), svd.dsv());
994 }
995
996
997 inline void Variables::
discrete_string_variable_label(const String & dsv_label,size_t index)998 discrete_string_variable_label(const String& dsv_label, size_t index)
999 {
1000 SharedVariablesData& svd = shared_data();
1001 svd.all_discrete_string_label(dsv_label, svd.dsv_start()+index);
1002 }
1003
1004
1005 inline StringMultiArrayConstView Variables::
discrete_real_variable_labels() const1006 discrete_real_variable_labels() const
1007 {
1008 const SharedVariablesData& svd = shared_data();
1009 return svd.all_discrete_real_labels(svd.drv_start(), svd.drv());
1010 }
1011
1012
1013 inline void Variables::
discrete_real_variable_labels(StringMultiArrayConstView drv_labels)1014 discrete_real_variable_labels(StringMultiArrayConstView drv_labels)
1015 {
1016 SharedVariablesData& svd = shared_data();
1017 svd.all_discrete_real_labels(drv_labels, svd.drv_start(), svd.drv());
1018 }
1019
1020
1021 inline void Variables::
discrete_real_variable_label(const String & drv_label,size_t index)1022 discrete_real_variable_label(const String& drv_label, size_t index)
1023 {
1024 SharedVariablesData& svd = shared_data();
1025 svd.all_discrete_real_label(drv_label, svd.drv_start()+index);
1026 }
1027
1028
continuous_variable_types() const1029 inline UShortMultiArrayConstView Variables::continuous_variable_types() const
1030 {
1031 const SharedVariablesData& svd = shared_data();
1032 return svd.all_continuous_types(svd.cv_start(), svd.cv());
1033 }
1034
1035
1036 inline void Variables::
continuous_variable_types(UShortMultiArrayConstView cv_types)1037 continuous_variable_types(UShortMultiArrayConstView cv_types)
1038 {
1039 SharedVariablesData& svd = shared_data();
1040 svd.all_continuous_types(cv_types, svd.cv_start(), svd.cv());
1041 }
1042
1043
1044 inline void Variables::
continuous_variable_type(unsigned short cv_type,size_t index)1045 continuous_variable_type(unsigned short cv_type, size_t index)
1046 {
1047 SharedVariablesData& svd = shared_data();
1048 svd.all_continuous_type(cv_type, svd.cv_start() + index);
1049 }
1050
1051
discrete_int_variable_types() const1052 inline UShortMultiArrayConstView Variables::discrete_int_variable_types() const
1053 {
1054 const SharedVariablesData& svd = shared_data();
1055 return svd.all_discrete_int_types(svd.div_start(), svd.div());
1056 }
1057
1058
1059 inline void Variables::
discrete_int_variable_types(UShortMultiArrayConstView div_types)1060 discrete_int_variable_types(UShortMultiArrayConstView div_types)
1061 {
1062 SharedVariablesData& svd = shared_data();
1063 svd.all_discrete_int_types(div_types, svd.div_start(), svd.div());
1064 }
1065
1066
1067 inline void Variables::
discrete_int_variable_type(unsigned short div_type,size_t index)1068 discrete_int_variable_type(unsigned short div_type, size_t index)
1069 {
1070 SharedVariablesData& svd = shared_data();
1071 svd.all_discrete_int_type(div_type, svd.div_start() + index);
1072 }
1073
1074
1075 inline UShortMultiArrayConstView Variables::
discrete_string_variable_types() const1076 discrete_string_variable_types() const
1077 {
1078 const SharedVariablesData& svd = shared_data();
1079 return svd.all_discrete_string_types(svd.dsv_start(), svd.dsv());
1080 }
1081
1082
1083 inline void Variables::
discrete_string_variable_types(UShortMultiArrayConstView dsv_types)1084 discrete_string_variable_types(UShortMultiArrayConstView dsv_types)
1085 {
1086 SharedVariablesData& svd = shared_data();
1087 svd.all_discrete_string_types(dsv_types, svd.dsv_start(), svd.dsv());
1088 }
1089
1090
1091 inline void Variables::
discrete_string_variable_type(unsigned short dsv_type,size_t index)1092 discrete_string_variable_type(unsigned short dsv_type, size_t index)
1093 {
1094 SharedVariablesData& svd = shared_data();
1095 svd.all_discrete_string_type(dsv_type, svd.dsv_start() + index);
1096 }
1097
1098
discrete_real_variable_types() const1099 inline UShortMultiArrayConstView Variables::discrete_real_variable_types() const
1100 {
1101 const SharedVariablesData& svd = shared_data();
1102 return svd.all_discrete_real_types(svd.drv_start(), svd.drv());
1103 }
1104
1105
1106 inline void Variables::
discrete_real_variable_types(UShortMultiArrayConstView drv_types)1107 discrete_real_variable_types(UShortMultiArrayConstView drv_types)
1108 {
1109 SharedVariablesData& svd = shared_data();
1110 svd.all_discrete_real_types(drv_types, svd.drv_start(), svd.drv());
1111 }
1112
1113
1114 inline void Variables::
discrete_real_variable_type(unsigned short drv_type,size_t index)1115 discrete_real_variable_type(unsigned short drv_type, size_t index)
1116 {
1117 SharedVariablesData& svd = shared_data();
1118 svd.all_discrete_real_type(drv_type, svd.drv_start() + index);
1119 }
1120
1121
continuous_variable_ids() const1122 inline SizetMultiArrayConstView Variables::continuous_variable_ids() const
1123 {
1124 const SharedVariablesData& svd = shared_data();
1125 return svd.all_continuous_ids(svd.cv_start(), svd.cv());
1126 }
1127
1128
continuous_variable_ids(SizetMultiArrayConstView cv_ids)1129 inline void Variables::continuous_variable_ids(SizetMultiArrayConstView cv_ids)
1130 {
1131 SharedVariablesData& svd = shared_data();
1132 svd.all_continuous_ids(cv_ids, svd.cv_start(), svd.cv());
1133 }
1134
1135
continuous_variable_id(size_t cv_id,size_t index)1136 inline void Variables::continuous_variable_id(size_t cv_id, size_t index)
1137 {
1138 SharedVariablesData& svd = shared_data();
1139 svd.all_continuous_id(cv_id, svd.cv_start() + index);
1140 }
1141
1142
1143 //inline const SizetArray& Variables::relaxed_discrete_ids() const
1144 //{ return shared_data().relaxed_discrete_ids(); }
1145
1146
inactive_continuous_variables() const1147 inline const RealVector& Variables::inactive_continuous_variables() const
1148 {
1149 return (variablesRep) ? variablesRep->inactiveContinuousVars :
1150 inactiveContinuousVars;
1151 }
1152
1153
inactive_continuous_variables(const RealVector & ic_vars)1154 inline void Variables::inactive_continuous_variables(const RealVector& ic_vars)
1155 {
1156 // use assign() to update the data the view points to
1157 if (variablesRep) variablesRep->inactiveContinuousVars.assign(ic_vars);
1158 else inactiveContinuousVars.assign(ic_vars);
1159 }
1160
1161
inactive_continuous_variable(Real ic_var,size_t index)1162 inline void Variables::inactive_continuous_variable(Real ic_var, size_t index)
1163 {
1164 // use assign() to update the data the view points to
1165 if (variablesRep) variablesRep->inactiveContinuousVars[index] = ic_var;
1166 else inactiveContinuousVars[index] = ic_var;
1167 }
1168
1169
inactive_discrete_int_variables() const1170 inline const IntVector& Variables::inactive_discrete_int_variables() const
1171 {
1172 return (variablesRep) ? variablesRep->inactiveDiscreteIntVars :
1173 inactiveDiscreteIntVars;
1174 }
1175
1176
1177 inline void Variables::
inactive_discrete_int_variables(const IntVector & idi_vars)1178 inactive_discrete_int_variables(const IntVector& idi_vars)
1179 {
1180 // use assign() to update the data the view points to
1181 if (variablesRep) variablesRep->inactiveDiscreteIntVars.assign(idi_vars);
1182 else inactiveDiscreteIntVars.assign(idi_vars);
1183 }
1184
1185
inactive_discrete_int_variable(int idi_var,size_t index)1186 inline void Variables::inactive_discrete_int_variable(int idi_var, size_t index)
1187 {
1188 // use assign() to update the data the view points to
1189 if (variablesRep) variablesRep->inactiveDiscreteIntVars[index] = idi_var;
1190 else inactiveDiscreteIntVars[index] = idi_var;
1191 }
1192
1193
1194 inline StringMultiArrayConstView Variables::
inactive_discrete_string_variables() const1195 inactive_discrete_string_variables() const
1196 {
1197 return (variablesRep) ? variablesRep->inactive_discrete_string_variables() :
1198 allDiscreteStringVars[boost::indices[idx_range(sharedVarsData.idsv_start(),
1199 sharedVarsData.idsv())]];
1200 }
1201
1202
1203 inline void Variables::
inactive_discrete_string_variables(StringMultiArrayConstView ids_vars)1204 inactive_discrete_string_variables(StringMultiArrayConstView ids_vars)
1205 {
1206 if (variablesRep)
1207 variablesRep->inactive_discrete_string_variables(ids_vars);
1208 else
1209 allDiscreteStringVars[boost::indices[
1210 idx_range(sharedVarsData.idsv_start(),sharedVarsData.idsv())]] = ids_vars;
1211 }
1212
1213
1214 inline void Variables::
inactive_discrete_string_variable(const String & ids_var,size_t index)1215 inactive_discrete_string_variable(const String& ids_var, size_t index)
1216 {
1217 if (variablesRep)
1218 variablesRep->inactive_discrete_string_variable(ids_var, index);
1219 else
1220 allDiscreteStringVars[sharedVarsData.idsv_start()+index] = ids_var;
1221 }
1222
1223
inactive_discrete_real_variables() const1224 inline const RealVector& Variables::inactive_discrete_real_variables() const
1225 {
1226 return (variablesRep) ? variablesRep->inactiveDiscreteRealVars :
1227 inactiveDiscreteRealVars;
1228 }
1229
1230
1231 inline void Variables::
inactive_discrete_real_variables(const RealVector & idr_vars)1232 inactive_discrete_real_variables(const RealVector& idr_vars)
1233 {
1234 // use assign() to update the data the view points to
1235 if (variablesRep) variablesRep->inactiveDiscreteRealVars.assign(idr_vars);
1236 else inactiveDiscreteRealVars.assign(idr_vars);
1237 }
1238
1239
1240 inline void Variables::
inactive_discrete_real_variable(Real idr_var,size_t index)1241 inactive_discrete_real_variable(Real idr_var, size_t index)
1242 {
1243 // use assign() to update the data the view points to
1244 if (variablesRep) variablesRep->inactiveDiscreteRealVars[index] = idr_var;
1245 else inactiveDiscreteRealVars[index] = idr_var;
1246 }
1247
1248
1249 inline StringMultiArrayConstView Variables::
inactive_continuous_variable_labels() const1250 inactive_continuous_variable_labels() const
1251 {
1252 const SharedVariablesData& svd = shared_data();
1253 return svd.all_continuous_labels(svd.icv_start(), svd.icv());
1254 }
1255
1256
1257 inline void Variables::
inactive_continuous_variable_labels(StringMultiArrayConstView icv_labels)1258 inactive_continuous_variable_labels(StringMultiArrayConstView icv_labels)
1259 {
1260 SharedVariablesData& svd = shared_data();
1261 svd.all_continuous_labels(icv_labels, svd.icv_start(), svd.icv());
1262 }
1263
1264
1265 inline StringMultiArrayConstView Variables::
inactive_discrete_int_variable_labels() const1266 inactive_discrete_int_variable_labels() const
1267 {
1268 const SharedVariablesData& svd = shared_data();
1269 return svd.all_discrete_int_labels(svd.idiv_start(), svd.idiv());
1270 }
1271
1272
1273 inline void Variables::
inactive_discrete_int_variable_labels(StringMultiArrayConstView idiv_labels)1274 inactive_discrete_int_variable_labels(StringMultiArrayConstView idiv_labels)
1275 {
1276 SharedVariablesData& svd = shared_data();
1277 svd.all_discrete_int_labels(idiv_labels, svd.idiv_start(), svd.idiv());
1278 }
1279
1280
1281 inline StringMultiArrayConstView Variables::
inactive_discrete_string_variable_labels() const1282 inactive_discrete_string_variable_labels() const
1283 {
1284 const SharedVariablesData& svd = shared_data();
1285 return svd.all_discrete_string_labels(svd.idsv_start(), svd.idsv());
1286 }
1287
1288
1289 inline void Variables::
inactive_discrete_string_variable_labels(StringMultiArrayConstView idsv_labels)1290 inactive_discrete_string_variable_labels(StringMultiArrayConstView idsv_labels)
1291 {
1292 SharedVariablesData& svd = shared_data();
1293 svd.all_discrete_string_labels(idsv_labels, svd.idsv_start(), svd.idsv());
1294 }
1295
1296
1297 inline StringMultiArrayConstView Variables::
inactive_discrete_real_variable_labels() const1298 inactive_discrete_real_variable_labels() const
1299 {
1300 const SharedVariablesData& svd = shared_data();
1301 return svd.all_discrete_real_labels(svd.idrv_start(), svd.idrv());
1302 }
1303
1304
1305 inline void Variables::
inactive_discrete_real_variable_labels(StringMultiArrayConstView idrv_labels)1306 inactive_discrete_real_variable_labels(StringMultiArrayConstView idrv_labels)
1307 {
1308 SharedVariablesData& svd = shared_data();
1309 svd.all_discrete_real_labels(idrv_labels, svd.idrv_start(), svd.idrv());
1310 }
1311
1312
1313 inline UShortMultiArrayConstView Variables::
inactive_continuous_variable_types() const1314 inactive_continuous_variable_types() const
1315 {
1316 const SharedVariablesData& svd = shared_data();
1317 return svd.all_continuous_types(svd.icv_start(), svd.icv());
1318 }
1319
1320
1321 inline UShortMultiArrayConstView Variables::
inactive_discrete_int_variable_types() const1322 inactive_discrete_int_variable_types() const
1323 {
1324 const SharedVariablesData& svd = shared_data();
1325 return svd.all_discrete_int_types(svd.idiv_start(), svd.idiv());
1326 }
1327
1328
1329 inline UShortMultiArrayConstView Variables::
inactive_discrete_string_variable_types() const1330 inactive_discrete_string_variable_types() const
1331 {
1332 const SharedVariablesData& svd = shared_data();
1333 return svd.all_discrete_string_types(svd.idsv_start(), svd.idsv());
1334 }
1335
1336
1337 inline UShortMultiArrayConstView Variables::
inactive_discrete_real_variable_types() const1338 inactive_discrete_real_variable_types() const
1339 {
1340 const SharedVariablesData& svd = shared_data();
1341 return svd.all_discrete_real_types(svd.idrv_start(), svd.idrv());
1342 }
1343
1344
1345 inline SizetMultiArrayConstView Variables::
inactive_continuous_variable_ids() const1346 inactive_continuous_variable_ids() const
1347 {
1348 const SharedVariablesData& svd = shared_data();
1349 return svd.all_continuous_ids(svd.icv_start(), svd.icv());
1350 }
1351
1352
all_continuous_variables() const1353 inline const RealVector& Variables::all_continuous_variables() const
1354 { return (variablesRep) ? variablesRep->allContinuousVars : allContinuousVars; }
1355
1356
all_continuous_variables(const RealVector & ac_vars)1357 inline void Variables::all_continuous_variables(const RealVector& ac_vars)
1358 {
1359 if (variablesRep) variablesRep->allContinuousVars.assign(ac_vars);
1360 else allContinuousVars.assign(ac_vars);
1361 }
1362
1363
1364 inline void Variables::
all_continuous_variable(Real ac_var,size_t index)1365 all_continuous_variable(Real ac_var, size_t index)
1366 {
1367 if (variablesRep) variablesRep->allContinuousVars[index] = ac_var;
1368 else allContinuousVars[index] = ac_var;
1369 }
1370
1371
all_discrete_int_variables() const1372 inline const IntVector& Variables::all_discrete_int_variables() const
1373 {
1374 return (variablesRep) ? variablesRep->allDiscreteIntVars
1375 : allDiscreteIntVars;
1376 }
1377
1378
all_discrete_int_variables(const IntVector & adi_vars)1379 inline void Variables::all_discrete_int_variables(const IntVector& adi_vars)
1380 {
1381 if (variablesRep) variablesRep->allDiscreteIntVars.assign(adi_vars);
1382 else allDiscreteIntVars.assign(adi_vars);
1383 }
1384
1385
all_discrete_int_variable(int adi_var,size_t index)1386 inline void Variables::all_discrete_int_variable(int adi_var, size_t index)
1387 {
1388 if (variablesRep) variablesRep->allDiscreteIntVars[index] = adi_var;
1389 else allDiscreteIntVars[index] = adi_var;
1390 }
1391
1392
1393 inline StringMultiArrayConstView Variables::
all_discrete_string_variables() const1394 all_discrete_string_variables() const
1395 {
1396 return (variablesRep) ?
1397 variablesRep->allDiscreteStringVars[boost::indices[idx_range(0, adsv())]] :
1398 allDiscreteStringVars[boost::indices[idx_range(0, adsv())]];
1399 }
1400
1401
1402 inline void Variables::
all_discrete_string_variables(StringMultiArrayConstView ads_vars)1403 all_discrete_string_variables(StringMultiArrayConstView ads_vars)
1404 {
1405 if (variablesRep) variablesRep->allDiscreteStringVars = ads_vars;
1406 else allDiscreteStringVars = ads_vars; // TO DO: check boost size
1407 }
1408
1409
1410 inline void Variables::
all_discrete_string_variable(const String & ads_var,size_t index)1411 all_discrete_string_variable(const String& ads_var, size_t index)
1412 {
1413 if (variablesRep) variablesRep->allDiscreteStringVars[index] = ads_var;
1414 else allDiscreteStringVars[index] = ads_var;
1415 }
1416
1417
all_discrete_real_variables() const1418 inline const RealVector& Variables::all_discrete_real_variables() const
1419 {
1420 return (variablesRep) ? variablesRep->allDiscreteRealVars :
1421 allDiscreteRealVars;
1422 }
1423
1424
all_discrete_real_variables(const RealVector & adr_vars)1425 inline void Variables::all_discrete_real_variables(const RealVector& adr_vars)
1426 {
1427 if (variablesRep) variablesRep->allDiscreteRealVars.assign(adr_vars);
1428 else allDiscreteRealVars.assign(adr_vars);
1429 }
1430
1431
1432 inline void Variables::
all_discrete_real_variable(Real adr_var,size_t index)1433 all_discrete_real_variable(Real adr_var, size_t index)
1434 {
1435 if (variablesRep) variablesRep->allDiscreteRealVars[index] = adr_var;
1436 else allDiscreteRealVars[index] = adr_var;
1437 }
1438
1439
all_continuous_variable_labels() const1440 inline StringMultiArrayView Variables::all_continuous_variable_labels() const
1441 { return shared_data().all_continuous_labels(0, acv()); }
1442
1443
1444 inline void Variables::
all_continuous_variable_labels(StringMultiArrayConstView acv_labels)1445 all_continuous_variable_labels(StringMultiArrayConstView acv_labels)
1446 { shared_data().all_continuous_labels(acv_labels, 0, acv()); }
1447
1448
1449 inline void Variables::
all_continuous_variable_label(const String & acv_label,size_t index)1450 all_continuous_variable_label(const String& acv_label, size_t index)
1451 { shared_data().all_continuous_label(acv_label, index); }
1452
1453
all_discrete_int_variable_labels() const1454 inline StringMultiArrayView Variables::all_discrete_int_variable_labels() const
1455 { return shared_data().all_discrete_int_labels(0, adiv()); }
1456
1457
1458 inline void Variables::
all_discrete_int_variable_labels(StringMultiArrayConstView adiv_labels)1459 all_discrete_int_variable_labels(StringMultiArrayConstView adiv_labels)
1460 { shared_data().all_discrete_int_labels(adiv_labels, 0, adiv()); }
1461
1462
1463 inline void Variables::
all_discrete_int_variable_label(const String & adiv_label,size_t index)1464 all_discrete_int_variable_label(const String& adiv_label, size_t index)
1465 { shared_data().all_discrete_int_label(adiv_label, index); }
1466
1467
1468 inline StringMultiArrayView Variables::
all_discrete_string_variable_labels() const1469 all_discrete_string_variable_labels() const
1470 { return shared_data().all_discrete_string_labels(0, adsv()); }
1471
1472
1473 inline void Variables::
all_discrete_string_variable_labels(StringMultiArrayConstView adsv_labels)1474 all_discrete_string_variable_labels(StringMultiArrayConstView adsv_labels)
1475 { shared_data().all_discrete_string_labels(adsv_labels, 0, adsv()); }
1476
1477
1478 inline void Variables::
all_discrete_string_variable_label(const String & adsv_label,size_t index)1479 all_discrete_string_variable_label(const String& adsv_label, size_t index)
1480 { shared_data().all_discrete_string_label(adsv_label, index); }
1481
1482
all_discrete_real_variable_labels() const1483 inline StringMultiArrayView Variables::all_discrete_real_variable_labels() const
1484 { return shared_data().all_discrete_real_labels(0, adrv()); }
1485
1486
1487 inline void Variables::
all_discrete_real_variable_labels(StringMultiArrayConstView adrv_labels)1488 all_discrete_real_variable_labels(StringMultiArrayConstView adrv_labels)
1489 { shared_data().all_discrete_real_labels(adrv_labels, 0, adrv()); }
1490
1491
1492 inline void Variables::
all_discrete_real_variable_label(const String & adrv_label,size_t index)1493 all_discrete_real_variable_label(const String& adrv_label, size_t index)
1494 { shared_data().all_discrete_real_label(adrv_label, index); }
1495
1496
1497 inline UShortMultiArrayConstView Variables::
all_continuous_variable_types() const1498 all_continuous_variable_types() const
1499 { return shared_data().all_continuous_types(0, acv()); }
1500
1501
1502 inline UShortMultiArrayConstView Variables::
all_discrete_int_variable_types() const1503 all_discrete_int_variable_types() const
1504 { return shared_data().all_discrete_int_types(0, adiv()); }
1505
1506
1507 inline UShortMultiArrayConstView Variables::
all_discrete_string_variable_types() const1508 all_discrete_string_variable_types() const
1509 { return shared_data().all_discrete_string_types(0, adsv()); }
1510
1511
1512 inline UShortMultiArrayConstView Variables::
all_discrete_real_variable_types() const1513 all_discrete_real_variable_types() const
1514 { return shared_data().all_discrete_real_types(0, adrv()); }
1515
1516
all_continuous_variable_ids() const1517 inline SizetMultiArrayConstView Variables::all_continuous_variable_ids() const
1518 { return shared_data().all_continuous_ids(0, acv()); }
1519
all_discrete_int_variable_ids() const1520 inline SizetMultiArrayConstView Variables::all_discrete_int_variable_ids() const
1521 { return shared_data().all_discrete_int_ids(0, adiv()); }
1522
all_discrete_string_variable_ids() const1523 inline SizetMultiArrayConstView Variables::all_discrete_string_variable_ids() const
1524 { return shared_data().all_discrete_string_ids(0, adsv()); }
1525
all_discrete_real_variable_ids() const1526 inline SizetMultiArrayConstView Variables::all_discrete_real_variable_ids() const
1527 { return shared_data().all_discrete_real_ids(0, adrv()); }
1528
1529
view() const1530 inline const std::pair<short,short>& Variables::view() const
1531 { return shared_data().view(); }
1532
1533
variables_id() const1534 inline const String& Variables::variables_id() const
1535 { return shared_data().id(); }
1536
1537
variables_components_totals() const1538 inline const SizetArray& Variables::variables_components_totals() const
1539 { return shared_data().components_totals(); }
1540
1541
is_null() const1542 inline bool Variables::is_null() const
1543 { return (variablesRep == NULL); }
1544
1545
build_views()1546 inline void Variables::build_views()
1547 {
1548 // called only from letters
1549 const std::pair<short,short>& view = sharedVarsData.view();
1550 if (view.first != EMPTY_VIEW)
1551 build_active_views();
1552 if (view.second != EMPTY_VIEW)
1553 build_inactive_views();
1554 }
1555
1556
1557 /// global comparison function for Variables
variables_id_compare(const Variables & vars,const void * id)1558 inline bool variables_id_compare(const Variables& vars, const void* id)
1559 { return ( *(const String*)id == vars.variables_id() ); }
1560
1561
1562 // Having overloaded operators call read/write means that the operators need
1563 // not be a friend to private data because read/write functions are public.
1564
1565 /// std::istream extraction operator for Variables.
operator >>(std::istream & s,Variables & vars)1566 inline std::istream& operator>>(std::istream& s, Variables& vars)
1567 { vars.read(s); return s; }
1568
1569
1570 /// std::ostream insertion operator for Variables.
operator <<(std::ostream & s,const Variables & vars)1571 inline std::ostream& operator<<(std::ostream& s, const Variables& vars)
1572 { vars.write(s); return s; }
1573
1574
1575 /// MPIUnpackBuffer extraction operator for Variables.
operator >>(MPIUnpackBuffer & s,Variables & vars)1576 inline MPIUnpackBuffer& operator>>(MPIUnpackBuffer& s, Variables& vars)
1577 { vars.read(s); return s; }
1578
1579
1580 /// MPIPackBuffer insertion operator for Variables.
operator <<(MPIPackBuffer & s,const Variables & vars)1581 inline MPIPackBuffer& operator<<(MPIPackBuffer& s, const Variables& vars)
1582 { vars.write(s); return s; }
1583
1584
1585 /// inequality operator for Variables
operator !=(const Variables & vars1,const Variables & vars2)1586 inline bool operator!=(const Variables& vars1, const Variables& vars2)
1587 { return !(vars1 == vars2); }
1588
1589
1590 /// free function to write Variables data vectors in input spec ordering
1591 /** written for arbitrary types, but typical use will be ScalarType1 = Real,
1592 ScalarType2 = int, ScalarType3 = string, and ScalarType4 = int or Real. */
1593 template <typename OrdinalType, typename ScalarType1, typename ScalarType2,
1594 typename ScalarType3, typename ScalarType4>
write_ordered(std::ostream & s,const SizetArray & comp_totals,const Teuchos::SerialDenseVector<OrdinalType,ScalarType1> & c_vector,const Teuchos::SerialDenseVector<OrdinalType,ScalarType2> & di_vector,const Teuchos::SerialDenseVector<OrdinalType,ScalarType3> & ds_vector,const Teuchos::SerialDenseVector<OrdinalType,ScalarType4> & dr_vector)1595 inline void write_ordered(std::ostream& s, const SizetArray& comp_totals,
1596 const Teuchos::SerialDenseVector<OrdinalType, ScalarType1>& c_vector,
1597 const Teuchos::SerialDenseVector<OrdinalType, ScalarType2>& di_vector,
1598 const Teuchos::SerialDenseVector<OrdinalType, ScalarType3>& ds_vector,
1599 const Teuchos::SerialDenseVector<OrdinalType, ScalarType4>& dr_vector)
1600 {
1601 size_t i, j,
1602 num_cdv = comp_totals[TOTAL_CDV], num_ddiv = comp_totals[TOTAL_DDIV],
1603 num_ddsv = comp_totals[TOTAL_DDSV], num_ddrv = comp_totals[TOTAL_DDRV],
1604 num_cauv = comp_totals[TOTAL_CAUV], num_dauiv = comp_totals[TOTAL_DAUIV],
1605 num_dausv = comp_totals[TOTAL_DAUSV], num_daurv = comp_totals[TOTAL_DAURV],
1606 num_ceuv = comp_totals[TOTAL_CEUV], num_deuiv = comp_totals[TOTAL_DEUIV],
1607 num_deusv = comp_totals[TOTAL_DEUSV], num_deurv = comp_totals[TOTAL_DEURV],
1608 num_csv = comp_totals[TOTAL_CSV], num_dsiv = comp_totals[TOTAL_DSIV],
1609 num_dssv = comp_totals[TOTAL_DSSV], num_dsrv = comp_totals[TOTAL_DSRV],
1610 cv_cntr = 0, div_cntr = 0, dsv_cntr = 0, drv_cntr = 0;
1611
1612 // design
1613 write_data_partial(s, cv_cntr, num_cdv, c_vector);
1614 write_data_partial(s, div_cntr, num_ddiv, di_vector);
1615 write_data_partial(s, dsv_cntr, num_ddsv, ds_vector);
1616 write_data_partial(s, drv_cntr, num_ddrv, dr_vector);
1617 cv_cntr += num_cdv; div_cntr += num_ddiv;
1618 dsv_cntr += num_ddsv; drv_cntr += num_ddrv;
1619 // aleatory uncertain
1620 write_data_partial(s, cv_cntr, num_cauv, c_vector);
1621 write_data_partial(s, div_cntr, num_dauiv, di_vector);
1622 write_data_partial(s, dsv_cntr, num_dausv, ds_vector);
1623 write_data_partial(s, drv_cntr, num_daurv, dr_vector);
1624 cv_cntr += num_cauv; div_cntr += num_dauiv;
1625 dsv_cntr += num_dausv; drv_cntr += num_daurv;
1626 // epistemic uncertain
1627 write_data_partial(s, cv_cntr, num_ceuv, c_vector);
1628 write_data_partial(s, div_cntr, num_deuiv, di_vector);
1629 write_data_partial(s, dsv_cntr, num_deusv, ds_vector);
1630 write_data_partial(s, drv_cntr, num_deurv, dr_vector);
1631 cv_cntr += num_ceuv; div_cntr += num_deuiv;
1632 dsv_cntr += num_deusv; drv_cntr += num_deurv;
1633 // state
1634 write_data_partial(s, cv_cntr, num_csv, c_vector);
1635 write_data_partial(s, div_cntr, num_dsiv, di_vector);
1636 write_data_partial(s, dsv_cntr, num_dssv, ds_vector);
1637 write_data_partial(s, drv_cntr, num_dsrv, dr_vector);
1638 //cv_cntr += num_csv; div_cntr += num_dsiv;
1639 //dsv_cntr += num_dssv; drv_cntr += num_dsrv;
1640 }
1641
1642
1643 /// free function to write Variables data vectors in input spec ordering
1644 /** written for arbitrary types, but typical use will be ScalarType1 = Real,
1645 ScalarType2 = int, ScalarType3 = string, and ScalarType4 = int or Real. */
1646 template <typename OrdinalType, typename ScalarType1, typename ScalarType2,
1647 typename ScalarType3, typename ScalarType4>
write_ordered(std::ostream & s,const SizetArray & comp_totals,const Teuchos::SerialDenseVector<OrdinalType,ScalarType1> & c_vector,const Teuchos::SerialDenseVector<OrdinalType,ScalarType2> & di_vector,const boost::multi_array<ScalarType3,1> & ds_array,const Teuchos::SerialDenseVector<OrdinalType,ScalarType4> & dr_vector)1648 inline void write_ordered(std::ostream& s, const SizetArray& comp_totals,
1649 const Teuchos::SerialDenseVector<OrdinalType, ScalarType1>& c_vector,
1650 const Teuchos::SerialDenseVector<OrdinalType, ScalarType2>& di_vector,
1651 const boost::multi_array<ScalarType3, 1>& ds_array,
1652 const Teuchos::SerialDenseVector<OrdinalType, ScalarType4>& dr_vector)
1653 {
1654 size_t i, j,
1655 num_cdv = comp_totals[TOTAL_CDV], num_ddiv = comp_totals[TOTAL_DDIV],
1656 num_ddsv = comp_totals[TOTAL_DDSV], num_ddrv = comp_totals[TOTAL_DDRV],
1657 num_cauv = comp_totals[TOTAL_CAUV], num_dauiv = comp_totals[TOTAL_DAUIV],
1658 num_dausv = comp_totals[TOTAL_DAUSV], num_daurv = comp_totals[TOTAL_DAURV],
1659 num_ceuv = comp_totals[TOTAL_CEUV], num_deuiv = comp_totals[TOTAL_DEUIV],
1660 num_deusv = comp_totals[TOTAL_DEUSV], num_deurv = comp_totals[TOTAL_DEURV],
1661 num_csv = comp_totals[TOTAL_CSV], num_dsiv = comp_totals[TOTAL_DSIV],
1662 num_dssv = comp_totals[TOTAL_DSSV], num_dsrv = comp_totals[TOTAL_DSRV],
1663 cv_cntr = 0, div_cntr = 0, dsv_cntr = 0, drv_cntr = 0;
1664
1665 // design
1666 write_data_partial(s, cv_cntr, num_cdv, c_vector);
1667 write_data_partial(s, div_cntr, num_ddiv, di_vector);
1668 write_data_partial(s, dsv_cntr, num_ddsv, ds_array);
1669 write_data_partial(s, drv_cntr, num_ddrv, dr_vector);
1670 cv_cntr += num_cdv; div_cntr += num_ddiv;
1671 dsv_cntr += num_ddsv; drv_cntr += num_ddrv;
1672 // aleatory uncertain
1673 write_data_partial(s, cv_cntr, num_cauv, c_vector);
1674 write_data_partial(s, div_cntr, num_dauiv, di_vector);
1675 write_data_partial(s, dsv_cntr, num_dausv, ds_array);
1676 write_data_partial(s, drv_cntr, num_daurv, dr_vector);
1677 cv_cntr += num_cauv; div_cntr += num_dauiv;
1678 dsv_cntr += num_dausv; drv_cntr += num_daurv;
1679 // epistemic uncertain
1680 write_data_partial(s, cv_cntr, num_ceuv, c_vector);
1681 write_data_partial(s, div_cntr, num_deuiv, di_vector);
1682 write_data_partial(s, dsv_cntr, num_deusv, ds_array);
1683 write_data_partial(s, drv_cntr, num_deurv, dr_vector);
1684 cv_cntr += num_ceuv; div_cntr += num_deuiv;
1685 dsv_cntr += num_deusv; drv_cntr += num_deurv;
1686 // state
1687 write_data_partial(s, cv_cntr, num_csv, c_vector);
1688 write_data_partial(s, div_cntr, num_dsiv, di_vector);
1689 write_data_partial(s, dsv_cntr, num_dssv, ds_array);
1690 write_data_partial(s, drv_cntr, num_dsrv, dr_vector);
1691 //cv_cntr += num_csv; div_cntr += num_dsiv;
1692 //dsv_cntr += num_dssv; drv_cntr += num_dsrv;
1693 }
1694
1695
1696 /// free function to write Variables data vectors in input spec ordering
1697 template <typename ScalarType>
write_ordered(std::ostream & s,const SizetArray & comp_totals,const std::vector<ScalarType> & c_array,const std::vector<ScalarType> & di_array,const std::vector<ScalarType> & ds_array,const std::vector<ScalarType> & dr_array)1698 inline void write_ordered(std::ostream& s, const SizetArray& comp_totals,
1699 const std::vector<ScalarType>& c_array,
1700 const std::vector<ScalarType>& di_array,
1701 const std::vector<ScalarType>& ds_array,
1702 const std::vector<ScalarType>& dr_array)
1703 {
1704 size_t i, j,
1705 num_cdv = comp_totals[TOTAL_CDV], num_ddiv = comp_totals[TOTAL_DDIV],
1706 num_ddsv = comp_totals[TOTAL_DDSV], num_ddrv = comp_totals[TOTAL_DDRV],
1707 num_cauv = comp_totals[TOTAL_CAUV], num_dauiv = comp_totals[TOTAL_DAUIV],
1708 num_dausv = comp_totals[TOTAL_DAUSV], num_daurv = comp_totals[TOTAL_DAURV],
1709 num_ceuv = comp_totals[TOTAL_CEUV], num_deuiv = comp_totals[TOTAL_DEUIV],
1710 num_deusv = comp_totals[TOTAL_DEUSV], num_deurv = comp_totals[TOTAL_DEURV],
1711 num_csv = comp_totals[TOTAL_CSV], num_dsiv = comp_totals[TOTAL_DSIV],
1712 num_dssv = comp_totals[TOTAL_DSSV], num_dsrv = comp_totals[TOTAL_DSRV],
1713 cv_cntr = 0, div_cntr = 0, dsv_cntr = 0, drv_cntr = 0;
1714
1715 // design
1716 write_data_partial(s, cv_cntr, num_cdv, c_array);
1717 write_data_partial(s, div_cntr, num_ddiv, di_array);
1718 write_data_partial(s, dsv_cntr, num_ddsv, ds_array);
1719 write_data_partial(s, drv_cntr, num_ddrv, dr_array);
1720 cv_cntr += num_cdv; div_cntr += num_ddiv;
1721 dsv_cntr += num_ddsv; drv_cntr += num_ddrv;
1722 // aleatory uncertain
1723 write_data_partial(s, cv_cntr, num_cauv, c_array);
1724 write_data_partial(s, div_cntr, num_dauiv, di_array);
1725 write_data_partial(s, dsv_cntr, num_dausv, ds_array);
1726 write_data_partial(s, drv_cntr, num_daurv, dr_array);
1727 cv_cntr += num_cauv; div_cntr += num_dauiv;
1728 dsv_cntr += num_dausv; drv_cntr += num_daurv;
1729 // epistemic uncertain
1730 write_data_partial(s, cv_cntr, num_ceuv, c_array);
1731 write_data_partial(s, div_cntr, num_deuiv, di_array);
1732 write_data_partial(s, dsv_cntr, num_deusv, ds_array);
1733 write_data_partial(s, drv_cntr, num_deurv, dr_array);
1734 cv_cntr += num_ceuv; div_cntr += num_deuiv;
1735 dsv_cntr += num_deusv; drv_cntr += num_deurv;
1736 // state
1737 write_data_partial(s, cv_cntr, num_csv, c_array);
1738 write_data_partial(s, div_cntr, num_dsiv, di_array);
1739 write_data_partial(s, dsv_cntr, num_dssv, ds_array);
1740 write_data_partial(s, drv_cntr, num_dsrv, dr_array);
1741 //cv_cntr += num_csv; div_cntr += num_dsiv;
1742 //dsv_cntr += num_dssv; drv_cntr += num_dsrv;
1743 }
1744
1745 } // namespace Dakota
1746
1747
1748 // Since we may serialize this class through a temporary, force
1749 // serialization mode and no tracking
1750 BOOST_CLASS_IMPLEMENTATION(Dakota::Variables,
1751 boost::serialization::object_serializable)
1752 BOOST_CLASS_TRACKING(Dakota::Variables,
1753 boost::serialization::track_never)
1754
1755
1756 #endif
1757