suanPan
Factory.hpp
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  ******************************************************************************/
31 #ifndef FACTORY_HPP
32 #define FACTORY_HPP
33 
34 #include <future>
35 
36 #include "MetaMat/operator_times.hpp"
37 #include "Toolbox/container.h"
38 
39 enum class AnalysisType {
40  NONE,
41  DISP,
42  EIGEN,
43  BUCKLE,
44  STATICS,
45  DYNAMICS
46 };
47 
48 enum class StorageScheme {
49  FULL,
50  BAND,
51  BANDSYMM,
52  SYMMPACK,
53  SPARSE,
54  SPARSESYMM
55 };
56 
57 enum class SolverType {
58  LAPACK,
59  SPIKE,
60  SUPERLU,
61  MUMPS,
62  CUDA,
63  PARDISO,
64  FGMRES
65 };
66 
67 template<sp_d T> class Factory final {
68  unsigned n_size = 0; // number of degrees of freedom
69  unsigned n_lobw = 0; // low bandwidth
70  unsigned n_upbw = 0; // up bandwidth
71  unsigned n_sfbw = n_lobw + n_upbw; // matrix storage offset
72  unsigned n_rfld = 0; // reference load size
73  unsigned n_mpc = 0; // multipoint constraint size
74  uword n_elem = 0;
75 
76  AnalysisType analysis_type = AnalysisType::NONE; // type of analysis
77  StorageScheme storage_type = StorageScheme::FULL; // type of analysis
78 
79  bool nlgeom = false;
80 
81  double tolerance = 1E-14;
82  Precision precision = Precision::FULL;
83  SolverType solver = SolverType::LAPACK;
84  unsigned refinement = 10;
85 
86  T error = 0.; // error produced by certain solvers
87 
88  Col<T> ninja; // the result from A*X=B
89  Col<T> sushi; // modified right-hand side B
90 
91  suanpan::set<uword> reference_dof;
92  SpMat<T> reference_load;
93 
94  uvec auxiliary_encoding; // for constraints using multiplier method
95  Col<T> auxiliary_lambda; // for constraints using multiplier method
96  Col<T> auxiliary_resistance; // for constraints using multiplier method
97  Col<T> auxiliary_load; // for constraints using multiplier method
98  SpMat<T> auxiliary_stiffness; // for constraints using multiplier method
99 
100  SpCol<T> trial_constraint_resistance;
101  SpCol<T> current_constraint_resistance;
102 
103  T trial_time = 0.; // global trial (pseudo) time
104  T incre_time = 0.; // global incremental (pseudo) time
105  T current_time = 0.; // global current (pseudo) time
106  T pre_time = 0.; // global previous (pseudo) time
107 
108  T strain_energy = 0.;
109  T kinetic_energy = 0.;
110  T viscous_energy = 0.;
111  T complementary_energy = 0.;
112  Col<T> momentum;
113 
114  Col<T> trial_load_factor; // global trial load factor
115  Col<T> trial_load; // global trial load vector
116  Col<T> trial_settlement; // global trial displacement load vector
117  Col<T> trial_resistance; // global trial resistance vector
118  Col<T> trial_damping_force; // global trial damping force vector
119  Col<T> trial_inertial_force; // global trial inertial force vector
120  Col<T> trial_displacement; // global trial displacement vector
121  Col<T> trial_velocity; // global trial velocity vector
122  Col<T> trial_acceleration; // global trial acceleration vector
123  Col<T> trial_temperature; // global trial temperature vector
124 
125  Col<T> incre_load_factor; // global incremental load vector
126  Col<T> incre_load; // global incremental load vector
127  Col<T> incre_settlement; // global incremental displacement load vector
128  Col<T> incre_resistance; // global incremental resistance vector
129  Col<T> incre_damping_force; // global incremental damping force vector
130  Col<T> incre_inertial_force; // global incremental inertial force vector
131  Col<T> incre_displacement; // global incremental displacement vector
132  Col<T> incre_velocity; // global incremental velocity vector
133  Col<T> incre_acceleration; // global incremental acceleration vector
134  Col<T> incre_temperature; // global incremental temperature vector
135 
136  Col<T> current_load_factor; // global current load vector
137  Col<T> current_load; // global current load vector
138  Col<T> current_settlement; // global current displacement load vector
139  Col<T> current_resistance; // global current resistance vector
140  Col<T> current_damping_force; // global current damping force vector
141  Col<T> current_inertial_force; // global current inertial force vector
142  Col<T> current_displacement; // global current displacement vector
143  Col<T> current_velocity; // global current velocity vector
144  Col<T> current_acceleration; // global current acceleration vector
145  Col<T> current_temperature; // global current temperature vector
146 
147  Col<T> pre_load_factor; // global previous load vector
148  Col<T> pre_load; // global previous load vector
149  Col<T> pre_settlement; // global previous displacement load vector
150  Col<T> pre_resistance; // global previous resistance vector
151  Col<T> pre_damping_force; // global previous damping force vector
152  Col<T> pre_inertial_force; // global previous inertial force vector
153  Col<T> pre_displacement; // global previous displacement vector
154  Col<T> pre_velocity; // global previous velocity vector
155  Col<T> pre_acceleration; // global previous acceleration vector
156  Col<T> pre_temperature; // global previous temperature vector
157 
158  shared_ptr<MetaMat<T>> global_mass = nullptr; // global mass matrix
159  shared_ptr<MetaMat<T>> global_damping = nullptr; // global damping matrix
160  shared_ptr<MetaMat<T>> global_stiffness = nullptr; // global stiffness matrix
161  shared_ptr<MetaMat<T>> global_geometry = nullptr; // global geometry matrix
162 
163  std::vector<std::mutex> global_mutex = std::vector<std::mutex>(20);
164 
165  Col<T> eigenvalue; // eigenvalues
166 
167  Mat<T> eigenvector; // eigenvectors
168 
169  template<sp_d T1> friend unique_ptr<MetaMat<T1>> get_basic_container(const Factory<T1>*);
170  template<sp_d T1> friend unique_ptr<MetaMat<T1>> get_matrix_container(const Factory<T1>*);
171 
172 public:
173  const bool initialized = false;
174 
175  explicit Factory(unsigned = 0, AnalysisType = AnalysisType::NONE, StorageScheme = StorageScheme::FULL);
176 
177  void set_size(unsigned);
178  [[nodiscard]] unsigned get_size() const;
179 
180  void set_entry(uword);
181  [[nodiscard]] uword get_entry() const;
182 
183  void set_nlgeom(bool);
184  [[nodiscard]] bool is_nlgeom() const;
185 
186  void set_tolerance(double);
187  [[nodiscard]] double get_tolerance() const;
188 
189  void set_precision(Precision);
190  [[nodiscard]] Precision get_precision() const;
191 
192  void set_solver(SolverType);
193  [[nodiscard]] SolverType get_solver() const;
194 
195  void set_refinement(unsigned);
196 
197  void set_analysis_type(AnalysisType);
198  [[nodiscard]] AnalysisType get_analysis_type() const;
199 
200  void set_storage_scheme(StorageScheme);
201  [[nodiscard]] StorageScheme get_storage_scheme() const;
202 
203  [[nodiscard]] bool is_sparse() const;
204 
205  void set_bandwidth(unsigned, unsigned);
206  void get_bandwidth(unsigned&, unsigned&) const;
207 
208  void update_reference_size();
209  void set_reference_size(unsigned);
210  [[nodiscard]] unsigned get_reference_size() const;
211 
212  void update_reference_dof(const uvec&);
213  void set_reference_dof(const suanpan::set<uword>&);
214  [[nodiscard]] const suanpan::set<uword>& get_reference_dof() const;
215 
216  void set_error(const T&);
217  const T& get_error() const;
218 
219  /*************************INITIALIZER*************************/
220 
221  int initialize();
222 
223  void initialize_load_factor();
224  void initialize_load();
225  void initialize_settlement();
226  void initialize_resistance();
227  void initialize_damping_force();
228  void initialize_inertial_force();
229  void initialize_displacement();
230  void initialize_velocity();
231  void initialize_acceleration();
232  void initialize_temperature();
233  void initialize_auxiliary_resistance();
234 
235  void initialize_mass();
236  void initialize_damping();
237  void initialize_stiffness();
238  void initialize_geometry();
239  void initialize_eigen();
240 
241  /*************************SETTER*************************/
242 
243  void set_ninja(const Col<T>&);
244  void set_sushi(const Col<T>&);
245 
246  void set_mpc(unsigned);
247 
248  void set_reference_load(const SpMat<T>&);
249 
250  void set_trial_time(const T&);
251  void set_trial_load_factor(const Col<T>&);
252  void set_trial_load(const Col<T>&);
253  void set_trial_settlement(const Col<T>&);
254  void set_trial_resistance(const Col<T>&);
255  void set_trial_damping_force(const Col<T>&);
256  void set_trial_inertial_force(const Col<T>&);
257  void set_trial_displacement(const Col<T>&);
258  void set_trial_velocity(const Col<T>&);
259  void set_trial_acceleration(const Col<T>&);
260  void set_trial_temperature(const Col<T>&);
261 
262  void set_incre_time(const T&);
263  void set_incre_load_factor(const Col<T>&);
264  void set_incre_load(const Col<T>&);
265  void set_incre_settlement(const Col<T>&);
266  void set_incre_resistance(const Col<T>&);
267  void set_incre_damping_force(const Col<T>&);
268  void set_incre_inertial_force(const Col<T>&);
269  void set_incre_displacement(const Col<T>&);
270  void set_incre_velocity(const Col<T>&);
271  void set_incre_acceleration(const Col<T>&);
272  void set_incre_temperature(const Col<T>&);
273 
274  void set_current_time(const T&);
275  void set_current_load_factor(const Col<T>&);
276  void set_current_load(const Col<T>&);
277  void set_current_settlement(const Col<T>&);
278  void set_current_resistance(const Col<T>&);
279  void set_current_damping_force(const Col<T>&);
280  void set_current_inertial_force(const Col<T>&);
281  void set_current_displacement(const Col<T>&);
282  void set_current_velocity(const Col<T>&);
283  void set_current_acceleration(const Col<T>&);
284  void set_current_temperature(const Col<T>&);
285 
286  void set_pre_time(const T&);
287  void set_pre_load_factor(const Col<T>&);
288  void set_pre_load(const Col<T>&);
289  void set_pre_settlement(const Col<T>&);
290  void set_pre_resistance(const Col<T>&);
291  void set_pre_damping_force(const Col<T>&);
292  void set_pre_inertial_force(const Col<T>&);
293  void set_pre_displacement(const Col<T>&);
294  void set_pre_velocity(const Col<T>&);
295  void set_pre_acceleration(const Col<T>&);
296  void set_pre_temperature(const Col<T>&);
297 
298  void set_mass(const shared_ptr<MetaMat<T>>&);
299  void set_damping(const shared_ptr<MetaMat<T>>&);
300  void set_stiffness(const shared_ptr<MetaMat<T>>&);
301  void set_geometry(const shared_ptr<MetaMat<T>>&);
302 
303  void set_eigenvalue(const Col<T>&);
304  void set_eigenvector(const Mat<T>&);
305 
306  /*************************GETTER*************************/
307 
308  const Col<T>& get_ninja() const;
309  const Col<T>& get_sushi() const;
310 
311  [[nodiscard]] unsigned get_mpc() const;
312 
313  const SpMat<T>& get_reference_load() const;
314 
315  [[nodiscard]] const uvec& get_auxiliary_encoding() const;
316  const Col<T>& get_auxiliary_lambda() const;
317  const Col<T>& get_auxiliary_resistance() const;
318  const Col<T>& get_auxiliary_load() const;
319  const SpMat<T>& get_auxiliary_stiffness() const;
320 
321  const SpCol<T>& get_trial_constraint_resistance() const;
322  const SpCol<T>& get_current_constraint_resistance() const;
323 
324  T get_strain_energy();
325  T get_kinetic_energy();
326  T get_viscous_energy();
327  T get_complementary_energy();
328  const Col<T>& get_momentum();
329 
330  const T& get_trial_time() const;
331  const Col<T>& get_trial_load_factor() const;
332  const Col<T>& get_trial_load() const;
333  const Col<T>& get_trial_settlement() const;
334  const Col<T>& get_trial_resistance() const;
335  const Col<T>& get_trial_damping_force() const;
336  const Col<T>& get_trial_inertial_force() const;
337  const Col<T>& get_trial_displacement() const;
338  const Col<T>& get_trial_velocity() const;
339  const Col<T>& get_trial_acceleration() const;
340  const Col<T>& get_trial_temperature() const;
341 
342  const T& get_incre_time() const;
343  const Col<T>& get_incre_load_factor() const;
344  const Col<T>& get_incre_load() const;
345  const Col<T>& get_incre_settlement() const;
346  const Col<T>& get_incre_resistance() const;
347  const Col<T>& get_incre_damping_force() const;
348  const Col<T>& get_incre_inertial_force() const;
349  const Col<T>& get_incre_displacement() const;
350  const Col<T>& get_incre_velocity() const;
351  const Col<T>& get_incre_acceleration() const;
352  const Col<T>& get_incre_temperature() const;
353 
354  const T& get_current_time() const;
355  const Col<T>& get_current_load_factor() const;
356  const Col<T>& get_current_load() const;
357  const Col<T>& get_current_settlement() const;
358  const Col<T>& get_current_resistance() const;
359  const Col<T>& get_current_damping_force() const;
360  const Col<T>& get_current_inertial_force() const;
361  const Col<T>& get_current_displacement() const;
362  const Col<T>& get_current_velocity() const;
363  const Col<T>& get_current_acceleration() const;
364  const Col<T>& get_current_temperature() const;
365 
366  const T& get_pre_time() const;
367  const Col<T>& get_pre_load_factor() const;
368  const Col<T>& get_pre_load() const;
369  const Col<T>& get_pre_settlement() const;
370  const Col<T>& get_pre_resistance() const;
371  const Col<T>& get_pre_damping_force() const;
372  const Col<T>& get_pre_inertial_force() const;
373  const Col<T>& get_pre_displacement() const;
374  const Col<T>& get_pre_velocity() const;
375  const Col<T>& get_pre_acceleration() const;
376  const Col<T>& get_pre_temperature() const;
377 
378  const shared_ptr<MetaMat<T>>& get_mass() const;
379  const shared_ptr<MetaMat<T>>& get_damping() const;
380  const shared_ptr<MetaMat<T>>& get_stiffness() const;
381  const shared_ptr<MetaMat<T>>& get_geometry() const;
382 
383  std::mutex& get_auxiliary_encoding_mutex();
384  std::mutex& get_auxiliary_resistance_mutex();
385  std::mutex& get_auxiliary_load_mutex();
386  std::mutex& get_auxiliary_stiffness_mutex();
387 
388  std::mutex& get_trial_constraint_resistance_mutex();
389 
390  std::mutex& get_trial_load_mutex();
391  std::mutex& get_trial_settlement_mutex();
392 
393  std::mutex& get_mass_mutex();
394  std::mutex& get_damping_mutex();
395  std::mutex& get_stiffness_mutex();
396  std::mutex& get_geometry_mutex();
397 
398  const Col<T>& get_eigenvalue() const;
399  const Mat<T>& get_eigenvector() const;
400 
401  /*************************UPDATER*************************/
402 
403  void update_trial_time(const T&);
404  void update_trial_load_factor(const Col<T>&);
405  void update_trial_load(const Col<T>&);
406  void update_trial_settlement(const Col<T>&);
407  void update_trial_resistance(const Col<T>&);
408  void update_trial_damping_force(const Col<T>&);
409  void update_trial_inertial_force(const Col<T>&);
410  void update_trial_displacement(const Col<T>&);
411  void update_trial_velocity(const Col<T>&);
412  void update_trial_acceleration(const Col<T>&);
413  void update_trial_temperature(const Col<T>&);
414 
415  void update_incre_time(const T&);
416  void update_incre_load_factor(const Col<T>&);
417  void update_incre_load(const Col<T>&);
418  void update_incre_settlement(const Col<T>&);
419  void update_incre_resistance(const Col<T>&);
420  void update_incre_damping_force(const Col<T>&);
421  void update_incre_inertial_force(const Col<T>&);
422  void update_incre_displacement(const Col<T>&);
423  void update_incre_velocity(const Col<T>&);
424  void update_incre_acceleration(const Col<T>&);
425  void update_incre_temperature(const Col<T>&);
426 
427  void update_current_time(const T&);
428  void update_current_load_factor(const Col<T>&);
429  void update_current_load(const Col<T>&);
430  void update_current_settlement(const Col<T>&);
431  void update_current_resistance(const Col<T>&);
432  void update_current_damping_force(const Col<T>&);
433  void update_current_inertial_force(const Col<T>&);
434  void update_current_displacement(const Col<T>&);
435  void update_current_velocity(const Col<T>&);
436  void update_current_acceleration(const Col<T>&);
437  void update_current_temperature(const Col<T>&);
438 
439  /*************************FRIEND*************************/
440 
441  template<sp_d T1> friend Col<T1>& get_ninja(const shared_ptr<Factory<T1>>&);
442  template<sp_d T1> friend Col<T1>& get_sushi(const shared_ptr<Factory<T1>>&);
443 
444  template<sp_d T1> friend suanpan::set<uword>& get_reference_dof(const shared_ptr<Factory<T1>>&);
445  template<sp_d T1> friend SpMat<T1>& get_reference_load(const shared_ptr<Factory<T1>>&);
446 
447  template<sp_d T1> friend uvec& get_auxiliary_encoding(const shared_ptr<Factory<T1>>&);
448  template<sp_d T1> friend Col<T1>& get_auxiliary_lambda(const shared_ptr<Factory<T1>>&);
449  template<sp_d T1> friend Col<T1>& get_auxiliary_resistance(const shared_ptr<Factory<T1>>&);
450  template<sp_d T1> friend Col<T1>& get_auxiliary_load(const shared_ptr<Factory<T1>>&);
451  template<sp_d T1> friend SpMat<T1>& get_auxiliary_stiffness(const shared_ptr<Factory<T1>>&);
452 
453  template<sp_d T1> friend SpCol<T1>& get_trial_constraint_resistance(const shared_ptr<Factory<T1>>&);
454  template<sp_d T1> friend SpCol<T1>& get_current_constraint_resistance(const shared_ptr<Factory<T1>>&);
455 
456  template<sp_d T1> friend T& get_trial_time(const shared_ptr<Factory<T1>>&);
457  template<sp_d T1> friend Col<T1>& get_trial_load_factor(const shared_ptr<Factory<T1>>&);
458  template<sp_d T1> friend Col<T1>& get_trial_load(const shared_ptr<Factory<T1>>&);
459  template<sp_d T1> friend Col<T1>& get_trial_settlement(const shared_ptr<Factory<T1>>&);
460  template<sp_d T1> friend Col<T1>& get_trial_resistance(const shared_ptr<Factory<T1>>&);
461  template<sp_d T1> friend Col<T1>& get_trial_damping_force(const shared_ptr<Factory<T1>>&);
462  template<sp_d T1> friend Col<T1>& get_trial_inertial_force(const shared_ptr<Factory<T1>>&);
463  template<sp_d T1> friend Col<T1>& get_trial_displacement(const shared_ptr<Factory<T1>>&);
464  template<sp_d T1> friend Col<T1>& get_trial_velocity(const shared_ptr<Factory<T1>>&);
465  template<sp_d T1> friend Col<T1>& get_trial_acceleration(const shared_ptr<Factory<T1>>&);
466  template<sp_d T1> friend Col<T1>& get_trial_temperature(const shared_ptr<Factory<T1>>&);
467 
468  template<sp_d T1> friend T& get_incre_time(const shared_ptr<Factory<T1>>&);
469  template<sp_d T1> friend Col<T1>& get_incre_load_factor(const shared_ptr<Factory<T1>>&);
470  template<sp_d T1> friend Col<T1>& get_incre_load(const shared_ptr<Factory<T1>>&);
471  template<sp_d T1> friend Col<T1>& get_incre_settlement(const shared_ptr<Factory<T1>>&);
472  template<sp_d T1> friend Col<T1>& get_incre_resistance(const shared_ptr<Factory<T1>>&);
473  template<sp_d T1> friend Col<T1>& get_incre_damping_force(const shared_ptr<Factory<T1>>&);
474  template<sp_d T1> friend Col<T1>& get_incre_inertial_force(const shared_ptr<Factory<T1>>&);
475  template<sp_d T1> friend Col<T1>& get_incre_displacement(const shared_ptr<Factory<T1>>&);
476  template<sp_d T1> friend Col<T1>& get_incre_velocity(const shared_ptr<Factory<T1>>&);
477  template<sp_d T1> friend Col<T1>& get_incre_acceleration(const shared_ptr<Factory<T1>>&);
478  template<sp_d T1> friend Col<T1>& get_incre_temperature(const shared_ptr<Factory<T1>>&);
479 
480  template<sp_d T1> friend T& get_current_time(const shared_ptr<Factory<T1>>&);
481  template<sp_d T1> friend Col<T1>& get_current_load_factor(const shared_ptr<Factory<T1>>&);
482  template<sp_d T1> friend Col<T1>& get_current_load(const shared_ptr<Factory<T1>>&);
483  template<sp_d T1> friend Col<T1>& get_current_settlement(const shared_ptr<Factory<T1>>&);
484  template<sp_d T1> friend Col<T1>& get_current_resistance(const shared_ptr<Factory<T1>>&);
485  template<sp_d T1> friend Col<T1>& get_current_damping_force(const shared_ptr<Factory<T1>>&);
486  template<sp_d T1> friend Col<T1>& get_current_inertial_force(const shared_ptr<Factory<T1>>&);
487  template<sp_d T1> friend Col<T1>& get_current_displacement(const shared_ptr<Factory<T1>>&);
488  template<sp_d T1> friend Col<T1>& get_current_velocity(const shared_ptr<Factory<T1>>&);
489  template<sp_d T1> friend Col<T1>& get_current_acceleration(const shared_ptr<Factory<T1>>&);
490  template<sp_d T1> friend Col<T1>& get_current_temperature(const shared_ptr<Factory<T1>>&);
491 
492  template<sp_d T1> friend T& get_pre_time(const shared_ptr<Factory<T1>>&);
493  template<sp_d T1> friend Col<T1>& get_pre_load_factor(const shared_ptr<Factory<T1>>&);
494  template<sp_d T1> friend Col<T1>& get_pre_load(const shared_ptr<Factory<T1>>&);
495  template<sp_d T1> friend Col<T1>& get_pre_settlement(const shared_ptr<Factory<T1>>&);
496  template<sp_d T1> friend Col<T1>& get_pre_resistance(const shared_ptr<Factory<T1>>&);
497  template<sp_d T1> friend Col<T1>& get_pre_damping_force(const shared_ptr<Factory<T1>>&);
498  template<sp_d T1> friend Col<T1>& get_pre_inertial_force(const shared_ptr<Factory<T1>>&);
499  template<sp_d T1> friend Col<T1>& get_pre_displacement(const shared_ptr<Factory<T1>>&);
500  template<sp_d T1> friend Col<T1>& get_pre_velocity(const shared_ptr<Factory<T1>>&);
501  template<sp_d T1> friend Col<T1>& get_pre_acceleration(const shared_ptr<Factory<T1>>&);
502  template<sp_d T1> friend Col<T1>& get_pre_temperature(const shared_ptr<Factory<T1>>&);
503 
504  template<sp_d T1> friend shared_ptr<MetaMat<T1>>& get_mass(const shared_ptr<Factory<T1>>&);
505  template<sp_d T1> friend shared_ptr<MetaMat<T1>>& get_damping(const shared_ptr<Factory<T1>>&);
506  template<sp_d T1> friend shared_ptr<MetaMat<T1>>& get_stiffness(const shared_ptr<Factory<T1>>&);
507  template<sp_d T1> friend shared_ptr<MetaMat<T1>>& get_geometry(const shared_ptr<Factory<T1>>&);
508 
509  template<sp_d T1> friend Col<T1>& get_eigenvalue(const shared_ptr<Factory<T1>>&);
510  template<sp_d T1> friend Mat<T1>& get_eigenvector(const shared_ptr<Factory<T1>>&);
511 
512  /*************************STATUS*************************/
513 
514  void commit_energy();
515  void clear_energy();
516 
517  void commit_status();
518  void commit_time();
519  void commit_load_factor();
520  void commit_load();
521  void commit_settlement();
522  void commit_resistance();
523  void commit_damping_force();
524  void commit_inertial_force();
525  void commit_displacement();
526  void commit_velocity();
527  void commit_acceleration();
528  void commit_temperature();
529  void commit_auxiliary_resistance();
530 
531  void commit_pre_status();
532  void commit_pre_time();
533  void commit_pre_load_factor();
534  void commit_pre_load();
535  void commit_pre_settlement();
536  void commit_pre_resistance();
537  void commit_pre_damping_force();
538  void commit_pre_inertial_force();
539  void commit_pre_displacement();
540  void commit_pre_velocity();
541  void commit_pre_acceleration();
542  void commit_pre_temperature();
543 
544  void clear_status();
545  void clear_time();
546  void clear_load_factor();
547  void clear_load();
548  void clear_settlement();
549  void clear_resistance();
550  void clear_damping_force();
551  void clear_inertial_force();
552  void clear_displacement();
553  void clear_velocity();
554  void clear_acceleration();
555  void clear_temperature();
556  void clear_auxiliary_resistance();
557 
558  void reset_status();
559  void reset_time();
560  void reset_load_factor();
561  void reset_load();
562  void reset_settlement();
563  void reset_resistance();
564  void reset_damping_force();
565  void reset_inertial_force();
566  void reset_displacement();
567  void reset_velocity();
568  void reset_acceleration();
569  void reset_temperature();
570  void reset_auxiliary_resistance();
571 
572  void clear_eigen();
573  void clear_mass();
574  void clear_damping();
575  void clear_stiffness();
576  void clear_geometry();
577  void clear_auxiliary();
578 
579  void reset();
580 
581  /*************************ASSEMBLER*************************/
582 
583  void assemble_resistance(const Mat<T>&, const uvec&);
584  void assemble_damping_force(const Mat<T>&, const uvec&);
585  void assemble_inertial_force(const Mat<T>&, const uvec&);
586  void assemble_mass(const Mat<T>&, const uvec&);
587  void assemble_damping(const Mat<T>&, const uvec&);
588  void assemble_stiffness(const Mat<T>&, const uvec&);
589  void assemble_geometry(const Mat<T>&, const uvec&);
590  void assemble_stiffness(const SpMat<T>&, const uvec&);
591 
592  /*************************UTILITY*************************/
593 
594  void print() const;
595 };
596 
597 template<sp_d T> Factory<T>::Factory(const unsigned D, const AnalysisType AT, const StorageScheme SS)
598  : n_size(D)
599  , analysis_type(AT)
600  , storage_type(SS) {}
601 
602 template<sp_d T> void Factory<T>::set_size(const unsigned D) {
603  if(D == n_size) return;
604  n_size = D;
605  access::rw(initialized) = false;
606 }
607 
608 template<sp_d T> unsigned Factory<T>::get_size() const { return n_size; }
609 
610 template<sp_d T> void Factory<T>::set_entry(const uword N) { n_elem = N; }
611 
612 template<sp_d T> uword Factory<T>::get_entry() const { return n_elem; }
613 
614 template<sp_d T> void Factory<T>::set_nlgeom(const bool B) {
615  if(B == nlgeom) return;
616  nlgeom = B;
617  access::rw(initialized) = false;
618 }
619 
620 template<sp_d T> bool Factory<T>::is_nlgeom() const { return nlgeom; }
621 
622 template<sp_d T> void Factory<T>::set_tolerance(const double E) { tolerance = E; }
623 
624 template<sp_d T> double Factory<T>::get_tolerance() const { return tolerance; }
625 
626 template<sp_d T> void Factory<T>::set_precision(const Precision E) { precision = E; }
627 
628 template<sp_d T> Precision Factory<T>::get_precision() const { return precision; }
629 
630 template<sp_d T> void Factory<T>::set_solver(const SolverType E) { solver = E; }
631 
632 template<sp_d T> SolverType Factory<T>::get_solver() const { return solver; }
633 
634 template<sp_d T> void Factory<T>::set_refinement(const unsigned R) { refinement = R; }
635 
636 template<sp_d T> void Factory<T>::set_analysis_type(const AnalysisType AT) {
637  if(AT == analysis_type) return;
638  analysis_type = AT;
639  access::rw(initialized) = false;
640 }
641 
642 template<sp_d T> AnalysisType Factory<T>::get_analysis_type() const { return analysis_type; }
643 
644 template<sp_d T> void Factory<T>::set_storage_scheme(const StorageScheme SS) {
645  if(SS == storage_type) return;
646  storage_type = SS;
647  access::rw(initialized) = false;
648 }
649 
650 template<sp_d T> StorageScheme Factory<T>::get_storage_scheme() const { return storage_type; }
651 
652 template<sp_d T> bool Factory<T>::is_sparse() const { return StorageScheme::SPARSE == storage_type || StorageScheme::SPARSESYMM == storage_type; }
653 
654 template<sp_d T> void Factory<T>::set_bandwidth(const unsigned L, const unsigned U) {
655  if(L == n_lobw && U == n_upbw) return;
656  n_lobw = L;
657  n_upbw = U;
658  n_sfbw = L + U;
659  access::rw(initialized) = false;
660 }
661 
662 template<sp_d T> void Factory<T>::get_bandwidth(unsigned& L, unsigned& U) const {
663  L = n_lobw;
664  U = n_upbw;
665 }
666 
667 template<sp_d T> void Factory<T>::update_reference_size() { n_rfld = static_cast<unsigned>(reference_dof.size()); }
668 
669 template<sp_d T> void Factory<T>::set_reference_size(const unsigned S) {
670  if(S == n_rfld) return;
671  n_rfld = S;
672 }
673 
674 template<sp_d T> unsigned Factory<T>::get_reference_size() const { return n_rfld; }
675 
676 template<sp_d T> void Factory<T>::update_reference_dof(const uvec& S) { reference_dof.insert(S.cbegin(), S.cend()); }
677 
678 template<sp_d T> void Factory<T>::set_reference_dof(const suanpan::set<uword>& D) { reference_dof = D; }
679 
680 template<sp_d T> const suanpan::set<uword>& Factory<T>::get_reference_dof() const { return reference_dof; }
681 
682 template<sp_d T> void Factory<T>::set_error(const T& E) { error = E; }
683 
684 template<sp_d T> const T& Factory<T>::get_error() const { return error; }
685 
686 template<sp_d T> int Factory<T>::initialize() {
687  reference_dof.clear(); // clear reference dof vector in every step
688 
689  if(initialized || n_size == 0) return 0;
690 
691  ninja.zeros(n_size);
692  sushi.zeros(n_size);
693 
694  reset();
695 
696  switch(analysis_type) {
697  case AnalysisType::DISP:
698  initialize_displacement();
699  break;
700  case AnalysisType::EIGEN:
701  initialize_mass();
702  initialize_stiffness();
703  initialize_eigen();
704  break;
705  case AnalysisType::BUCKLE:
706  case AnalysisType::STATICS:
707  initialize_load();
708  initialize_resistance();
709  initialize_displacement();
710  initialize_stiffness();
711  initialize_geometry();
712  break;
713  case AnalysisType::DYNAMICS:
714  initialize_load();
715  initialize_resistance();
716  initialize_damping_force();
717  initialize_inertial_force();
718  initialize_displacement();
719  initialize_velocity();
720  initialize_acceleration();
721  initialize_mass();
722  initialize_damping();
723  initialize_stiffness();
724  initialize_geometry();
725  break;
726  case AnalysisType::NONE:
727  break;
728  }
729 
730  initialize_auxiliary_resistance();
731 
732  access::rw(initialized) = true;
733 
734  return 0;
735 }
736 
737 template<sp_d T> void Factory<T>::initialize_load_factor() {
738  if(n_rfld == 0) return;
739 
740  trial_load_factor.zeros(n_rfld);
741  incre_load_factor.zeros(n_rfld);
742  current_load_factor.zeros(n_rfld);
743 
744  reference_load.zeros(n_size, n_rfld);
745 }
746 
747 template<sp_d T> void Factory<T>::initialize_load() {
748  trial_load.zeros(n_size);
749  incre_load.zeros(n_size);
750  current_load.zeros(n_size);
751 }
752 
753 template<sp_d T> void Factory<T>::initialize_settlement() {
754  trial_settlement.zeros(n_size);
755  incre_settlement.zeros(n_size);
756  current_settlement.zeros(n_size);
757 }
758 
759 template<sp_d T> void Factory<T>::initialize_resistance() {
760  trial_resistance.zeros(n_size);
761  incre_resistance.zeros(n_size);
762  current_resistance.zeros(n_size);
763 }
764 
765 template<sp_d T> void Factory<T>::initialize_damping_force() {
766  trial_damping_force.zeros(n_size);
767  incre_damping_force.zeros(n_size);
768  current_damping_force.zeros(n_size);
769 }
770 
771 template<sp_d T> void Factory<T>::initialize_inertial_force() {
772  trial_inertial_force.zeros(n_size);
773  incre_inertial_force.zeros(n_size);
774  current_inertial_force.zeros(n_size);
775 }
776 
777 template<sp_d T> void Factory<T>::initialize_displacement() {
778  trial_displacement.zeros(n_size);
779  incre_displacement.zeros(n_size);
780  current_displacement.zeros(n_size);
781 }
782 
783 template<sp_d T> void Factory<T>::initialize_velocity() {
784  trial_velocity.zeros(n_size);
785  incre_velocity.zeros(n_size);
786  current_velocity.zeros(n_size);
787 }
788 
789 template<sp_d T> void Factory<T>::initialize_acceleration() {
790  trial_acceleration.zeros(n_size);
791  incre_acceleration.zeros(n_size);
792  current_acceleration.zeros(n_size);
793 }
794 
795 template<sp_d T> void Factory<T>::initialize_temperature() {
796  trial_temperature.zeros(n_size);
797  incre_temperature.zeros(n_size);
798  current_temperature.zeros(n_size);
799 }
800 
801 template<sp_d T> void Factory<T>::initialize_auxiliary_resistance() {
802  trial_constraint_resistance.zeros(n_size);
803  current_constraint_resistance.zeros(n_size);
804 }
805 
806 template<sp_d T> void Factory<T>::initialize_mass() { global_mass = get_matrix_container(this); }
807 
808 template<sp_d T> void Factory<T>::initialize_damping() { global_damping = get_matrix_container(this); }
809 
810 template<sp_d T> void Factory<T>::initialize_stiffness() { global_stiffness = get_matrix_container(this); }
811 
812 template<sp_d T> void Factory<T>::initialize_geometry() {
813  if(!nlgeom) return;
814 
815  global_geometry = get_matrix_container(this);
816 }
817 
818 template<sp_d T> void Factory<T>::initialize_eigen() {
819  eigenvalue.zeros(n_size);
820  eigenvector.zeros(n_size, n_size);
821 }
822 
823 template<sp_d T> void Factory<T>::set_ninja(const Col<T>& N) { ninja = N; }
824 
825 template<sp_d T> void Factory<T>::set_sushi(const Col<T>& S) { sushi = S; }
826 
827 template<sp_d T> void Factory<T>::set_mpc(const unsigned S) {
828  n_mpc = S;
829  auxiliary_encoding.zeros(n_mpc);
830  auxiliary_resistance.zeros(n_mpc);
831  auxiliary_load.zeros(n_mpc);
832  auxiliary_stiffness.zeros(n_size, n_mpc);
833 }
834 
835 template<sp_d T> void Factory<T>::set_reference_load(const SpMat<T>& L) { reference_load = L; }
836 
837 template<sp_d T> void Factory<T>::set_trial_time(const T& M) { trial_time = M; }
838 
839 template<sp_d T> void Factory<T>::set_trial_load_factor(const Col<T>& L) { trial_load_factor = L; }
840 
841 template<sp_d T> void Factory<T>::set_trial_load(const Col<T>& L) { trial_load = L; }
842 
843 template<sp_d T> void Factory<T>::set_trial_settlement(const Col<T>& S) { trial_settlement = S; }
844 
845 template<sp_d T> void Factory<T>::set_trial_resistance(const Col<T>& R) { trial_resistance = R; }
846 
847 template<sp_d T> void Factory<T>::set_trial_damping_force(const Col<T>& R) { trial_damping_force = R; }
848 
849 template<sp_d T> void Factory<T>::set_trial_inertial_force(const Col<T>& R) { trial_inertial_force = R; }
850 
851 template<sp_d T> void Factory<T>::set_trial_displacement(const Col<T>& D) { trial_displacement = D; }
852 
853 template<sp_d T> void Factory<T>::set_trial_velocity(const Col<T>& V) { trial_velocity = V; }
854 
855 template<sp_d T> void Factory<T>::set_trial_acceleration(const Col<T>& A) { trial_acceleration = A; }
856 
857 template<sp_d T> void Factory<T>::set_trial_temperature(const Col<T>& M) { trial_temperature = M; }
858 
859 template<sp_d T> void Factory<T>::set_incre_time(const T& M) { incre_time = M; }
860 
861 template<sp_d T> void Factory<T>::set_incre_load_factor(const Col<T>& L) { incre_load_factor = L; }
862 
863 template<sp_d T> void Factory<T>::set_incre_load(const Col<T>& L) { incre_load = L; }
864 
865 template<sp_d T> void Factory<T>::set_incre_settlement(const Col<T>& S) { incre_settlement = S; }
866 
867 template<sp_d T> void Factory<T>::set_incre_resistance(const Col<T>& R) { incre_resistance = R; }
868 
869 template<sp_d T> void Factory<T>::set_incre_damping_force(const Col<T>& R) { incre_damping_force = R; }
870 
871 template<sp_d T> void Factory<T>::set_incre_inertial_force(const Col<T>& R) { incre_inertial_force = R; }
872 
873 template<sp_d T> void Factory<T>::set_incre_displacement(const Col<T>& D) { incre_displacement = D; }
874 
875 template<sp_d T> void Factory<T>::set_incre_velocity(const Col<T>& V) { incre_velocity = V; }
876 
877 template<sp_d T> void Factory<T>::set_incre_acceleration(const Col<T>& A) { incre_acceleration = A; }
878 
879 template<sp_d T> void Factory<T>::set_incre_temperature(const Col<T>& M) { incre_temperature = M; }
880 
881 template<sp_d T> void Factory<T>::set_current_time(const T& M) { current_time = M; }
882 
883 template<sp_d T> void Factory<T>::set_current_load_factor(const Col<T>& L) { current_load_factor = L; }
884 
885 template<sp_d T> void Factory<T>::set_current_load(const Col<T>& L) { current_load = L; }
886 
887 template<sp_d T> void Factory<T>::set_current_settlement(const Col<T>& S) { current_settlement = S; }
888 
889 template<sp_d T> void Factory<T>::set_current_resistance(const Col<T>& R) { current_resistance = R; }
890 
891 template<sp_d T> void Factory<T>::set_current_damping_force(const Col<T>& R) { current_damping_force = R; }
892 
893 template<sp_d T> void Factory<T>::set_current_inertial_force(const Col<T>& R) { current_inertial_force = R; }
894 
895 template<sp_d T> void Factory<T>::set_current_displacement(const Col<T>& D) { current_displacement = D; }
896 
897 template<sp_d T> void Factory<T>::set_current_velocity(const Col<T>& V) { current_velocity = V; }
898 
899 template<sp_d T> void Factory<T>::set_current_acceleration(const Col<T>& A) { current_acceleration = A; }
900 
901 template<sp_d T> void Factory<T>::set_current_temperature(const Col<T>& M) { current_temperature = M; }
902 
903 template<sp_d T> void Factory<T>::set_pre_time(const T& M) { pre_time = M; }
904 
905 template<sp_d T> void Factory<T>::set_pre_load_factor(const Col<T>& L) { pre_load_factor = L; }
906 
907 template<sp_d T> void Factory<T>::set_pre_load(const Col<T>& L) { pre_load = L; }
908 
909 template<sp_d T> void Factory<T>::set_pre_settlement(const Col<T>& S) { pre_settlement = S; }
910 
911 template<sp_d T> void Factory<T>::set_pre_resistance(const Col<T>& R) { pre_resistance = R; }
912 
913 template<sp_d T> void Factory<T>::set_pre_damping_force(const Col<T>& R) { pre_damping_force = R; }
914 
915 template<sp_d T> void Factory<T>::set_pre_inertial_force(const Col<T>& R) { pre_inertial_force = R; }
916 
917 template<sp_d T> void Factory<T>::set_pre_displacement(const Col<T>& D) { pre_displacement = D; }
918 
919 template<sp_d T> void Factory<T>::set_pre_velocity(const Col<T>& V) { pre_velocity = V; }
920 
921 template<sp_d T> void Factory<T>::set_pre_acceleration(const Col<T>& A) { pre_acceleration = A; }
922 
923 template<sp_d T> void Factory<T>::set_pre_temperature(const Col<T>& M) { pre_temperature = M; }
924 
925 template<sp_d T> void Factory<T>::set_mass(const shared_ptr<MetaMat<T>>& M) { global_mass = M; }
926 
927 template<sp_d T> void Factory<T>::set_damping(const shared_ptr<MetaMat<T>>& C) { global_damping = C; }
928 
929 template<sp_d T> void Factory<T>::set_stiffness(const shared_ptr<MetaMat<T>>& K) { global_stiffness = K; }
930 
931 template<sp_d T> void Factory<T>::set_geometry(const shared_ptr<MetaMat<T>>& G) { global_geometry = G; }
932 
933 template<sp_d T> void Factory<T>::set_eigenvalue(const Col<T>& L) { eigenvalue = L; }
934 
935 template<sp_d T> void Factory<T>::set_eigenvector(const Mat<T>& V) { eigenvector = V; }
936 
937 template<sp_d T> const Col<T>& Factory<T>::get_ninja() const { return ninja; }
938 
939 template<sp_d T> const Col<T>& Factory<T>::get_sushi() const { return sushi; }
940 
941 template<sp_d T> unsigned Factory<T>::get_mpc() const { return n_mpc; }
942 
943 template<sp_d T> const SpMat<T>& Factory<T>::get_reference_load() const { return reference_load; }
944 
945 template<sp_d T> const uvec& Factory<T>::get_auxiliary_encoding() const { return auxiliary_encoding; }
946 
947 template<sp_d T> const Col<T>& Factory<T>::get_auxiliary_lambda() const { return auxiliary_lambda; }
948 
949 template<sp_d T> const Col<T>& Factory<T>::get_auxiliary_resistance() const { return auxiliary_resistance; }
950 
951 template<sp_d T> const Col<T>& Factory<T>::get_auxiliary_load() const { return auxiliary_load; }
952 
953 template<sp_d T> const SpMat<T>& Factory<T>::get_auxiliary_stiffness() const { return auxiliary_stiffness; }
954 
955 template<sp_d T> const SpCol<T>& Factory<T>::get_trial_constraint_resistance() const { return trial_constraint_resistance; }
956 
957 template<sp_d T> const SpCol<T>& Factory<T>::get_current_constraint_resistance() const { return current_constraint_resistance; }
958 
959 template<sp_d T> T Factory<T>::get_strain_energy() { return strain_energy; }
960 
961 template<sp_d T> T Factory<T>::get_kinetic_energy() { return kinetic_energy; }
962 
963 template<sp_d T> T Factory<T>::get_viscous_energy() { return viscous_energy; }
964 
965 template<sp_d T> T Factory<T>::get_complementary_energy() { return complementary_energy; }
966 
967 template<sp_d T> const Col<T>& Factory<T>::get_momentum() { return momentum; }
968 
969 template<sp_d T> const T& Factory<T>::get_trial_time() const { return trial_time; }
970 
971 template<sp_d T> const Col<T>& Factory<T>::get_trial_load_factor() const { return trial_load_factor; }
972 
973 template<sp_d T> const Col<T>& Factory<T>::get_trial_load() const { return trial_load; }
974 
975 template<sp_d T> const Col<T>& Factory<T>::get_trial_settlement() const { return trial_settlement; }
976 
977 template<sp_d T> const Col<T>& Factory<T>::get_trial_resistance() const { return trial_resistance; }
978 
979 template<sp_d T> const Col<T>& Factory<T>::get_trial_damping_force() const { return trial_damping_force; }
980 
981 template<sp_d T> const Col<T>& Factory<T>::get_trial_inertial_force() const { return trial_inertial_force; }
982 
983 template<sp_d T> const Col<T>& Factory<T>::get_trial_displacement() const { return trial_displacement; }
984 
985 template<sp_d T> const Col<T>& Factory<T>::get_trial_velocity() const { return trial_velocity; }
986 
987 template<sp_d T> const Col<T>& Factory<T>::get_trial_acceleration() const { return trial_acceleration; }
988 
989 template<sp_d T> const Col<T>& Factory<T>::get_trial_temperature() const { return trial_temperature; }
990 
991 template<sp_d T> const T& Factory<T>::get_incre_time() const { return incre_time; }
992 
993 template<sp_d T> const Col<T>& Factory<T>::get_incre_load_factor() const { return incre_load_factor; }
994 
995 template<sp_d T> const Col<T>& Factory<T>::get_incre_load() const { return incre_load; }
996 
997 template<sp_d T> const Col<T>& Factory<T>::get_incre_settlement() const { return incre_settlement; }
998 
999 template<sp_d T> const Col<T>& Factory<T>::get_incre_resistance() const { return incre_resistance; }
1000 
1001 template<sp_d T> const Col<T>& Factory<T>::get_incre_damping_force() const { return incre_damping_force; }
1002 
1003 template<sp_d T> const Col<T>& Factory<T>::get_incre_inertial_force() const { return incre_inertial_force; }
1004 
1005 template<sp_d T> const Col<T>& Factory<T>::get_incre_displacement() const { return incre_displacement; }
1006 
1007 template<sp_d T> const Col<T>& Factory<T>::get_incre_velocity() const { return incre_velocity; }
1008 
1009 template<sp_d T> const Col<T>& Factory<T>::get_incre_acceleration() const { return incre_acceleration; }
1010 
1011 template<sp_d T> const Col<T>& Factory<T>::get_incre_temperature() const { return incre_temperature; }
1012 
1013 template<sp_d T> const T& Factory<T>::get_current_time() const { return current_time; }
1014 
1015 template<sp_d T> const Col<T>& Factory<T>::get_current_load_factor() const { return current_load_factor; }
1016 
1017 template<sp_d T> const Col<T>& Factory<T>::get_current_load() const { return current_load; }
1018 
1019 template<sp_d T> const Col<T>& Factory<T>::get_current_settlement() const { return current_settlement; }
1020 
1021 template<sp_d T> const Col<T>& Factory<T>::get_current_resistance() const { return current_resistance; }
1022 
1023 template<sp_d T> const Col<T>& Factory<T>::get_current_damping_force() const { return current_damping_force; }
1024 
1025 template<sp_d T> const Col<T>& Factory<T>::get_current_inertial_force() const { return current_inertial_force; }
1026 
1027 template<sp_d T> const Col<T>& Factory<T>::get_current_displacement() const { return current_displacement; }
1028 
1029 template<sp_d T> const Col<T>& Factory<T>::get_current_velocity() const { return current_velocity; }
1030 
1031 template<sp_d T> const Col<T>& Factory<T>::get_current_acceleration() const { return current_acceleration; }
1032 
1033 template<sp_d T> const Col<T>& Factory<T>::get_current_temperature() const { return current_temperature; }
1034 
1035 template<sp_d T> const T& Factory<T>::get_pre_time() const { return pre_time; }
1036 
1037 template<sp_d T> const Col<T>& Factory<T>::get_pre_load_factor() const { return pre_load_factor; }
1038 
1039 template<sp_d T> const Col<T>& Factory<T>::get_pre_load() const { return pre_load; }
1040 
1041 template<sp_d T> const Col<T>& Factory<T>::get_pre_settlement() const { return pre_settlement; }
1042 
1043 template<sp_d T> const Col<T>& Factory<T>::get_pre_resistance() const { return pre_resistance; }
1044 
1045 template<sp_d T> const Col<T>& Factory<T>::get_pre_damping_force() const { return pre_damping_force; }
1046 
1047 template<sp_d T> const Col<T>& Factory<T>::get_pre_inertial_force() const { return pre_inertial_force; }
1048 
1049 template<sp_d T> const Col<T>& Factory<T>::get_pre_displacement() const { return pre_displacement; }
1050 
1051 template<sp_d T> const Col<T>& Factory<T>::get_pre_velocity() const { return pre_velocity; }
1052 
1053 template<sp_d T> const Col<T>& Factory<T>::get_pre_acceleration() const { return pre_acceleration; }
1054 
1055 template<sp_d T> const Col<T>& Factory<T>::get_pre_temperature() const { return pre_temperature; }
1056 
1057 template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_mass() const { return global_mass; }
1058 
1059 template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_damping() const { return global_damping; }
1060 
1061 template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_stiffness() const { return global_stiffness; }
1062 
1063 template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_geometry() const { return global_geometry; }
1064 
1065 template<sp_d T> std::mutex& Factory<T>::get_auxiliary_encoding_mutex() { return global_mutex.at(0); }
1066 
1067 template<sp_d T> std::mutex& Factory<T>::get_auxiliary_resistance_mutex() { return global_mutex.at(1); }
1068 
1069 template<sp_d T> std::mutex& Factory<T>::get_auxiliary_load_mutex() { return global_mutex.at(2); }
1070 
1071 template<sp_d T> std::mutex& Factory<T>::get_auxiliary_stiffness_mutex() { return global_mutex.at(3); }
1072 
1073 template<sp_d T> std::mutex& Factory<T>::get_trial_constraint_resistance_mutex() { return global_mutex.at(4); }
1074 
1075 template<sp_d T> std::mutex& Factory<T>::get_trial_load_mutex() { return global_mutex.at(5); }
1076 
1077 template<sp_d T> std::mutex& Factory<T>::get_trial_settlement_mutex() { return global_mutex.at(6); }
1078 
1079 template<sp_d T> std::mutex& Factory<T>::get_mass_mutex() { return global_mutex.at(7); }
1080 
1081 template<sp_d T> std::mutex& Factory<T>::get_damping_mutex() { return global_mutex.at(8); }
1082 
1083 template<sp_d T> std::mutex& Factory<T>::get_stiffness_mutex() { return global_mutex.at(9); }
1084 
1085 template<sp_d T> std::mutex& Factory<T>::get_geometry_mutex() { return global_mutex.at(10); }
1086 
1087 template<sp_d T> const Col<T>& Factory<T>::get_eigenvalue() const { return eigenvalue; }
1088 
1089 template<sp_d T> const Mat<T>& Factory<T>::get_eigenvector() const { return eigenvector; }
1090 
1091 template<sp_d T> void Factory<T>::update_trial_time(const T& M) {
1092  trial_time = M;
1093  incre_time = trial_time - current_time;
1094 }
1095 
1096 template<sp_d T> void Factory<T>::update_trial_load_factor(const Col<T>& L) {
1097  trial_load_factor = L;
1098  incre_load_factor = trial_load_factor - current_load_factor;
1099 }
1100 
1101 template<sp_d T> void Factory<T>::update_trial_load(const Col<T>& L) {
1102  trial_load = L;
1103  incre_load = trial_load - current_load;
1104 }
1105 
1106 template<sp_d T> void Factory<T>::update_trial_settlement(const Col<T>& S) {
1107  trial_settlement = S;
1108  incre_settlement = trial_settlement - current_settlement;
1109 }
1110 
1111 template<sp_d T> void Factory<T>::update_trial_resistance(const Col<T>& R) {
1112  trial_resistance = R;
1113  incre_resistance = trial_resistance - current_resistance;
1114 }
1115 
1116 template<sp_d T> void Factory<T>::update_trial_damping_force(const Col<T>& R) {
1117  trial_damping_force = R;
1118  incre_damping_force = trial_damping_force - current_damping_force;
1119 }
1120 
1121 template<sp_d T> void Factory<T>::update_trial_inertial_force(const Col<T>& R) {
1122  trial_inertial_force = R;
1123  incre_inertial_force = trial_inertial_force - current_inertial_force;
1124 }
1125 
1126 template<sp_d T> void Factory<T>::update_trial_displacement(const Col<T>& D) {
1127  trial_displacement = D;
1128  incre_displacement = trial_displacement - current_displacement;
1129 }
1130 
1131 template<sp_d T> void Factory<T>::update_trial_velocity(const Col<T>& V) {
1132  trial_velocity = V;
1133  incre_velocity = trial_velocity - current_velocity;
1134 }
1135 
1136 template<sp_d T> void Factory<T>::update_trial_acceleration(const Col<T>& A) {
1137  trial_acceleration = A;
1138  incre_acceleration = trial_acceleration - current_acceleration;
1139 }
1140 
1141 template<sp_d T> void Factory<T>::update_trial_temperature(const Col<T>& M) {
1142  trial_temperature = M;
1143  incre_temperature = trial_temperature - current_temperature;
1144 }
1145 
1146 template<sp_d T> void Factory<T>::update_incre_time(const T& M) {
1147  incre_time = M;
1148  trial_time = current_time + incre_time;
1149 }
1150 
1151 template<sp_d T> void Factory<T>::update_incre_load_factor(const Col<T>& L) {
1152  incre_load_factor = L;
1153  trial_load_factor = current_load_factor + incre_load_factor;
1154 }
1155 
1156 template<sp_d T> void Factory<T>::update_incre_load(const Col<T>& L) {
1157  incre_load = L;
1158  trial_load = current_load + incre_load;
1159 }
1160 
1161 template<sp_d T> void Factory<T>::update_incre_settlement(const Col<T>& S) {
1162  incre_settlement = S;
1163  trial_settlement = current_settlement + incre_settlement;
1164 }
1165 
1166 template<sp_d T> void Factory<T>::update_incre_resistance(const Col<T>& R) {
1167  incre_resistance = R;
1168  trial_resistance = current_resistance + incre_resistance;
1169 }
1170 
1171 template<sp_d T> void Factory<T>::update_incre_damping_force(const Col<T>& R) {
1172  incre_damping_force = R;
1173  trial_damping_force = current_damping_force + incre_damping_force;
1174 }
1175 
1176 template<sp_d T> void Factory<T>::update_incre_inertial_force(const Col<T>& R) {
1177  incre_inertial_force = R;
1178  trial_inertial_force = current_inertial_force + incre_inertial_force;
1179 }
1180 
1181 template<sp_d T> void Factory<T>::update_incre_displacement(const Col<T>& D) {
1182  incre_displacement = D;
1183  trial_displacement = current_displacement + incre_displacement;
1184 }
1185 
1186 template<sp_d T> void Factory<T>::update_incre_velocity(const Col<T>& V) {
1187  incre_velocity = V;
1188  trial_velocity = current_velocity + incre_velocity;
1189 }
1190 
1191 template<sp_d T> void Factory<T>::update_incre_acceleration(const Col<T>& A) {
1192  incre_acceleration = A;
1193  trial_acceleration = current_acceleration + incre_acceleration;
1194 }
1195 
1196 template<sp_d T> void Factory<T>::update_incre_temperature(const Col<T>& M) {
1197  incre_temperature = M;
1198  trial_temperature = current_temperature + incre_temperature;
1199 }
1200 
1201 template<sp_d T> void Factory<T>::update_current_time(const T& M) {
1202  trial_time = current_time = M;
1203  incre_time = 0.;
1204 }
1205 
1206 template<sp_d T> void Factory<T>::update_current_load_factor(const Col<T>& L) {
1207  trial_load_factor = current_load_factor = L;
1208  incre_load_factor.zeros();
1209 }
1210 
1211 template<sp_d T> void Factory<T>::update_current_load(const Col<T>& L) {
1212  trial_load = current_load = L;
1213  incre_load.zeros();
1214 }
1215 
1216 template<sp_d T> void Factory<T>::update_current_settlement(const Col<T>& S) {
1217  trial_settlement = current_settlement = S;
1218  incre_settlement.zeros();
1219 }
1220 
1221 template<sp_d T> void Factory<T>::update_current_resistance(const Col<T>& R) {
1222  trial_resistance = current_resistance = R;
1223  incre_resistance.zeros();
1224 }
1225 
1226 template<sp_d T> void Factory<T>::update_current_damping_force(const Col<T>& R) {
1227  trial_damping_force = current_damping_force = R;
1228  incre_damping_force.zeros();
1229 }
1230 
1231 template<sp_d T> void Factory<T>::update_current_inertial_force(const Col<T>& R) {
1232  trial_inertial_force = current_inertial_force = R;
1233  incre_inertial_force.zeros();
1234 }
1235 
1236 template<sp_d T> void Factory<T>::update_current_displacement(const Col<T>& D) {
1237  trial_displacement = current_displacement = D;
1238  incre_displacement.zeros();
1239 }
1240 
1241 template<sp_d T> void Factory<T>::update_current_velocity(const Col<T>& V) {
1242  trial_velocity = current_velocity = V;
1243  incre_velocity.zeros();
1244 }
1245 
1246 template<sp_d T> void Factory<T>::update_current_acceleration(const Col<T>& A) {
1247  trial_acceleration = current_acceleration = A;
1248  incre_acceleration.zeros();
1249 }
1250 
1251 template<sp_d T> void Factory<T>::update_current_temperature(const Col<T>& M) {
1252  trial_temperature = current_temperature = M;
1253  incre_temperature.zeros();
1254 }
1255 
1256 template<sp_d T> void Factory<T>::commit_energy() {
1257  auto se = std::async([&] { if(!trial_resistance.empty() && !incre_displacement.empty()) strain_energy += .5 * dot(trial_resistance + current_resistance, incre_displacement); });
1258  auto ke = std::async([&] { if(!trial_inertial_force.empty() && !trial_velocity.empty()) kinetic_energy = .5 * dot(global_mass * trial_velocity, trial_velocity); });
1259  auto ve = std::async([&] { if(!trial_damping_force.empty() && !incre_displacement.empty()) viscous_energy += .5 * dot(trial_damping_force + current_damping_force, incre_displacement); });
1260  auto ce = std::async([&] { if(!trial_displacement.empty() && !incre_resistance.empty()) complementary_energy += .5 * dot(trial_displacement + current_displacement, incre_resistance); });
1261  auto mm = std::async([&] { if(!trial_inertial_force.empty() && !trial_velocity.empty()) momentum = global_mass * trial_velocity; });
1262 
1263  se.get();
1264  ke.get();
1265  ve.get();
1266  ce.get();
1267  mm.get();
1268 }
1269 
1270 template<sp_d T> void Factory<T>::clear_energy() {
1271  strain_energy = 0.;
1272  kinetic_energy = 0.;
1273  viscous_energy = 0.;
1274  complementary_energy = 0.;
1275  momentum.zeros();
1276 }
1277 
1278 template<sp_d T> void Factory<T>::commit_status() {
1279  commit_energy();
1280 
1281  commit_time();
1282  commit_load_factor();
1283  commit_load();
1284  commit_settlement();
1285  commit_resistance();
1286  commit_damping_force();
1287  commit_inertial_force();
1288  commit_displacement();
1289  commit_velocity();
1290  commit_acceleration();
1291  commit_temperature();
1292  commit_auxiliary_resistance();
1293 }
1294 
1295 template<sp_d T> void Factory<T>::commit_time() {
1296  current_time = trial_time;
1297  incre_time = 0.;
1298 }
1299 
1300 template<sp_d T> void Factory<T>::commit_load_factor() {
1301  if(trial_load_factor.is_empty()) return;
1302  current_load_factor = trial_load_factor;
1303  incre_load_factor.zeros();
1304 }
1305 
1306 template<sp_d T> void Factory<T>::commit_load() {
1307  if(trial_load.is_empty()) return;
1308  current_load = trial_load;
1309  incre_load.zeros();
1310 }
1311 
1312 template<sp_d T> void Factory<T>::commit_settlement() {
1313  if(trial_settlement.is_empty()) return;
1314  current_settlement = trial_settlement;
1315  incre_settlement.zeros();
1316 }
1317 
1318 template<sp_d T> void Factory<T>::commit_resistance() {
1319  if(trial_resistance.is_empty()) return;
1320  current_resistance = trial_resistance;
1321  incre_resistance.zeros();
1322 }
1323 
1324 template<sp_d T> void Factory<T>::commit_damping_force() {
1325  if(trial_damping_force.is_empty()) return;
1326  current_damping_force = trial_damping_force;
1327  incre_damping_force.zeros();
1328 }
1329 
1330 template<sp_d T> void Factory<T>::commit_inertial_force() {
1331  if(trial_inertial_force.is_empty()) return;
1332  current_inertial_force = trial_inertial_force;
1333  incre_inertial_force.zeros();
1334 }
1335 
1336 template<sp_d T> void Factory<T>::commit_displacement() {
1337  if(trial_displacement.is_empty()) return;
1338  current_displacement = trial_displacement;
1339  incre_displacement.zeros();
1340 }
1341 
1342 template<sp_d T> void Factory<T>::commit_velocity() {
1343  if(trial_velocity.is_empty()) return;
1344  current_velocity = trial_velocity;
1345  incre_velocity.zeros();
1346 }
1347 
1348 template<sp_d T> void Factory<T>::commit_acceleration() {
1349  if(trial_acceleration.is_empty()) return;
1350  current_acceleration = trial_acceleration;
1351  incre_acceleration.zeros();
1352 }
1353 
1354 template<sp_d T> void Factory<T>::commit_temperature() {
1355  if(trial_temperature.is_empty()) return;
1356  current_temperature = trial_temperature;
1357  incre_temperature.zeros();
1358 }
1359 
1360 template<sp_d T> void Factory<T>::commit_auxiliary_resistance() {
1361  if(trial_constraint_resistance.is_empty()) return;
1362  current_constraint_resistance = trial_constraint_resistance;
1363 }
1364 
1365 template<sp_d T> void Factory<T>::commit_pre_status() {
1366  commit_pre_time();
1367  commit_pre_load_factor();
1368  commit_pre_load();
1369  commit_pre_settlement();
1370  commit_pre_resistance();
1371  commit_pre_damping_force();
1372  commit_pre_inertial_force();
1373  commit_pre_displacement();
1374  commit_pre_velocity();
1375  commit_pre_acceleration();
1376  commit_pre_temperature();
1377 }
1378 
1379 template<sp_d T> void Factory<T>::commit_pre_time() { pre_time = current_time; }
1380 
1381 template<sp_d T> void Factory<T>::commit_pre_load_factor() { if(!current_load_factor.is_empty()) pre_load_factor = current_load_factor; }
1382 
1383 template<sp_d T> void Factory<T>::commit_pre_load() { if(!current_load.is_empty()) pre_load = current_load; }
1384 
1385 template<sp_d T> void Factory<T>::commit_pre_settlement() { if(!current_settlement.is_empty()) pre_settlement = current_settlement; }
1386 
1387 template<sp_d T> void Factory<T>::commit_pre_resistance() { if(!current_resistance.is_empty()) pre_resistance = current_resistance; }
1388 
1389 template<sp_d T> void Factory<T>::commit_pre_damping_force() { if(!current_damping_force.is_empty()) pre_damping_force = current_damping_force; }
1390 
1391 template<sp_d T> void Factory<T>::commit_pre_inertial_force() { if(!current_inertial_force.is_empty()) pre_inertial_force = current_inertial_force; }
1392 
1393 template<sp_d T> void Factory<T>::commit_pre_displacement() { if(!current_displacement.is_empty()) pre_displacement = current_displacement; }
1394 
1395 template<sp_d T> void Factory<T>::commit_pre_velocity() { if(!current_velocity.is_empty()) pre_velocity = current_velocity; }
1396 
1397 template<sp_d T> void Factory<T>::commit_pre_acceleration() { if(!current_acceleration.is_empty()) pre_acceleration = current_acceleration; }
1398 
1399 template<sp_d T> void Factory<T>::commit_pre_temperature() { if(!current_temperature.is_empty()) pre_temperature = current_temperature; }
1400 
1401 template<sp_d T> void Factory<T>::clear_status() {
1402  access::rw(initialized) = false;
1403 
1404  ninja.zeros();
1405 
1406  clear_energy();
1407 
1408  clear_time();
1409  clear_load_factor();
1410  clear_load();
1411  clear_settlement();
1412  clear_resistance();
1413  clear_damping_force();
1414  clear_inertial_force();
1415  clear_displacement();
1416  clear_velocity();
1417  clear_acceleration();
1418  clear_temperature();
1419  clear_auxiliary_resistance();
1420 }
1421 
1422 template<sp_d T> void Factory<T>::clear_time() { trial_time = incre_time = current_time = 0.; }
1423 
1424 template<sp_d T> void Factory<T>::clear_load_factor() {
1425  if(!pre_load_factor.is_empty()) pre_load_factor.zeros();
1426  if(!trial_load_factor.is_empty()) trial_load_factor.zeros();
1427  if(!incre_load_factor.is_empty()) incre_load_factor.zeros();
1428  if(!current_load_factor.is_empty()) current_load_factor.zeros();
1429 }
1430 
1431 template<sp_d T> void Factory<T>::clear_load() {
1432  if(!pre_load.is_empty()) pre_load.zeros();
1433  if(!trial_load.is_empty()) trial_load.zeros();
1434  if(!incre_load.is_empty()) incre_load.zeros();
1435  if(!current_load.is_empty()) current_load.zeros();
1436 }
1437 
1438 template<sp_d T> void Factory<T>::clear_settlement() {
1439  if(!pre_settlement.is_empty()) pre_settlement.zeros();
1440  if(!trial_settlement.is_empty()) trial_settlement.zeros();
1441  if(!incre_settlement.is_empty()) incre_settlement.zeros();
1442  if(!current_settlement.is_empty()) current_settlement.zeros();
1443 }
1444 
1445 template<sp_d T> void Factory<T>::clear_resistance() {
1446  if(!pre_resistance.is_empty()) pre_resistance.zeros();
1447  if(!trial_resistance.is_empty()) trial_resistance.zeros();
1448  if(!incre_resistance.is_empty()) incre_resistance.zeros();
1449  if(!current_resistance.is_empty()) current_resistance.zeros();
1450 }
1451 
1452 template<sp_d T> void Factory<T>::clear_damping_force() {
1453  if(!pre_damping_force.is_empty()) pre_damping_force.zeros();
1454  if(!trial_damping_force.is_empty()) trial_damping_force.zeros();
1455  if(!incre_damping_force.is_empty()) incre_damping_force.zeros();
1456  if(!current_damping_force.is_empty()) current_damping_force.zeros();
1457 }
1458 
1459 template<sp_d T> void Factory<T>::clear_inertial_force() {
1460  if(!pre_inertial_force.is_empty()) pre_inertial_force.zeros();
1461  if(!trial_inertial_force.is_empty()) trial_inertial_force.zeros();
1462  if(!incre_inertial_force.is_empty()) incre_inertial_force.zeros();
1463  if(!current_inertial_force.is_empty()) current_inertial_force.zeros();
1464 }
1465 
1466 template<sp_d T> void Factory<T>::clear_displacement() {
1467  if(!pre_displacement.is_empty()) pre_displacement.zeros();
1468  if(!trial_displacement.is_empty()) trial_displacement.zeros();
1469  if(!incre_displacement.is_empty()) incre_displacement.zeros();
1470  if(!current_displacement.is_empty()) current_displacement.zeros();
1471 }
1472 
1473 template<sp_d T> void Factory<T>::clear_velocity() {
1474  if(!pre_velocity.is_empty()) pre_velocity.zeros();
1475  if(!trial_velocity.is_empty()) trial_velocity.zeros();
1476  if(!incre_velocity.is_empty()) incre_velocity.zeros();
1477  if(!current_velocity.is_empty()) current_velocity.zeros();
1478 }
1479 
1480 template<sp_d T> void Factory<T>::clear_acceleration() {
1481  if(!pre_acceleration.is_empty()) pre_acceleration.zeros();
1482  if(!trial_acceleration.is_empty()) trial_acceleration.zeros();
1483  if(!incre_acceleration.is_empty()) incre_acceleration.zeros();
1484  if(!current_acceleration.is_empty()) current_acceleration.zeros();
1485 }
1486 
1487 template<sp_d T> void Factory<T>::clear_temperature() {
1488  if(!pre_temperature.is_empty()) pre_temperature.zeros();
1489  if(!trial_temperature.is_empty()) trial_temperature.zeros();
1490  if(!incre_temperature.is_empty()) incre_temperature.zeros();
1491  if(!current_temperature.is_empty()) current_temperature.zeros();
1492 }
1493 
1494 template<sp_d T> void Factory<T>::clear_auxiliary_resistance() {
1495  if(!trial_constraint_resistance.is_empty()) trial_constraint_resistance.zeros();
1496  if(!current_constraint_resistance.is_empty()) current_constraint_resistance.zeros();
1497 }
1498 
1499 template<sp_d T> void Factory<T>::reset_status() {
1500  ninja.zeros();
1501 
1502  reset_time();
1503  reset_load_factor();
1504  reset_load();
1505  reset_settlement();
1506  reset_resistance();
1507  reset_damping_force();
1508  reset_inertial_force();
1509  reset_displacement();
1510  reset_velocity();
1511  reset_acceleration();
1512  reset_temperature();
1513  reset_auxiliary_resistance();
1514 }
1515 
1516 template<sp_d T> void Factory<T>::reset_time() {
1517  trial_time = current_time;
1518  incre_time = 0.;
1519 }
1520 
1521 template<sp_d T> void Factory<T>::reset_load_factor() {
1522  if(trial_load_factor.is_empty()) return;
1523  trial_load_factor = current_load_factor;
1524  incre_load_factor.zeros();
1525 }
1526 
1527 template<sp_d T> void Factory<T>::reset_load() {
1528  if(trial_load.is_empty()) return;
1529  trial_load = current_load;
1530  incre_load.zeros();
1531 }
1532 
1533 template<sp_d T> void Factory<T>::reset_settlement() {
1534  if(trial_settlement.is_empty()) return;
1535  trial_settlement = current_settlement;
1536  incre_settlement.zeros();
1537 }
1538 
1539 template<sp_d T> void Factory<T>::reset_resistance() {
1540  if(trial_resistance.is_empty()) return;
1541  trial_resistance = current_resistance;
1542  incre_resistance.zeros();
1543 }
1544 
1545 template<sp_d T> void Factory<T>::reset_damping_force() {
1546  if(trial_damping_force.is_empty()) return;
1547  trial_damping_force = current_damping_force;
1548  incre_damping_force.zeros();
1549 }
1550 
1551 template<sp_d T> void Factory<T>::reset_inertial_force() {
1552  if(trial_inertial_force.is_empty()) return;
1553  trial_inertial_force = current_inertial_force;
1554  incre_inertial_force.zeros();
1555 }
1556 
1557 template<sp_d T> void Factory<T>::reset_displacement() {
1558  if(trial_displacement.is_empty()) return;
1559  trial_displacement = current_displacement;
1560  incre_displacement.zeros();
1561 }
1562 
1563 template<sp_d T> void Factory<T>::reset_velocity() {
1564  if(trial_velocity.is_empty()) return;
1565  trial_velocity = current_velocity;
1566  incre_velocity.zeros();
1567 }
1568 
1569 template<sp_d T> void Factory<T>::reset_acceleration() {
1570  if(trial_acceleration.is_empty()) return;
1571  trial_acceleration = current_acceleration;
1572  incre_acceleration.zeros();
1573 }
1574 
1575 template<sp_d T> void Factory<T>::reset_temperature() {
1576  if(trial_temperature.is_empty()) return;
1577  trial_temperature = current_temperature;
1578  incre_temperature.zeros();
1579 }
1580 
1581 template<sp_d T> void Factory<T>::reset_auxiliary_resistance() {
1582  if(trial_constraint_resistance.is_empty()) return;
1583  trial_constraint_resistance = current_constraint_resistance;
1584 }
1585 
1586 template<sp_d T> void Factory<T>::clear_eigen() {
1587  if(!eigenvalue.is_empty()) eigenvalue.zeros();
1588  if(!eigenvector.is_empty()) eigenvector.zeros();
1589 }
1590 
1591 template<sp_d T> void Factory<T>::clear_mass() { if(global_mass != nullptr) global_mass->zeros(); }
1592 
1593 template<sp_d T> void Factory<T>::clear_damping() { if(global_damping != nullptr) global_damping->zeros(); }
1594 
1595 template<sp_d T> void Factory<T>::clear_stiffness() { if(global_stiffness != nullptr) global_stiffness->zeros(); }
1596 
1597 template<sp_d T> void Factory<T>::clear_geometry() { if(global_geometry != nullptr) global_geometry->zeros(); }
1598 
1599 template<sp_d T> void Factory<T>::clear_auxiliary() {
1600  n_mpc = 0;
1601  auxiliary_load.reset();
1602  auxiliary_stiffness.set_size(n_size, 0);
1603  auxiliary_resistance.reset();
1604  auxiliary_encoding.reset();
1605 }
1606 
1607 template<sp_d T> void Factory<T>::reset() {
1608  global_mass = nullptr;
1609  global_damping = nullptr;
1610  global_stiffness = nullptr;
1611  global_geometry = nullptr;
1612 }
1613 
1614 template<sp_d T> void Factory<T>::assemble_resistance(const Mat<T>& ER, const uvec& EI) {
1615  if(ER.is_empty()) return;
1616  for(unsigned I = 0; I < EI.n_elem; ++I) trial_resistance(EI(I)) += ER(I);
1617 }
1618 
1619 template<sp_d T> void Factory<T>::assemble_damping_force(const Mat<T>& ER, const uvec& EI) {
1620  if(ER.is_empty()) return;
1621  for(unsigned I = 0; I < EI.n_elem; ++I) trial_damping_force(EI(I)) += ER(I);
1622 }
1623 
1624 template<sp_d T> void Factory<T>::assemble_inertial_force(const Mat<T>& ER, const uvec& EI) {
1625  if(ER.is_empty()) return;
1626  for(unsigned I = 0; I < EI.n_elem; ++I) trial_inertial_force(EI(I)) += ER(I);
1627 }
1628 
1629 template<sp_d T> void Factory<T>::assemble_mass(const Mat<T>& EM, const uvec& EI) {
1630  if(EM.is_empty()) return;
1631  for(unsigned I = 0; I < EI.n_elem; ++I) for(unsigned J = 0; J < EI.n_elem; ++J) global_mass->at(EI(J), EI(I)) += EM(J, I);
1632 }
1633 
1634 template<sp_d T> void Factory<T>::assemble_damping(const Mat<T>& EC, const uvec& EI) {
1635  if(EC.is_empty()) return;
1636  for(unsigned I = 0; I < EI.n_elem; ++I) for(unsigned J = 0; J < EI.n_elem; ++J) global_damping->at(EI(J), EI(I)) += EC(J, I);
1637 }
1638 
1639 template<sp_d T> void Factory<T>::assemble_stiffness(const Mat<T>& EK, const uvec& EI) {
1640  if(EK.is_empty()) return;
1641  for(unsigned I = 0; I < EI.n_elem; ++I) for(unsigned J = 0; J < EI.n_elem; ++J) global_stiffness->at(EI(J), EI(I)) += EK(J, I);
1642 }
1643 
1644 template<sp_d T> void Factory<T>::assemble_geometry(const Mat<T>& EG, const uvec& EI) {
1645  if(EG.is_empty() || !nlgeom) return;
1646  for(unsigned I = 0; I < EI.n_elem; ++I) for(unsigned J = 0; J < EI.n_elem; ++J) global_geometry->at(EI(J), EI(I)) += EG(J, I);
1647 }
1648 
1649 template<sp_d T> void Factory<T>::assemble_stiffness(const SpMat<T>& EK, const uvec& EI) {
1650  if(EK.is_empty()) return;
1651  for(auto I = EK.begin(); I != EK.end(); ++I) global_stiffness->at(EI(I.row()), EI(I.col())) += *I;
1652 }
1653 
1654 template<sp_d T> void Factory<T>::print() const { suanpan_info("This is a Factory object with size of %u.\n", n_size); }
1655 
1656 #endif // FACTORY_HPP
1657 
get_auxiliary_stiffness
SpMat< T > & get_auxiliary_stiffness(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:95
get_current_temperature
Col< T > & get_current_temperature(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:165
Factory::set_mass
void set_mass(const shared_ptr< MetaMat< T >> &)
Definition: Factory.hpp:925
Factory::get_trial_settlement
const Col< T > & get_trial_settlement() const
Definition: Factory.hpp:975
Factory::clear_eigen
void clear_eigen()
Definition: Factory.hpp:1586
Factory::set_reference_load
void set_reference_load(const SpMat< T > &)
Definition: Factory.hpp:835
get_pre_time
T & get_pre_time(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:167
Factory::set_current_inertial_force
void set_current_inertial_force(const Col< T > &)
Definition: Factory.hpp:893
Factory::set_current_load
void set_current_load(const Col< T > &)
Definition: Factory.hpp:885
get_incre_inertial_force
Col< T > & get_incre_inertial_force(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:135
Factory::reset_resistance
void reset_resistance()
Definition: Factory.hpp:1539
Factory::initialize_resistance
void initialize_resistance()
Definition: Factory.hpp:759
Factory::get_solver
SolverType get_solver() const
Definition: Factory.hpp:632
Factory::get_damping
const shared_ptr< MetaMat< T > > & get_damping() const
Definition: Factory.hpp:1059
StorageScheme::SPARSESYMM
Factory::commit_pre_status
void commit_pre_status()
Definition: Factory.hpp:1365
Factory::commit_inertial_force
void commit_inertial_force()
Definition: Factory.hpp:1330
StorageScheme::FULL
Factory::get_trial_time
const T & get_trial_time() const
Definition: Factory.hpp:969
get_auxiliary_resistance
Col< T > & get_auxiliary_resistance(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:91
Factory::set_size
void set_size(unsigned)
Definition: Factory.hpp:602
get_current_acceleration
Col< T > & get_current_acceleration(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:163
Factory::set_trial_resistance
void set_trial_resistance(const Col< T > &)
Definition: Factory.hpp:845
Factory::assemble_damping_force
void assemble_damping_force(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1619
Factory::commit_pre_resistance
void commit_pre_resistance()
Definition: Factory.hpp:1387
Factory::initialize_geometry
void initialize_geometry()
Definition: Factory.hpp:812
Factory::get_incre_damping_force
const Col< T > & get_incre_damping_force() const
Definition: Factory.hpp:1001
Factory::get_auxiliary_stiffness_mutex
std::mutex & get_auxiliary_stiffness_mutex()
Definition: Factory.hpp:1071
Factory::get_sushi
const Col< T > & get_sushi() const
Definition: Factory.hpp:939
get_pre_displacement
Col< T > & get_pre_displacement(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:181
Factory::update_current_acceleration
void update_current_acceleration(const Col< T > &)
Definition: Factory.hpp:1246
Factory::clear_displacement
void clear_displacement()
Definition: Factory.hpp:1466
Factory::get_pre_settlement
const Col< T > & get_pre_settlement() const
Definition: Factory.hpp:1041
Factory::set_current_damping_force
void set_current_damping_force(const Col< T > &)
Definition: Factory.hpp:891
Factory::set_trial_acceleration
void set_trial_acceleration(const Col< T > &)
Definition: Factory.hpp:855
AnalysisType::BUCKLE
Factory::get_incre_velocity
const Col< T > & get_incre_velocity() const
Definition: Factory.hpp:1007
Factory::get_auxiliary_resistance
const Col< T > & get_auxiliary_resistance() const
Definition: Factory.hpp:949
SolverType::SPIKE
Factory::set_pre_displacement
void set_pre_displacement(const Col< T > &)
Definition: Factory.hpp:917
Factory::update_current_velocity
void update_current_velocity(const Col< T > &)
Definition: Factory.hpp:1241
Factory::set_stiffness
void set_stiffness(const shared_ptr< MetaMat< T >> &)
Definition: Factory.hpp:929
Factory::get_trial_settlement_mutex
std::mutex & get_trial_settlement_mutex()
Definition: Factory.hpp:1077
Factory::get_damping_mutex
std::mutex & get_damping_mutex()
Definition: Factory.hpp:1081
SolverType::MUMPS
Factory::get_pre_time
const T & get_pre_time() const
Definition: Factory.hpp:1035
get_trial_damping_force
Col< T > & get_trial_damping_force(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:111
get_trial_settlement
Col< T > & get_trial_settlement(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:107
Factory::set_eigenvector
void set_eigenvector(const Mat< T > &)
Definition: Factory.hpp:935
Factory::set_current_acceleration
void set_current_acceleration(const Col< T > &)
Definition: Factory.hpp:899
Factory::clear_inertial_force
void clear_inertial_force()
Definition: Factory.hpp:1459
Factory::update_current_time
void update_current_time(const T &)
Definition: Factory.hpp:1201
Factory::update_incre_load
void update_incre_load(const Col< T > &)
Definition: Factory.hpp:1156
Factory::commit_pre_velocity
void commit_pre_velocity()
Definition: Factory.hpp:1395
Factory::update_incre_inertial_force
void update_incre_inertial_force(const Col< T > &)
Definition: Factory.hpp:1176
get_pre_velocity
Col< T > & get_pre_velocity(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:183
Factory::set_tolerance
void set_tolerance(double)
Definition: Factory.hpp:622
Factory::get_reference_load
const SpMat< T > & get_reference_load() const
Definition: Factory.hpp:943
AnalysisType::EIGEN
AnalysisType::DYNAMICS
Factory::get_current_acceleration
const Col< T > & get_current_acceleration() const
Definition: Factory.hpp:1031
Factory::clear_time
void clear_time()
Definition: Factory.hpp:1422
Factory::assemble_damping
void assemble_damping(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1634
get_trial_inertial_force
Col< T > & get_trial_inertial_force(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:113
Factory::is_nlgeom
bool is_nlgeom() const
Definition: Factory.hpp:620
Factory::assemble_geometry
void assemble_geometry(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1644
Factory
A Factory class.
Definition: DomainBase.h:44
Factory::clear_auxiliary_resistance
void clear_auxiliary_resistance()
Definition: Factory.hpp:1494
get_matrix_container
unique_ptr< MetaMat< T > > get_matrix_container(const Factory< T > *const W)
Definition: FactoryHelper.hpp:61
Factory::update_current_damping_force
void update_current_damping_force(const Col< T > &)
Definition: Factory.hpp:1226
Factory::get_current_resistance
const Col< T > & get_current_resistance() const
Definition: Factory.hpp:1021
Factory::update_current_load_factor
void update_current_load_factor(const Col< T > &)
Definition: Factory.hpp:1206
Factory::clear_damping_force
void clear_damping_force()
Definition: Factory.hpp:1452
Factory::initialize_damping
void initialize_damping()
Definition: Factory.hpp:808
Factory::clear_stiffness
void clear_stiffness()
Definition: Factory.hpp:1595
Factory::update_trial_velocity
void update_trial_velocity(const Col< T > &)
Definition: Factory.hpp:1131
Factory::reset
void reset()
Definition: Factory.hpp:1607
Factory::get_auxiliary_stiffness
const SpMat< T > & get_auxiliary_stiffness() const
Definition: Factory.hpp:953
get_trial_resistance
Col< T > & get_trial_resistance(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:109
get_incre_time
T & get_incre_time(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:123
Factory::get_incre_inertial_force
const Col< T > & get_incre_inertial_force() const
Definition: Factory.hpp:1003
Factory::update_trial_settlement
void update_trial_settlement(const Col< T > &)
Definition: Factory.hpp:1106
get_pre_load_factor
Col< T1 > & get_pre_load_factor(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:169
Factory::get_pre_load_factor
const Col< T > & get_pre_load_factor() const
Definition: Factory.hpp:1037
Factory::clear_settlement
void clear_settlement()
Definition: Factory.hpp:1438
Factory::get_incre_settlement
const Col< T > & get_incre_settlement() const
Definition: Factory.hpp:997
Factory::get_trial_load
const Col< T > & get_trial_load() const
Definition: Factory.hpp:973
Factory::reset_settlement
void reset_settlement()
Definition: Factory.hpp:1533
Factory::set_ninja
void set_ninja(const Col< T > &)
Definition: Factory.hpp:823
Factory::get_incre_load
const Col< T > & get_incre_load() const
Definition: Factory.hpp:995
Factory::commit_pre_time
void commit_pre_time()
Definition: Factory.hpp:1379
Factory::get_auxiliary_encoding_mutex
std::mutex & get_auxiliary_encoding_mutex()
Definition: Factory.hpp:1065
Factory::get_pre_load
const Col< T > & get_pre_load() const
Definition: Factory.hpp:1039
Factory::get_current_displacement
const Col< T > & get_current_displacement() const
Definition: Factory.hpp:1027
Factory::commit_settlement
void commit_settlement()
Definition: Factory.hpp:1312
Factory::set_pre_settlement
void set_pre_settlement(const Col< T > &)
Definition: Factory.hpp:909
get_eigenvector
Mat< T > & get_eigenvector(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:191
Factory::get_auxiliary_load
const Col< T > & get_auxiliary_load() const
Definition: Factory.hpp:951
Factory::commit_damping_force
void commit_damping_force()
Definition: Factory.hpp:1324
Factory::commit_pre_load_factor
void commit_pre_load_factor()
Definition: Factory.hpp:1381
Factory::clear_temperature
void clear_temperature()
Definition: Factory.hpp:1487
Factory::get_trial_inertial_force
const Col< T > & get_trial_inertial_force() const
Definition: Factory.hpp:981
Factory::commit_load_factor
void commit_load_factor()
Definition: Factory.hpp:1300
Factory::set_pre_inertial_force
void set_pre_inertial_force(const Col< T > &)
Definition: Factory.hpp:915
Factory::assemble_mass
void assemble_mass(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1629
get_current_time
T & get_current_time(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:145
Factory::update_incre_velocity
void update_incre_velocity(const Col< T > &)
Definition: Factory.hpp:1186
Factory::get_incre_resistance
const Col< T > & get_incre_resistance() const
Definition: Factory.hpp:999
get_current_constraint_resistance
SpCol< T1 > & get_current_constraint_resistance(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:99
get_incre_resistance
Col< T > & get_incre_resistance(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:131
Factory::get_eigenvector
const Mat< T > & get_eigenvector() const
Definition: Factory.hpp:1089
Factory::update_incre_temperature
void update_incre_temperature(const Col< T > &)
Definition: Factory.hpp:1196
Factory::clear_auxiliary
void clear_auxiliary()
Definition: Factory.hpp:1599
Factory::get_error
const T & get_error() const
Definition: Factory.hpp:684
get_trial_time
T & get_trial_time(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:101
Factory::update_incre_load_factor
void update_incre_load_factor(const Col< T > &)
Definition: Factory.hpp:1151
get_current_displacement
Col< T > & get_current_displacement(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:159
Factory::initialize_auxiliary_resistance
void initialize_auxiliary_resistance()
Definition: Factory.hpp:801
Factory::set_sushi
void set_sushi(const Col< T > &)
Definition: Factory.hpp:825
Factory::get_pre_temperature
const Col< T > & get_pre_temperature() const
Definition: Factory.hpp:1055
Factory::get_trial_displacement
const Col< T > & get_trial_displacement() const
Definition: Factory.hpp:983
PlaneType::N
get_mass
shared_ptr< MetaMat< T1 > > & get_mass(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:71
get_trial_velocity
Col< T > & get_trial_velocity(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:117
Factory::get_trial_acceleration
const Col< T > & get_trial_acceleration() const
Definition: Factory.hpp:987
Factory::set_reference_dof
void set_reference_dof(const suanpan::set< uword > &)
Definition: Factory.hpp:678
get_incre_load_factor
Col< T1 > & get_incre_load_factor(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:125
Factory::commit_resistance
void commit_resistance()
Definition: Factory.hpp:1318
Factory::update_current_resistance
void update_current_resistance(const Col< T > &)
Definition: Factory.hpp:1221
Factory::update_current_settlement
void update_current_settlement(const Col< T > &)
Definition: Factory.hpp:1216
Factory::update_trial_displacement
void update_trial_displacement(const Col< T > &)
Definition: Factory.hpp:1126
Factory::get_strain_energy
T get_strain_energy()
Definition: Factory.hpp:959
SolverType::PARDISO
Factory::initialize_displacement
void initialize_displacement()
Definition: Factory.hpp:777
Factory::update_incre_damping_force
void update_incre_damping_force(const Col< T > &)
Definition: Factory.hpp:1171
Factory::get_mpc
unsigned get_mpc() const
Definition: Factory.hpp:941
get_basic_container
unique_ptr< MetaMat< T > > get_basic_container(const Factory< T > *const W)
Definition: FactoryHelper.hpp:26
get_eigenvalue
Col< T > & get_eigenvalue(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:189
Factory::set_storage_scheme
void set_storage_scheme(StorageScheme)
Definition: Factory.hpp:644
Factory::set_pre_temperature
void set_pre_temperature(const Col< T > &)
Definition: Factory.hpp:923
Factory::get_tolerance
double get_tolerance() const
Definition: Factory.hpp:624
get_incre_damping_force
Col< T > & get_incre_damping_force(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:133
Factory::get_momentum
const Col< T > & get_momentum()
Definition: Factory.hpp:967
Factory::set_incre_resistance
void set_incre_resistance(const Col< T > &)
Definition: Factory.hpp:867
Factory::commit_pre_temperature
void commit_pre_temperature()
Definition: Factory.hpp:1399
get_trial_load_factor
Col< T1 > & get_trial_load_factor(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:103
Factory::update_trial_time
void update_trial_time(const T &)
Definition: Factory.hpp:1091
OutputType::U
Factory::commit_temperature
void commit_temperature()
Definition: Factory.hpp:1354
Factory::set_current_time
void set_current_time(const T &)
Definition: Factory.hpp:881
Factory::get_stiffness
const shared_ptr< MetaMat< T > > & get_stiffness() const
Definition: Factory.hpp:1061
Factory::update_trial_load_factor
void update_trial_load_factor(const Col< T > &)
Definition: Factory.hpp:1096
Factory::reset_velocity
void reset_velocity()
Definition: Factory.hpp:1563
get_auxiliary_load
Col< T > & get_auxiliary_load(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:93
Factory::is_sparse
bool is_sparse() const
Definition: Factory.hpp:652
get_reference_load
SpMat< T > & get_reference_load(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:85
Factory::commit_velocity
void commit_velocity()
Definition: Factory.hpp:1342
Factory::reset_time
void reset_time()
Definition: Factory.hpp:1516
OutputType::AT
get_current_settlement
Col< T > & get_current_settlement(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:151
Factory::update_trial_temperature
void update_trial_temperature(const Col< T > &)
Definition: Factory.hpp:1141
Factory::reset_status
void reset_status()
Definition: Factory.hpp:1499
Factory::set_nlgeom
void set_nlgeom(bool)
Definition: Factory.hpp:614
get_reference_dof
suanpan::set< uword > & get_reference_dof(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:83
Factory::initialize_eigen
void initialize_eigen()
Definition: Factory.hpp:818
Factory::commit_acceleration
void commit_acceleration()
Definition: Factory.hpp:1348
Factory::update_incre_displacement
void update_incre_displacement(const Col< T > &)
Definition: Factory.hpp:1181
Factory::update_incre_settlement
void update_incre_settlement(const Col< T > &)
Definition: Factory.hpp:1161
get_pre_damping_force
Col< T > & get_pre_damping_force(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:177
Factory::get_kinetic_energy
T get_kinetic_energy()
Definition: Factory.hpp:961
Factory::initialized
const bool initialized
Definition: Factory.hpp:173
Factory::commit_energy
void commit_energy()
Definition: Factory.hpp:1256
get_pre_inertial_force
Col< T > & get_pre_inertial_force(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:179
Factory::set_current_velocity
void set_current_velocity(const Col< T > &)
Definition: Factory.hpp:897
OutputType::M
get_current_velocity
Col< T > & get_current_velocity(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:161
PlaneType::A
Factory::commit_load
void commit_load()
Definition: Factory.hpp:1306
get_current_damping_force
Col< T > & get_current_damping_force(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:155
Factory::reset_load_factor
void reset_load_factor()
Definition: Factory.hpp:1521
Factory::set_damping
void set_damping(const shared_ptr< MetaMat< T >> &)
Definition: Factory.hpp:927
Factory::set_refinement
void set_refinement(unsigned)
Definition: Factory.hpp:634
Factory::set_pre_damping_force
void set_pre_damping_force(const Col< T > &)
Definition: Factory.hpp:913
Factory::commit_pre_load
void commit_pre_load()
Definition: Factory.hpp:1383
Factory::get_trial_temperature
const Col< T > & get_trial_temperature() const
Definition: Factory.hpp:989
Factory::assemble_resistance
void assemble_resistance(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1614
Factory::get_current_inertial_force
const Col< T > & get_current_inertial_force() const
Definition: Factory.hpp:1025
Factory::get_incre_time
const T & get_incre_time() const
Definition: Factory.hpp:991
ParameterType::G
get_trial_temperature
Col< T > & get_trial_temperature(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:121
Factory::set_pre_acceleration
void set_pre_acceleration(const Col< T > &)
Definition: Factory.hpp:921
DOF::T
get_pre_temperature
Col< T > & get_pre_temperature(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:187
StorageScheme::BANDSYMM
Factory::get_geometry
const shared_ptr< MetaMat< T > > & get_geometry() const
Definition: Factory.hpp:1063
PlaneType::E
Factory::initialize_inertial_force
void initialize_inertial_force()
Definition: Factory.hpp:771
Factory::commit_pre_damping_force
void commit_pre_damping_force()
Definition: Factory.hpp:1389
Factory::update_current_temperature
void update_current_temperature(const Col< T > &)
Definition: Factory.hpp:1251
Factory::assemble_inertial_force
void assemble_inertial_force(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1624
SolverType
SolverType
Definition: Factory.hpp:57
Factory::get_ninja
const Col< T > & get_ninja() const
Definition: Factory.hpp:937
Factory::set_trial_time
void set_trial_time(const T &)
Definition: Factory.hpp:837
Factory::get_entry
uword get_entry() const
Definition: Factory.hpp:612
Factory::set_incre_velocity
void set_incre_velocity(const Col< T > &)
Definition: Factory.hpp:875
OutputType::K
Factory::set_pre_load_factor
void set_pre_load_factor(const Col< T > &)
Definition: Factory.hpp:905
Factory::set_error
void set_error(const T &)
Definition: Factory.hpp:682
Factory::set_current_temperature
void set_current_temperature(const Col< T > &)
Definition: Factory.hpp:901
Factory::clear_velocity
void clear_velocity()
Definition: Factory.hpp:1473
Factory::get_incre_temperature
const Col< T > & get_incre_temperature() const
Definition: Factory.hpp:1011
Factory::commit_time
void commit_time()
Definition: Factory.hpp:1295
AnalysisType::DISP
Factory::get_trial_constraint_resistance_mutex
std::mutex & get_trial_constraint_resistance_mutex()
Definition: Factory.hpp:1073
Factory::set_trial_damping_force
void set_trial_damping_force(const Col< T > &)
Definition: Factory.hpp:847
Factory::update_trial_load
void update_trial_load(const Col< T > &)
Definition: Factory.hpp:1101
Factory::get_current_load
const Col< T > & get_current_load() const
Definition: Factory.hpp:1017
get_pre_acceleration
Col< T > & get_pre_acceleration(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:185
Factory::commit_displacement
void commit_displacement()
Definition: Factory.hpp:1336
Factory::get_incre_displacement
const Col< T > & get_incre_displacement() const
Definition: Factory.hpp:1005
Factory::set_pre_velocity
void set_pre_velocity(const Col< T > &)
Definition: Factory.hpp:919
StorageScheme::SYMMPACK
Factory::initialize_acceleration
void initialize_acceleration()
Definition: Factory.hpp:789
StorageScheme::BAND
Factory::clear_status
void clear_status()
Definition: Factory.hpp:1401
Factory::set_mpc
void set_mpc(unsigned)
Definition: Factory.hpp:827
Factory::get_auxiliary_load_mutex
std::mutex & get_auxiliary_load_mutex()
Definition: Factory.hpp:1069
Factory::get_trial_velocity
const Col< T > & get_trial_velocity() const
Definition: Factory.hpp:985
Factory::set_pre_time
void set_pre_time(const T &)
Definition: Factory.hpp:903
get_incre_velocity
Col< T > & get_incre_velocity(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:139
Factory::reset_acceleration
void reset_acceleration()
Definition: Factory.hpp:1569
Factory::set_entry
void set_entry(uword)
Definition: Factory.hpp:610
get_pre_resistance
Col< T > & get_pre_resistance(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:175
Factory::reset_damping_force
void reset_damping_force()
Definition: Factory.hpp:1545
Factory::set_current_resistance
void set_current_resistance(const Col< T > &)
Definition: Factory.hpp:889
AnalysisType::STATICS
OutputType::SS
get_incre_temperature
Col< T > & get_incre_temperature(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:143
Factory::reset_load
void reset_load()
Definition: Factory.hpp:1527
Factory::get_complementary_energy
T get_complementary_energy()
Definition: Factory.hpp:965
Factory::update_incre_time
void update_incre_time(const T &)
Definition: Factory.hpp:1146
get_stiffness
shared_ptr< MetaMat< T1 > > & get_stiffness(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:75
Factory::update_reference_dof
void update_reference_dof(const uvec &)
Definition: Factory.hpp:676
Factory::set_incre_settlement
void set_incre_settlement(const Col< T > &)
Definition: Factory.hpp:865
Factory::get_incre_acceleration
const Col< T > & get_incre_acceleration() const
Definition: Factory.hpp:1009
Factory::commit_pre_displacement
void commit_pre_displacement()
Definition: Factory.hpp:1393
reset
void reset(ExternalMaterialData *data, int *info)
Definition: ElasticExternal.cpp:74
Factory::get_viscous_energy
T get_viscous_energy()
Definition: Factory.hpp:963
Factory::reset_displacement
void reset_displacement()
Definition: Factory.hpp:1557
Factory::set_incre_load_factor
void set_incre_load_factor(const Col< T > &)
Definition: Factory.hpp:861
Factory::get_trial_damping_force
const Col< T > & get_trial_damping_force() const
Definition: Factory.hpp:979
Factory::get_precision
Precision get_precision() const
Definition: Factory.hpp:628
Factory::get_trial_load_mutex
std::mutex & get_trial_load_mutex()
Definition: Factory.hpp:1075
Factory::get_mass_mutex
std::mutex & get_mass_mutex()
Definition: Factory.hpp:1079
get_current_load_factor
Col< T1 > & get_current_load_factor(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:147
Factory::set_bandwidth
void set_bandwidth(unsigned, unsigned)
Definition: Factory.hpp:654
get_current_inertial_force
Col< T > & get_current_inertial_force(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:157
Factory::get_pre_damping_force
const Col< T > & get_pre_damping_force() const
Definition: Factory.hpp:1045
Factory::get_eigenvalue
const Col< T > & get_eigenvalue() const
Definition: Factory.hpp:1087
Factory::get_reference_size
unsigned get_reference_size() const
Definition: Factory.hpp:674
Factory::get_trial_resistance
const Col< T > & get_trial_resistance() const
Definition: Factory.hpp:977
Factory::initialize_temperature
void initialize_temperature()
Definition: Factory.hpp:795
get_incre_acceleration
Col< T > & get_incre_acceleration(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:141
Factory::reset_auxiliary_resistance
void reset_auxiliary_resistance()
Definition: Factory.hpp:1581
Factory::get_analysis_type
AnalysisType get_analysis_type() const
Definition: Factory.hpp:642
get_incre_settlement
Col< T > & get_incre_settlement(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:129
Factory::get_auxiliary_lambda
const Col< T > & get_auxiliary_lambda() const
Definition: Factory.hpp:947
get_auxiliary_lambda
Col< T1 > & get_auxiliary_lambda(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:89
MetaMat
A MetaMat class that holds matrices.
Definition: MetaMat.hpp:39
Factory::clear_energy
void clear_energy()
Definition: Factory.hpp:1270
get_current_load
Col< T > & get_current_load(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:149
get_pre_settlement
Col< T > & get_pre_settlement(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:173
Factory::get_matrix_container
friend unique_ptr< MetaMat< T1 > > get_matrix_container(const Factory< T1 > *)
Factory::update_current_inertial_force
void update_current_inertial_force(const Col< T > &)
Definition: Factory.hpp:1231
Factory::commit_status
void commit_status()
Definition: Factory.hpp:1278
Factory::Factory
Factory(unsigned=0, AnalysisType=AnalysisType::NONE, StorageScheme=StorageScheme::FULL)
Definition: Factory.hpp:597
Factory::get_current_load_factor
const Col< T > & get_current_load_factor() const
Definition: Factory.hpp:1015
Factory::initialize_settlement
void initialize_settlement()
Definition: Factory.hpp:753
get_trial_load
Col< T > & get_trial_load(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:105
OutputType::V
Factory::update_reference_size
void update_reference_size()
Definition: Factory.hpp:667
Factory::update_incre_acceleration
void update_incre_acceleration(const Col< T > &)
Definition: Factory.hpp:1191
Factory::set_trial_load
void set_trial_load(const Col< T > &)
Definition: Factory.hpp:841
Factory::set_precision
void set_precision(Precision)
Definition: Factory.hpp:626
Factory::set_incre_displacement
void set_incre_displacement(const Col< T > &)
Definition: Factory.hpp:873
get_geometry
shared_ptr< MetaMat< T1 > > & get_geometry(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:77
Factory::set_incre_time
void set_incre_time(const T &)
Definition: Factory.hpp:859
Factory::update_trial_inertial_force
void update_trial_inertial_force(const Col< T > &)
Definition: Factory.hpp:1121
Factory::get_current_time
const T & get_current_time() const
Definition: Factory.hpp:1013
Factory::clear_load_factor
void clear_load_factor()
Definition: Factory.hpp:1424
Factory::get_mass
const shared_ptr< MetaMat< T > > & get_mass() const
Definition: Factory.hpp:1057
StorageScheme::SPARSE
get_trial_displacement
Col< T > & get_trial_displacement(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:115
Factory::get_stiffness_mutex
std::mutex & get_stiffness_mutex()
Definition: Factory.hpp:1083
Factory::initialize
int initialize()
Definition: Factory.hpp:686
Factory::set_incre_load
void set_incre_load(const Col< T > &)
Definition: Factory.hpp:863
Factory::set_pre_resistance
void set_pre_resistance(const Col< T > &)
Definition: Factory.hpp:911
Factory::set_incre_damping_force
void set_incre_damping_force(const Col< T > &)
Definition: Factory.hpp:869
Factory::set_eigenvalue
void set_eigenvalue(const Col< T > &)
Definition: Factory.hpp:933
Factory::commit_pre_inertial_force
void commit_pre_inertial_force()
Definition: Factory.hpp:1391
suanpan::set
std::set< T > set
Definition: container.h:54
Factory::set_incre_temperature
void set_incre_temperature(const Col< T > &)
Definition: Factory.hpp:879
Factory::set_current_settlement
void set_current_settlement(const Col< T > &)
Definition: Factory.hpp:887
SolverType::CUDA
Factory::reset_temperature
void reset_temperature()
Definition: Factory.hpp:1575
Precision::FULL
Factory::get_current_velocity
const Col< T > & get_current_velocity() const
Definition: Factory.hpp:1029
Factory::get_current_temperature
const Col< T > & get_current_temperature() const
Definition: Factory.hpp:1033
Factory::set_trial_settlement
void set_trial_settlement(const Col< T > &)
Definition: Factory.hpp:843
Factory::get_pre_inertial_force
const Col< T > & get_pre_inertial_force() const
Definition: Factory.hpp:1047
get_ninja
Col< T > & get_ninja(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:79
Factory::get_incre_load_factor
const Col< T > & get_incre_load_factor() const
Definition: Factory.hpp:993
Factory::initialize_load
void initialize_load()
Definition: Factory.hpp:747
Factory::update_trial_damping_force
void update_trial_damping_force(const Col< T > &)
Definition: Factory.hpp:1116
Factory::update_trial_resistance
void update_trial_resistance(const Col< T > &)
Definition: Factory.hpp:1111
Factory::initialize_stiffness
void initialize_stiffness()
Definition: Factory.hpp:810
get_auxiliary_encoding
uvec & get_auxiliary_encoding(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:87
Factory::get_current_settlement
const Col< T > & get_current_settlement() const
Definition: Factory.hpp:1019
AnalysisType::NONE
Factory::clear_resistance
void clear_resistance()
Definition: Factory.hpp:1445
Factory::set_incre_acceleration
void set_incre_acceleration(const Col< T > &)
Definition: Factory.hpp:877
Factory::reset_inertial_force
void reset_inertial_force()
Definition: Factory.hpp:1551
Factory::set_current_load_factor
void set_current_load_factor(const Col< T > &)
Definition: Factory.hpp:883
Factory::get_bandwidth
void get_bandwidth(unsigned &, unsigned &) const
Definition: Factory.hpp:662
Factory::set_trial_temperature
void set_trial_temperature(const Col< T > &)
Definition: Factory.hpp:857
get_current_resistance
Col< T > & get_current_resistance(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:153
get_incre_load
Col< T > & get_incre_load(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:127
Factory::get_size
unsigned get_size() const
Definition: Factory.hpp:608
get_trial_acceleration
Col< T > & get_trial_acceleration(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:119
get_incre_displacement
Col< T > & get_incre_displacement(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:137
Factory::set_trial_velocity
void set_trial_velocity(const Col< T > &)
Definition: Factory.hpp:853
SolverType::SUPERLU
Factory::clear_damping
void clear_damping()
Definition: Factory.hpp:1593
Factory::get_trial_constraint_resistance
const SpCol< T > & get_trial_constraint_resistance() const
Definition: Factory.hpp:955
Factory::initialize_load_factor
void initialize_load_factor()
Definition: Factory.hpp:737
Factory::clear_geometry
void clear_geometry()
Definition: Factory.hpp:1597
Factory::commit_auxiliary_resistance
void commit_auxiliary_resistance()
Definition: Factory.hpp:1360
operator_times.hpp
Factory::update_incre_resistance
void update_incre_resistance(const Col< T > &)
Definition: Factory.hpp:1166
get_pre_load
Col< T > & get_pre_load(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:171
Factory::clear_mass
void clear_mass()
Definition: Factory.hpp:1591
Factory::clear_load
void clear_load()
Definition: Factory.hpp:1431
Factory::get_current_damping_force
const Col< T > & get_current_damping_force() const
Definition: Factory.hpp:1023
StorageScheme
StorageScheme
Definition: Factory.hpp:48
SolverType::FGMRES
Factory::get_auxiliary_resistance_mutex
std::mutex & get_auxiliary_resistance_mutex()
Definition: Factory.hpp:1067
Factory::initialize_damping_force
void initialize_damping_force()
Definition: Factory.hpp:765
Factory::set_reference_size
void set_reference_size(unsigned)
Definition: Factory.hpp:669
Factory::get_pre_acceleration
const Col< T > & get_pre_acceleration() const
Definition: Factory.hpp:1053
Factory::update_trial_acceleration
void update_trial_acceleration(const Col< T > &)
Definition: Factory.hpp:1136
Factory::set_incre_inertial_force
void set_incre_inertial_force(const Col< T > &)
Definition: Factory.hpp:871
get_damping
shared_ptr< MetaMat< T1 > > & get_damping(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:73
get_sushi
Col< T > & get_sushi(const shared_ptr< Factory< T >> &W)
Definition: FactoryHelper.hpp:81
Factory::get_pre_velocity
const Col< T > & get_pre_velocity() const
Definition: Factory.hpp:1051
Factory::get_geometry_mutex
std::mutex & get_geometry_mutex()
Definition: Factory.hpp:1085
Factory::print
void print() const
Definition: Factory.hpp:1654
Factory::get_auxiliary_encoding
const uvec & get_auxiliary_encoding() const
Definition: Factory.hpp:945
Factory::get_trial_load_factor
const Col< T > & get_trial_load_factor() const
Definition: Factory.hpp:971
AnalysisType
AnalysisType
Definition: Factory.hpp:39
Factory::get_reference_dof
const suanpan::set< uword > & get_reference_dof() const
Definition: Factory.hpp:680
Factory::update_current_load
void update_current_load(const Col< T > &)
Definition: Factory.hpp:1211
Factory::set_analysis_type
void set_analysis_type(AnalysisType)
Definition: Factory.hpp:636
Factory::set_pre_load
void set_pre_load(const Col< T > &)
Definition: Factory.hpp:907
SolverType::LAPACK
get_solver
shared_ptr< Solver > & get_solver(const shared_ptr< Domain > &D, const unsigned T)
Definition: DomainHelper.cpp:50
Factory::assemble_stiffness
void assemble_stiffness(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1639
Factory::set_trial_displacement
void set_trial_displacement(const Col< T > &)
Definition: Factory.hpp:851
Factory::get_storage_scheme
StorageScheme get_storage_scheme() const
Definition: Factory.hpp:650
Factory::set_geometry
void set_geometry(const shared_ptr< MetaMat< T >> &)
Definition: Factory.hpp:931
Factory::get_pre_displacement
const Col< T > & get_pre_displacement() const
Definition: Factory.hpp:1049
PlaneType::S
Factory::set_trial_inertial_force
void set_trial_inertial_force(const Col< T > &)
Definition: Factory.hpp:849
Factory::set_trial_load_factor
void set_trial_load_factor(const Col< T > &)
Definition: Factory.hpp:839
Factory::set_current_displacement
void set_current_displacement(const Col< T > &)
Definition: Factory.hpp:895
Factory::update_current_displacement
void update_current_displacement(const Col< T > &)
Definition: Factory.hpp:1236
Factory::commit_pre_settlement
void commit_pre_settlement()
Definition: Factory.hpp:1385
Factory::clear_acceleration
void clear_acceleration()
Definition: Factory.hpp:1480
Factory::initialize_mass
void initialize_mass()
Definition: Factory.hpp:806
Factory::commit_pre_acceleration
void commit_pre_acceleration()
Definition: Factory.hpp:1397
Factory::set_solver
void set_solver(SolverType)
Definition: Factory.hpp:630
Factory::get_pre_resistance
const Col< T > & get_pre_resistance() const
Definition: Factory.hpp:1043
Factory::initialize_velocity
void initialize_velocity()
Definition: Factory.hpp:783
get_trial_constraint_resistance
SpCol< T1 > & get_trial_constraint_resistance(const shared_ptr< Factory< T1 >> &W)
Definition: FactoryHelper.hpp:97
Precision
Precision
Definition: MetaMat.hpp:34
Factory::get_current_constraint_resistance
const SpCol< T > & get_current_constraint_resistance() const
Definition: Factory.hpp:957