suanPan
DomainBase.h
Go to the documentation of this file.
1 /*******************************************************************************
2  * Copyright (C) 2017-2022 Theodore Chang
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
16  ******************************************************************************/
35 #ifndef DOMAINBASE_H
36 #define DOMAINBASE_H
37 
38 #include <future>
39 #include <Domain/Tag.h>
40 #include <Toolbox/container.h>
41 
42 using std::future;
43 
44 template<sp_d T> class Factory;
45 class Amplitude;
46 class Constraint;
47 class Converger;
48 class Criterion;
49 class Database;
50 class Element;
51 class ExternalModule;
52 class Group;
53 class Integrator;
54 class Load;
55 class Material;
56 class Modifier;
57 class Node;
58 class Orientation;
59 class Recorder;
60 class Section;
61 class Solver;
62 class Step;
63 
64 using AmplitudeQueue = std::vector<shared_ptr<Amplitude>>;
65 using ConstraintQueue = std::vector<shared_ptr<Constraint>>;
66 using ConvergerQueue = std::vector<shared_ptr<Converger>>;
67 using CriterionQueue = std::vector<shared_ptr<Criterion>>;
68 using DatabaseQueue = std::vector<shared_ptr<Database>>;
69 using ElementQueue = std::vector<shared_ptr<Element>>;
70 using GroupQueue = std::vector<shared_ptr<Group>>;
71 using IntegratorQueue = std::vector<shared_ptr<Integrator>>;
72 using LoadQueue = std::vector<shared_ptr<Load>>;
73 using MaterialQueue = std::vector<shared_ptr<Material>>;
74 using ModifierQueue = std::vector<shared_ptr<Modifier>>;
75 using NodeQueue = std::vector<shared_ptr<Node>>;
76 using OrientationQueue = std::vector<shared_ptr<Orientation>>;
77 using RecorderQueue = std::vector<shared_ptr<Recorder>>;
78 using SectionQueue = std::vector<shared_ptr<Section>>;
79 using SolverQueue = std::vector<shared_ptr<Solver>>;
80 using StepQueue = std::map<unsigned, shared_ptr<Step>>;
81 
82 using LongFactory = Factory<double>;
83 
84 enum class ColorMethod {
85  OFF,
86  WP,
87  MIS
88 };
89 
90 class DomainBase : public Tag {
91 public:
92  explicit DomainBase(unsigned);
93  DomainBase(const DomainBase&) = delete; // copy forbidden
94  DomainBase(DomainBase&&) = delete; // move forbidden
95  DomainBase& operator=(const DomainBase&) = delete; // assign forbidden
96  DomainBase& operator=(DomainBase&&) = delete; // assign forbidden
97  ~DomainBase() override;
98 
99  virtual void set_factory(const shared_ptr<LongFactory>&) = 0;
100  [[nodiscard]] virtual const shared_ptr<LongFactory>& get_factory() const = 0;
101 
102  virtual bool insert(const shared_ptr<future<void>>&) = 0;
103 
104  virtual void wait() = 0;
105 
106  virtual bool insert(const shared_ptr<ExternalModule>&) = 0;
107  [[nodiscard]] virtual const std::vector<shared_ptr<ExternalModule>>& get_external_module_pool() const = 0;
108 
109  virtual bool insert(const shared_ptr<Amplitude>&) = 0;
110  virtual bool insert(const shared_ptr<Constraint>&) = 0;
111  virtual bool insert(const shared_ptr<Converger>&) = 0;
112  virtual bool insert(const shared_ptr<Criterion>&) = 0;
113  virtual bool insert(const shared_ptr<Database>&) = 0;
114  virtual bool insert(const shared_ptr<Element>&) = 0;
115  virtual bool insert(const shared_ptr<Group>&) = 0;
116  virtual bool insert(const shared_ptr<Integrator>&) = 0;
117  virtual bool insert(const shared_ptr<Load>&) = 0;
118  virtual bool insert(const shared_ptr<Material>&) = 0;
119  virtual bool insert(const shared_ptr<Modifier>&) = 0;
120  virtual bool insert(const shared_ptr<Node>&) = 0;
121  virtual bool insert(const shared_ptr<Orientation>&) = 0;
122  virtual bool insert(const shared_ptr<Recorder>&) = 0;
123  virtual bool insert(const shared_ptr<Section>&) = 0;
124  virtual bool insert(const shared_ptr<Solver>&) = 0;
125  virtual bool insert(const shared_ptr<Step>&) = 0;
126 
127  template<typename T> bool erase(unsigned);
128  virtual bool erase_amplitude(unsigned) = 0;
129  virtual bool erase_constraint(unsigned) = 0;
130  virtual bool erase_converger(unsigned) = 0;
131  virtual bool erase_criterion(unsigned) = 0;
132  virtual bool erase_database(unsigned) = 0;
133  virtual bool erase_element(unsigned) = 0;
134  virtual bool erase_group(unsigned) = 0;
135  virtual bool erase_integrator(unsigned) = 0;
136  virtual bool erase_load(unsigned) = 0;
137  virtual bool erase_material(unsigned) = 0;
138  virtual bool erase_modifier(unsigned) = 0;
139  virtual bool erase_node(unsigned) = 0;
140  virtual bool erase_orientation(unsigned) = 0;
141  virtual bool erase_recorder(unsigned) = 0;
142  virtual bool erase_section(unsigned) = 0;
143  virtual bool erase_solver(unsigned) = 0;
144  virtual bool erase_step(unsigned) = 0;
145 
146  virtual void disable_amplitude(unsigned) = 0;
147  virtual void disable_constraint(unsigned) = 0;
148  virtual void disable_converger(unsigned) = 0;
149  virtual void disable_criterion(unsigned) = 0;
150  virtual void disable_database(unsigned) = 0;
151  virtual void disable_element(unsigned) = 0;
152  virtual void disable_group(unsigned) = 0;
153  virtual void disable_integrator(unsigned) = 0;
154  virtual void disable_load(unsigned) = 0;
155  virtual void disable_material(unsigned) = 0;
156  virtual void disable_modifier(unsigned) = 0;
157  virtual void disable_node(unsigned) = 0;
158  virtual void disable_orientation(unsigned) = 0;
159  virtual void disable_recorder(unsigned) = 0;
160  virtual void disable_section(unsigned) = 0;
161  virtual void disable_solver(unsigned) = 0;
162  virtual void disable_step(unsigned) = 0;
163 
164  virtual void enable_amplitude(unsigned) = 0;
165  virtual void enable_constraint(unsigned) = 0;
166  virtual void enable_converger(unsigned) = 0;
167  virtual void enable_criterion(unsigned) = 0;
168  virtual void enable_database(unsigned) = 0;
169  virtual void enable_element(unsigned) = 0;
170  virtual void enable_group(unsigned) = 0;
171  virtual void enable_integrator(unsigned) = 0;
172  virtual void enable_load(unsigned) = 0;
173  virtual void enable_material(unsigned) = 0;
174  virtual void enable_modifier(unsigned) = 0;
175  virtual void enable_node(unsigned) = 0;
176  virtual void enable_orientation(unsigned) = 0;
177  virtual void enable_recorder(unsigned) = 0;
178  virtual void enable_section(unsigned) = 0;
179  virtual void enable_solver(unsigned) = 0;
180  virtual void enable_step(unsigned) = 0;
181 
182  template<typename T> const shared_ptr<T>& get(unsigned);
183  template<typename T> const shared_ptr<T>& get(uword);
184  template<typename T> std::vector<shared_ptr<T>> get(const uvec&);
185  [[nodiscard]] virtual const shared_ptr<Amplitude>& get_amplitude(unsigned) const = 0;
186  [[nodiscard]] virtual const shared_ptr<Constraint>& get_constraint(unsigned) const = 0;
187  [[nodiscard]] virtual const shared_ptr<Converger>& get_converger(unsigned) const = 0;
188  [[nodiscard]] virtual const shared_ptr<Criterion>& get_criterion(unsigned) const = 0;
189  [[nodiscard]] virtual const shared_ptr<Database>& get_database(unsigned) const = 0;
190  [[nodiscard]] virtual const shared_ptr<Element>& get_element(unsigned) const = 0;
191  [[nodiscard]] virtual const shared_ptr<Group>& get_group(unsigned) const = 0;
192  [[nodiscard]] virtual const shared_ptr<Integrator>& get_integrator(unsigned) const = 0;
193  [[nodiscard]] virtual const shared_ptr<Load>& get_load(unsigned) const = 0;
194  [[nodiscard]] virtual const shared_ptr<Material>& get_material(unsigned) const = 0;
195  [[nodiscard]] virtual const shared_ptr<Modifier>& get_modifier(unsigned) const = 0;
196  [[nodiscard]] virtual const shared_ptr<Node>& get_node(unsigned) const = 0;
197  [[nodiscard]] virtual const shared_ptr<Orientation>& get_orientation(unsigned) const = 0;
198  [[nodiscard]] virtual const shared_ptr<Recorder>& get_recorder(unsigned) const = 0;
199  [[nodiscard]] virtual const shared_ptr<Section>& get_section(unsigned) const = 0;
200  [[nodiscard]] virtual const shared_ptr<Solver>& get_solver(unsigned) const = 0;
201  [[nodiscard]] virtual const shared_ptr<Step>& get_step(unsigned) const = 0;
202 
203  template<typename T> const std::vector<shared_ptr<T>>& get_pool();
204  [[nodiscard]] virtual const AmplitudeQueue& get_amplitude_pool() const = 0;
205  [[nodiscard]] virtual const ConstraintQueue& get_constraint_pool() const = 0;
206  [[nodiscard]] virtual const ConvergerQueue& get_converger_pool() const = 0;
207  [[nodiscard]] virtual const CriterionQueue& get_criterion_pool() const = 0;
208  [[nodiscard]] virtual const DatabaseQueue& get_database_pool() const = 0;
209  [[nodiscard]] virtual const ElementQueue& get_element_pool() const = 0;
210  [[nodiscard]] virtual const GroupQueue& get_group_pool() const = 0;
211  [[nodiscard]] virtual const IntegratorQueue& get_integrator_pool() const = 0;
212  [[nodiscard]] virtual const LoadQueue& get_load_pool() const = 0;
213  [[nodiscard]] virtual const MaterialQueue& get_material_pool() const = 0;
214  [[nodiscard]] virtual const ModifierQueue& get_modifier_pool() const = 0;
215  [[nodiscard]] virtual const NodeQueue& get_node_pool() const = 0;
216  [[nodiscard]] virtual const OrientationQueue& get_orientation_pool() const = 0;
217  [[nodiscard]] virtual const RecorderQueue& get_recorder_pool() const = 0;
218  [[nodiscard]] virtual const SectionQueue& get_section_pool() const = 0;
219  [[nodiscard]] virtual const SolverQueue& get_solver_pool() const = 0;
220  [[nodiscard]] virtual const StepQueue& get_step_pool() const = 0;
221 
222  friend shared_ptr<Amplitude>& get_amplitude(const shared_ptr<DomainBase>&, unsigned);
223  friend shared_ptr<Constraint>& get_constraint(const shared_ptr<DomainBase>&, unsigned);
224  friend shared_ptr<Converger>& get_converger(const shared_ptr<DomainBase>&, unsigned);
225  friend shared_ptr<Criterion>& get_criterion(const shared_ptr<DomainBase>&, unsigned);
226  friend shared_ptr<Database>& get_database(const shared_ptr<DomainBase>&, unsigned);
227  friend shared_ptr<Element>& get_element(const shared_ptr<DomainBase>&, unsigned);
228  friend shared_ptr<Group>& get_group(const shared_ptr<DomainBase>&, unsigned);
229  friend shared_ptr<Integrator>& get_integrator(const shared_ptr<DomainBase>&, unsigned);
230  friend shared_ptr<Load>& get_load(const shared_ptr<DomainBase>&, unsigned);
231  friend shared_ptr<Material>& get_material(const shared_ptr<DomainBase>&, unsigned);
232  friend shared_ptr<Modifier>& get_modifier(const shared_ptr<DomainBase>&, unsigned);
233  friend shared_ptr<Node>& get_node(const shared_ptr<DomainBase>&, unsigned);
234  friend shared_ptr<Orientation>& get_orientation(const shared_ptr<DomainBase>&, unsigned);
235  friend shared_ptr<Recorder>& get_recorder(const shared_ptr<DomainBase>&, unsigned);
236  friend shared_ptr<Section>& get_section(const shared_ptr<DomainBase>&, unsigned);
237  friend shared_ptr<Solver>& get_solver(const shared_ptr<DomainBase>&, unsigned);
238  friend shared_ptr<Step>& get_step(const shared_ptr<DomainBase>&, unsigned);
239 
240  template<typename T> size_t get();
241  [[nodiscard]] virtual size_t get_amplitude() const = 0;
242  [[nodiscard]] virtual size_t get_constraint() const = 0;
243  [[nodiscard]] virtual size_t get_converger() const = 0;
244  [[nodiscard]] virtual size_t get_criterion() const = 0;
245  [[nodiscard]] virtual size_t get_database() const = 0;
246  [[nodiscard]] virtual size_t get_element() const = 0;
247  [[nodiscard]] virtual size_t get_group() const = 0;
248  [[nodiscard]] virtual size_t get_integrator() const = 0;
249  [[nodiscard]] virtual size_t get_load() const = 0;
250  [[nodiscard]] virtual size_t get_material() const = 0;
251  [[nodiscard]] virtual size_t get_modifier() const = 0;
252  [[nodiscard]] virtual size_t get_node() const = 0;
253  [[nodiscard]] virtual size_t get_orientation() const = 0;
254  [[nodiscard]] virtual size_t get_recorder() const = 0;
255  [[nodiscard]] virtual size_t get_section() const = 0;
256  [[nodiscard]] virtual size_t get_solver() const = 0;
257  [[nodiscard]] virtual size_t get_step() const = 0;
258 
259  template<typename T> bool find(unsigned);
260  template<typename T> bool find(uword);
261  template<typename T> bool find(const uvec&);
262  [[nodiscard]] virtual bool find_amplitude(unsigned) const = 0;
263  [[nodiscard]] virtual bool find_constraint(unsigned) const = 0;
264  [[nodiscard]] virtual bool find_converger(unsigned) const = 0;
265  [[nodiscard]] virtual bool find_criterion(unsigned) const = 0;
266  [[nodiscard]] virtual bool find_database(unsigned) const = 0;
267  [[nodiscard]] virtual bool find_element(unsigned) const = 0;
268  [[nodiscard]] virtual bool find_group(unsigned) const = 0;
269  [[nodiscard]] virtual bool find_integrator(unsigned) const = 0;
270  [[nodiscard]] virtual bool find_load(unsigned) const = 0;
271  [[nodiscard]] virtual bool find_material(unsigned) const = 0;
272  [[nodiscard]] virtual bool find_modifier(unsigned) const = 0;
273  [[nodiscard]] virtual bool find_node(unsigned) const = 0;
274  [[nodiscard]] virtual bool find_orientation(unsigned) const = 0;
275  [[nodiscard]] virtual bool find_recorder(unsigned) const = 0;
276  [[nodiscard]] virtual bool find_section(unsigned) const = 0;
277  [[nodiscard]] virtual bool find_solver(unsigned) const = 0;
278  [[nodiscard]] virtual bool find_step(unsigned) const = 0;
279 
280  virtual void set_current_step_tag(unsigned) = 0;
281  virtual void set_current_converger_tag(unsigned) = 0;
282  virtual void set_current_integrator_tag(unsigned) = 0;
283  virtual void set_current_solver_tag(unsigned) = 0;
284 
285  virtual unsigned get_current_step_tag() = 0;
286  virtual unsigned get_current_converger_tag() = 0;
287  virtual unsigned get_current_integrator_tag() = 0;
288  virtual unsigned get_current_solver_tag() = 0;
289 
290  [[nodiscard]] virtual const shared_ptr<Step>& get_current_step() const = 0;
291  [[nodiscard]] virtual const shared_ptr<Converger>& get_current_converger() const = 0;
292  [[nodiscard]] virtual const shared_ptr<Integrator>& get_current_integrator() const = 0;
293  [[nodiscard]] virtual const shared_ptr<Solver>& get_current_solver() const = 0;
294 
298  virtual void insert_loaded_dof(const uvec&) = 0;
302  virtual void insert_restrained_dof(const uvec&) = 0;
306  virtual void insert_constrained_dof(const uvec&) = 0;
307 
311  virtual void insert_loaded_dof(uword) = 0;
315  virtual void insert_restrained_dof(uword) = 0;
319  virtual void insert_constrained_dof(uword) = 0;
320 
321  [[nodiscard]] virtual const suanpan::unordered_set<uword>& get_loaded_dof() const = 0;
322  [[nodiscard]] virtual const suanpan::unordered_set<uword>& get_restrained_dof() const = 0;
323  [[nodiscard]] virtual const suanpan::unordered_set<uword>& get_constrained_dof() const = 0;
324 
325  [[nodiscard]] virtual bool is_updated() const = 0;
326  [[nodiscard]] virtual bool is_sparse() const = 0;
327 
328  virtual void set_color_model(ColorMethod) = 0;
329  [[nodiscard]] virtual const std::vector<std::vector<unsigned>>& get_color_map() const = 0;
330  [[nodiscard]] virtual std::pair<std::vector<unsigned>, suanpan::graph<unsigned>> get_element_connectivity(bool) = 0;
331 
332  virtual int reorder_dof() = 0;
333  virtual int assign_color() = 0;
334 
335  virtual int restart() = 0;
336  virtual int soft_restart() = 0;
337  virtual int initialize() = 0;
338  virtual int initialize_load() = 0;
339  virtual int initialize_constraint() = 0;
340  virtual int initialize_reference() = 0;
341 
342  [[nodiscard]] virtual int process_load(bool) = 0;
343  [[nodiscard]] virtual int process_constraint(bool) = 0;
344  [[nodiscard]] virtual int process_criterion() = 0;
345  [[nodiscard]] virtual int process_modifier() = 0;
346 
347  virtual void record() = 0;
348  virtual void enable_all() = 0;
349  virtual void summary() const = 0;
350 
351  virtual void update_current_resistance() const = 0;
352  virtual void update_current_damping_force() const = 0;
353  virtual void update_current_inertial_force() const = 0;
354 
355  virtual void assemble_resistance() const = 0;
356  virtual void assemble_damping_force() const = 0;
357  virtual void assemble_inertial_force() const = 0;
358 
359  virtual void assemble_initial_mass() const = 0;
360  virtual void assemble_current_mass() const = 0;
361  virtual void assemble_trial_mass() const = 0;
362  virtual void assemble_initial_damping() const = 0;
363  virtual void assemble_current_damping() const = 0;
364  virtual void assemble_trial_damping() const = 0;
365  virtual void assemble_initial_stiffness() const = 0;
366  virtual void assemble_current_stiffness() const = 0;
367  virtual void assemble_trial_stiffness() const = 0;
368  virtual void assemble_initial_geometry() const = 0;
369  virtual void assemble_current_geometry() const = 0;
370  virtual void assemble_trial_geometry() const = 0;
371 
372  virtual void erase_machine_error() const = 0;
373 
374  virtual void update_load() = 0;
375  virtual void update_constraint() = 0;
376 
377  virtual void assemble_load_stiffness() = 0;
378  virtual void assemble_constraint_stiffness() = 0;
379 
380  [[nodiscard]] virtual int update_current_status() const = 0;
381  [[nodiscard]] virtual int update_incre_status() const = 0;
382  [[nodiscard]] virtual int update_trial_status() const = 0;
383 
384  virtual void stage_status() = 0;
385  virtual void commit_status() const = 0;
386  virtual void clear_status() = 0;
387  virtual void reset_status() const = 0;
388 
389  virtual void save(string) = 0;
390 };
391 
392 template<typename T> bool DomainBase::erase(unsigned) { throw invalid_argument("unsupported"); }
393 
394 template<> inline bool DomainBase::erase<Amplitude>(const unsigned T) { return erase_amplitude(T); }
395 
396 template<> inline bool DomainBase::erase<Constraint>(const unsigned T) { return erase_constraint(T); }
397 
398 template<> inline bool DomainBase::erase<Converger>(const unsigned T) { return erase_converger(T); }
399 
400 template<> inline bool DomainBase::erase<Criterion>(const unsigned T) { return erase_criterion(T); }
401 
402 template<> inline bool DomainBase::erase<Database>(const unsigned T) { return erase_database(T); }
403 
404 template<> inline bool DomainBase::erase<Element>(const unsigned T) { return erase_element(T); }
405 
406 template<> inline bool DomainBase::erase<Group>(const unsigned T) { return erase_group(T); }
407 
408 template<> inline bool DomainBase::erase<Integrator>(const unsigned T) { return erase_integrator(T); }
409 
410 template<> inline bool DomainBase::erase<Load>(const unsigned T) { return erase_load(T); }
411 
412 template<> inline bool DomainBase::erase<Material>(const unsigned T) { return erase_material(T); }
413 
414 template<> inline bool DomainBase::erase<Modifier>(const unsigned T) { return erase_modifier(T); }
415 
416 template<> inline bool DomainBase::erase<Node>(const unsigned T) { return erase_node(T); }
417 
418 template<> inline bool DomainBase::erase<Orientation>(const unsigned T) { return erase_orientation(T); }
419 
420 template<> inline bool DomainBase::erase<Recorder>(const unsigned T) { return erase_recorder(T); }
421 
422 template<> inline bool DomainBase::erase<Section>(const unsigned T) { return erase_section(T); }
423 
424 template<> inline bool DomainBase::erase<Solver>(const unsigned T) { return erase_solver(T); }
425 
426 template<> inline bool DomainBase::erase<Step>(const unsigned T) { return erase_step(T); }
427 
428 template<typename T> const shared_ptr<T>& DomainBase::get(unsigned) { throw invalid_argument("unsupported"); }
429 
430 template<typename T> const shared_ptr<T>& DomainBase::get(uword) { throw invalid_argument("unsupported"); }
431 
432 template<typename T> std::vector<shared_ptr<T>> DomainBase::get(const uvec& P) {
433  std::vector<shared_ptr<T>> output;
434  output.reserve(P.n_elem);
435 
436  for(auto I : P) output.emplace_back(get<T>(I));
437 
438  return output;
439 }
440 
441 template<> inline const shared_ptr<Amplitude>& DomainBase::get<Amplitude>(const uword T) { return get_amplitude(static_cast<unsigned>(T)); }
442 
443 template<> inline const shared_ptr<Constraint>& DomainBase::get<Constraint>(const uword T) { return get_constraint(static_cast<unsigned>(T)); }
444 
445 template<> inline const shared_ptr<Converger>& DomainBase::get<Converger>(const uword T) { return get_converger(static_cast<unsigned>(T)); }
446 
447 template<> inline const shared_ptr<Criterion>& DomainBase::get<Criterion>(const uword T) { return get_criterion(static_cast<unsigned>(T)); }
448 
449 template<> inline const shared_ptr<Database>& DomainBase::get<Database>(const uword T) { return get_database(static_cast<unsigned>(T)); }
450 
451 template<> inline const shared_ptr<Element>& DomainBase::get<Element>(const uword T) { return get_element(static_cast<unsigned>(T)); }
452 
453 template<> inline const shared_ptr<Group>& DomainBase::get<Group>(const uword T) { return get_group(static_cast<unsigned>(T)); }
454 
455 template<> inline const shared_ptr<Integrator>& DomainBase::get<Integrator>(const uword T) { return get_integrator(static_cast<unsigned>(T)); }
456 
457 template<> inline const shared_ptr<Load>& DomainBase::get<Load>(const uword T) { return get_load(static_cast<unsigned>(T)); }
458 
459 template<> inline const shared_ptr<Material>& DomainBase::get<Material>(const uword T) { return get_material(static_cast<unsigned>(T)); }
460 
461 template<> inline const shared_ptr<Modifier>& DomainBase::get<Modifier>(const uword T) { return get_modifier(static_cast<unsigned>(T)); }
462 
463 template<> inline const shared_ptr<Node>& DomainBase::get<Node>(const uword T) { return get_node(static_cast<unsigned>(T)); }
464 
465 template<> inline const shared_ptr<Orientation>& DomainBase::get<Orientation>(const uword T) { return get_orientation(static_cast<unsigned>(T)); }
466 
467 template<> inline const shared_ptr<Recorder>& DomainBase::get<Recorder>(const uword T) { return get_recorder(static_cast<unsigned>(T)); }
468 
469 template<> inline const shared_ptr<Section>& DomainBase::get<Section>(const uword T) { return get_section(static_cast<unsigned>(T)); }
470 
471 template<> inline const shared_ptr<Solver>& DomainBase::get<Solver>(const uword T) { return get_solver(static_cast<unsigned>(T)); }
472 
473 template<> inline const shared_ptr<Step>& DomainBase::get<Step>(const uword T) { return get_step(static_cast<unsigned>(T)); }
474 
475 template<> inline const shared_ptr<Amplitude>& DomainBase::get<Amplitude>(const unsigned T) { return get_amplitude(T); }
476 
477 template<> inline const shared_ptr<Constraint>& DomainBase::get<Constraint>(const unsigned T) { return get_constraint(T); }
478 
479 template<> inline const shared_ptr<Converger>& DomainBase::get<Converger>(const unsigned T) { return get_converger(T); }
480 
481 template<> inline const shared_ptr<Criterion>& DomainBase::get<Criterion>(const unsigned T) { return get_criterion(T); }
482 
483 template<> inline const shared_ptr<Database>& DomainBase::get<Database>(const unsigned T) { return get_database(T); }
484 
485 template<> inline const shared_ptr<Element>& DomainBase::get<Element>(const unsigned T) { return get_element(T); }
486 
487 template<> inline const shared_ptr<Group>& DomainBase::get<Group>(const unsigned T) { return get_group(T); }
488 
489 template<> inline const shared_ptr<Integrator>& DomainBase::get<Integrator>(const unsigned T) { return get_integrator(T); }
490 
491 template<> inline const shared_ptr<Load>& DomainBase::get<Load>(const unsigned T) { return get_load(T); }
492 
493 template<> inline const shared_ptr<Material>& DomainBase::get<Material>(const unsigned T) { return get_material(T); }
494 
495 template<> inline const shared_ptr<Modifier>& DomainBase::get<Modifier>(const unsigned T) { return get_modifier(T); }
496 
497 template<> inline const shared_ptr<Node>& DomainBase::get<Node>(const unsigned T) { return get_node(T); }
498 
499 template<> inline const shared_ptr<Orientation>& DomainBase::get<Orientation>(const unsigned T) { return get_orientation(T); }
500 
501 template<> inline const shared_ptr<Recorder>& DomainBase::get<Recorder>(const unsigned T) { return get_recorder(T); }
502 
503 template<> inline const shared_ptr<Section>& DomainBase::get<Section>(const unsigned T) { return get_section(T); }
504 
505 template<> inline const shared_ptr<Solver>& DomainBase::get<Solver>(const unsigned T) { return get_solver(T); }
506 
507 template<> inline const shared_ptr<Step>& DomainBase::get<Step>(const unsigned T) { return get_step(T); }
508 
509 template<typename T> const std::vector<shared_ptr<T>>& DomainBase::get_pool() { throw invalid_argument("unsupported"); }
510 
511 template<> inline const std::vector<shared_ptr<Amplitude>>& DomainBase::get_pool<Amplitude>() { return get_amplitude_pool(); }
512 
513 template<> inline const std::vector<shared_ptr<Constraint>>& DomainBase::get_pool<Constraint>() { return get_constraint_pool(); }
514 
515 template<> inline const std::vector<shared_ptr<Converger>>& DomainBase::get_pool<Converger>() { return get_converger_pool(); }
516 
517 template<> inline const std::vector<shared_ptr<Criterion>>& DomainBase::get_pool<Criterion>() { return get_criterion_pool(); }
518 
519 template<> inline const std::vector<shared_ptr<Database>>& DomainBase::get_pool<Database>() { return get_database_pool(); }
520 
521 template<> inline const std::vector<shared_ptr<Element>>& DomainBase::get_pool<Element>() { return get_element_pool(); }
522 
523 template<> inline const std::vector<shared_ptr<Group>>& DomainBase::get_pool<Group>() { return get_group_pool(); }
524 
525 template<> inline const std::vector<shared_ptr<Integrator>>& DomainBase::get_pool<Integrator>() { return get_integrator_pool(); }
526 
527 template<> inline const std::vector<shared_ptr<Load>>& DomainBase::get_pool<Load>() { return get_load_pool(); }
528 
529 template<> inline const std::vector<shared_ptr<Material>>& DomainBase::get_pool<Material>() { return get_material_pool(); }
530 
531 template<> inline const std::vector<shared_ptr<Modifier>>& DomainBase::get_pool<Modifier>() { return get_modifier_pool(); }
532 
533 template<> inline const std::vector<shared_ptr<Node>>& DomainBase::get_pool<Node>() { return get_node_pool(); }
534 
535 template<> inline const std::vector<shared_ptr<Orientation>>& DomainBase::get_pool<Orientation>() { return get_orientation_pool(); }
536 
537 template<> inline const std::vector<shared_ptr<Recorder>>& DomainBase::get_pool<Recorder>() { return get_recorder_pool(); }
538 
539 template<> inline const std::vector<shared_ptr<Section>>& DomainBase::get_pool<Section>() { return get_section_pool(); }
540 
541 template<> inline const std::vector<shared_ptr<Solver>>& DomainBase::get_pool<Solver>() { return get_solver_pool(); }
542 
543 template<typename T> size_t DomainBase::get() { throw invalid_argument("unsupported"); }
544 
545 template<> inline size_t DomainBase::get<Amplitude>() { return get_amplitude(); }
546 
547 template<> inline size_t DomainBase::get<Constraint>() { return get_constraint(); }
548 
549 template<> inline size_t DomainBase::get<Converger>() { return get_converger(); }
550 
551 template<> inline size_t DomainBase::get<Criterion>() { return get_criterion(); }
552 
553 template<> inline size_t DomainBase::get<Database>() { return get_database(); }
554 
555 template<> inline size_t DomainBase::get<Element>() { return get_element(); }
556 
557 template<> inline size_t DomainBase::get<Group>() { return get_group(); }
558 
559 template<> inline size_t DomainBase::get<Integrator>() { return get_integrator(); }
560 
561 template<> inline size_t DomainBase::get<Load>() { return get_load(); }
562 
563 template<> inline size_t DomainBase::get<Material>() { return get_material(); }
564 
565 template<> inline size_t DomainBase::get<Modifier>() { return get_modifier(); }
566 
567 template<> inline size_t DomainBase::get<Node>() { return get_node(); }
568 
569 template<> inline size_t DomainBase::get<Orientation>() { return get_orientation(); }
570 
571 template<> inline size_t DomainBase::get<Recorder>() { return get_recorder(); }
572 
573 template<> inline size_t DomainBase::get<Section>() { return get_section(); }
574 
575 template<> inline size_t DomainBase::get<Solver>() { return get_solver(); }
576 
577 template<> inline size_t DomainBase::get<Step>() { return get_step(); }
578 
579 template<typename T> bool DomainBase::find(unsigned) { throw invalid_argument("unsupported"); }
580 
581 template<typename T> bool DomainBase::find(uword) { throw invalid_argument("unsupported"); }
582 
583 template<typename T> bool DomainBase::find(const uvec& P) {
584  for(auto I : P) if(!find<T>(I)) return false;
585 
586  return true;
587 }
588 
589 template<> inline bool DomainBase::find<Amplitude>(const uword T) { return find_amplitude(static_cast<unsigned>(T)); }
590 
591 template<> inline bool DomainBase::find<Constraint>(const uword T) { return find_constraint(static_cast<unsigned>(T)); }
592 
593 template<> inline bool DomainBase::find<Converger>(const uword T) { return find_converger(static_cast<unsigned>(T)); }
594 
595 template<> inline bool DomainBase::find<Criterion>(const uword T) { return find_criterion(static_cast<unsigned>(T)); }
596 
597 template<> inline bool DomainBase::find<Database>(const uword T) { return find_database(static_cast<unsigned>(T)); }
598 
599 template<> inline bool DomainBase::find<Element>(const uword T) { return find_element(static_cast<unsigned>(T)); }
600 
601 template<> inline bool DomainBase::find<Group>(const uword T) { return find_group(static_cast<unsigned>(T)); }
602 
603 template<> inline bool DomainBase::find<Integrator>(const uword T) { return find_integrator(static_cast<unsigned>(T)); }
604 
605 template<> inline bool DomainBase::find<Load>(const uword T) { return find_load(static_cast<unsigned>(T)); }
606 
607 template<> inline bool DomainBase::find<Material>(const uword T) { return find_material(static_cast<unsigned>(T)); }
608 
609 template<> inline bool DomainBase::find<Modifier>(const uword T) { return find_modifier(static_cast<unsigned>(T)); }
610 
611 template<> inline bool DomainBase::find<Node>(const uword T) { return find_node(static_cast<unsigned>(T)); }
612 
613 template<> inline bool DomainBase::find<Orientation>(const uword T) { return find_orientation(static_cast<unsigned>(T)); }
614 
615 template<> inline bool DomainBase::find<Recorder>(const uword T) { return find_recorder(static_cast<unsigned>(T)); }
616 
617 template<> inline bool DomainBase::find<Section>(const uword T) { return find_section(static_cast<unsigned>(T)); }
618 
619 template<> inline bool DomainBase::find<Solver>(const uword T) { return find_solver(static_cast<unsigned>(T)); }
620 
621 template<> inline bool DomainBase::find<Step>(const uword T) { return find_step(static_cast<unsigned>(T)); }
622 
623 template<> inline bool DomainBase::find<Amplitude>(const unsigned T) { return find_amplitude(T); }
624 
625 template<> inline bool DomainBase::find<Constraint>(const unsigned T) { return find_constraint(T); }
626 
627 template<> inline bool DomainBase::find<Converger>(const unsigned T) { return find_converger(T); }
628 
629 template<> inline bool DomainBase::find<Criterion>(const unsigned T) { return find_criterion(T); }
630 
631 template<> inline bool DomainBase::find<Database>(const unsigned T) { return find_database(T); }
632 
633 template<> inline bool DomainBase::find<Element>(const unsigned T) { return find_element(T); }
634 
635 template<> inline bool DomainBase::find<Group>(const unsigned T) { return find_group(T); }
636 
637 template<> inline bool DomainBase::find<Integrator>(const unsigned T) { return find_integrator(T); }
638 
639 template<> inline bool DomainBase::find<Load>(const unsigned T) { return find_load(T); }
640 
641 template<> inline bool DomainBase::find<Material>(const unsigned T) { return find_material(T); }
642 
643 template<> inline bool DomainBase::find<Modifier>(const unsigned T) { return find_modifier(T); }
644 
645 template<> inline bool DomainBase::find<Node>(const unsigned T) { return find_node(T); }
646 
647 template<> inline bool DomainBase::find<Orientation>(const unsigned T) { return find_orientation(T); }
648 
649 template<> inline bool DomainBase::find<Recorder>(const unsigned T) { return find_recorder(T); }
650 
651 template<> inline bool DomainBase::find<Section>(const unsigned T) { return find_section(T); }
652 
653 template<> inline bool DomainBase::find<Solver>(const unsigned T) { return find_solver(T); }
654 
655 template<> inline bool DomainBase::find<Step>(const unsigned T) { return find_step(T); }
656 
657 #endif
658 
get_integrator
shared_ptr< Integrator > & get_integrator(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:34
MaterialQueue
std::vector< shared_ptr< Material > > MaterialQueue
Definition: DomainBase.h:73
Element
A Element class.
Definition: Element.h:89
Node
The Node class holds the number of DoFs, coordinate, displacement, velocity and acceleration.
Definition: Node.h:77
ColorMethod::OFF
DomainBase
The DomainBase class is a template.
Definition: DomainBase.h:90
DomainBase::get_pool
const std::vector< shared_ptr< T > > & get_pool()
Definition: DomainBase.h:509
StepQueue
std::map< unsigned, shared_ptr< Step > > StepQueue
Definition: DomainBase.h:80
Factory
A Factory class.
Definition: DomainBase.h:44
get_group
shared_ptr< Group > & get_group(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:32
get_section
shared_ptr< Section > & get_section(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:48
NodeQueue
std::vector< shared_ptr< Node > > NodeQueue
Definition: DomainBase.h:75
CriterionQueue
std::vector< shared_ptr< Criterion > > CriterionQueue
Definition: DomainBase.h:67
get_material
shared_ptr< Material > & get_material(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:38
AmplitudeQueue
std::vector< shared_ptr< Amplitude > > AmplitudeQueue
Definition: DomainBase.h:64
SolverQueue
std::vector< shared_ptr< Solver > > SolverQueue
Definition: DomainBase.h:79
Section
A Section class.
Definition: Section.h:73
get_converger
shared_ptr< Converger > & get_converger(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:24
suanpan::graph
vector< set< T > > graph
Definition: container.h:59
Group
The Group class.
Definition: Group.h:36
get_load
shared_ptr< Load > & get_load(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:36
Amplitude
An Amplitude class that can generate Amplitude pattern.
Definition: Amplitude.h:67
get_recorder
shared_ptr< Recorder > & get_recorder(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:46
Modifier
A Modifier class.
Definition: Modifier.h:36
DomainBase::get
size_t get()
Definition: DomainBase.h:543
DOF::P
ColorMethod
ColorMethod
Definition: DomainBase.h:84
ConstraintQueue
std::vector< shared_ptr< Constraint > > ConstraintQueue
Definition: DomainBase.h:65
Material
A Material abstract base class.
Definition: Material.h:102
Solver
A Solver class defines solvers used in analysis.
Definition: Solver.h:38
DOF::T
ColorMethod::MIS
Tag.h
get_orientation
shared_ptr< Orientation > & get_orientation(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:44
GroupQueue
std::vector< shared_ptr< Group > > GroupQueue
Definition: DomainBase.h:70
Load
A Load class.
Definition: Load.h:37
Integrator
The Integrator class is basically a wrapper of the DomainBase class with regard to some status changi...
Definition: Integrator.h:46
SectionQueue
std::vector< shared_ptr< Section > > SectionQueue
Definition: DomainBase.h:78
get_modifier
shared_ptr< Modifier > & get_modifier(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:40
RecorderQueue
std::vector< shared_ptr< Recorder > > RecorderQueue
Definition: DomainBase.h:77
Converger
The Converger class handles converger test to indicate if the iteration converges according to variou...
Definition: Converger.h:44
Tag
A base Tag class.
Definition: Tag.h:38
Criterion
A Criterion class.
Definition: Criterion.h:38
OrientationQueue
std::vector< shared_ptr< Orientation > > OrientationQueue
Definition: DomainBase.h:76
DatabaseQueue
std::vector< shared_ptr< Database > > DatabaseQueue
Definition: DomainBase.h:68
get_step
shared_ptr< Step > & get_step(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:52
ExternalModule
A ExternalModule class handles communication between the main program and external library...
Definition: ExternalModule.h:45
IntegratorQueue
std::vector< shared_ptr< Integrator > > IntegratorQueue
Definition: DomainBase.h:71
get_database
shared_ptr< Database > & get_database(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:28
Database
A Database class is a top level container.
Definition: Database.h:33
DomainBase::find
bool find(unsigned)
Definition: DomainBase.h:579
get_element
shared_ptr< Element > & get_element(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:30
ElementQueue
std::vector< shared_ptr< Element > > ElementQueue
Definition: DomainBase.h:69
Step
A Step class.
Definition: Step.h:39
Orientation
A Orientation class.
Definition: Orientation.h:40
ModifierQueue
std::vector< shared_ptr< Modifier > > ModifierQueue
Definition: DomainBase.h:74
DomainBase::erase
bool erase(unsigned)
Definition: DomainBase.h:392
Recorder
A Recorder class.
Definition: Recorder.h:35
ConvergerQueue
std::vector< shared_ptr< Converger > > ConvergerQueue
Definition: DomainBase.h:66
ColorMethod::WP
get_constraint
shared_ptr< Constraint > & get_constraint(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:22
get_node
shared_ptr< Node > & get_node(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:42
suanpan::unordered_set
std::unordered_set< T > unordered_set
Definition: container.h:55
get_amplitude
shared_ptr< Amplitude > & get_amplitude(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:20
get_solver
shared_ptr< Solver > & get_solver(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:50
LoadQueue
std::vector< shared_ptr< Load > > LoadQueue
Definition: DomainBase.h:72
Constraint
A Constraint class.
Definition: Constraint.h:36
get_criterion
shared_ptr< Criterion > & get_criterion(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:26