suanPan
Factory.hpp
Go to the documentation of this file.
1 /*******************************************************************************
2  * Copyright (C) 2017-2023 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 #include <Toolbox/container.h>
36 #include <Element/MappingDOF.h>
37 #include <Domain/MetaMat/MetaMat>
38 
39 #ifdef SUANPAN_MAGMA
40 #include <magmasparse.h>
41 #endif
42 
43 enum class AnalysisType {
44  NONE,
45  DISP,
46  EIGEN,
47  BUCKLE,
48  STATICS,
49  DYNAMICS
50 };
51 
52 enum class StorageScheme {
53  FULL,
54  BAND,
55  BANDSYMM,
56  SYMMPACK,
57  SPARSE,
58  SPARSESYMM
59 };
60 
61 enum class SolverType {
62  LAPACK,
63  SPIKE,
64  SUPERLU,
65  MUMPS,
66  CUDA,
67  PARDISO,
68  FGMRES,
69  MAGMA,
70  LIS
71 };
72 
73 template<sp_d T> class Factory final {
74  unsigned n_size = 0; // number of degrees of freedom
75  unsigned n_lobw = 0; // low bandwidth
76  unsigned n_upbw = 0; // up bandwidth
77  unsigned n_sfbw = n_lobw + n_upbw; // matrix storage offset
78  unsigned n_rfld = 0; // reference load size
79  unsigned n_mpc = 0; // multipoint constraint size
80  uword n_elem = 0;
81 
82  AnalysisType analysis_type = AnalysisType::NONE; // type of analysis
83  StorageScheme storage_type = StorageScheme::FULL; // type of analysis
84 
85 #ifdef SUANPAN_MAGMA
86  magma_dopts magma_setting{};
87 #endif
88 
89  bool nlgeom = false;
90  bool nonviscous = false;
91 
92  SolverType solver = SolverType::LAPACK;
93  SolverSetting<T> setting{};
94 
95  T error = T(0); // error produced by certain solvers
96 
97  Col<T> ninja; // the result from A*X=B
98  Col<T> sushi; // modified right-hand side B
99 
100  suanpan::set<uword> reference_dof;
101  SpMat<T> reference_load;
102 
103  uvec auxiliary_encoding; // for constraints using multiplier method
104  Col<T> auxiliary_lambda; // for constraints using multiplier method
105  Col<T> auxiliary_resistance; // for constraints using multiplier method
106  Col<T> auxiliary_load; // for constraints using multiplier method
107  SpMat<T> auxiliary_stiffness; // for constraints using multiplier method
108 
109  SpCol<T> trial_constraint_resistance;
110  SpCol<T> current_constraint_resistance;
111 
112  T trial_time = T(0); // global trial (pseudo) time
113  T incre_time = T(0); // global incremental (pseudo) time
114  T current_time = T(0); // global current (pseudo) time
115  T pre_time = T(0); // global previous (pseudo) time
116 
117  T strain_energy = T(0);
118  T kinetic_energy = T(0);
119  T viscous_energy = T(0);
120  T nonviscous_energy = T(0);
121  T complementary_energy = T(0);
122  Col<T> momentum;
123 
124  Col<T> trial_load_factor; // global trial load factor
125  Col<T> trial_load; // global trial load vector
126  Col<T> trial_settlement; // global trial displacement load vector
127  Col<T> trial_resistance; // global trial resistance vector
128  Col<T> trial_damping_force; // global trial damping force vector
129  Col<T> trial_nonviscous_force; // global trial nonviscous damping force vector
130  Col<T> trial_inertial_force; // global trial inertial force vector
131  Col<T> trial_displacement; // global trial displacement vector
132  Col<T> trial_velocity; // global trial velocity vector
133  Col<T> trial_acceleration; // global trial acceleration vector
134  Col<T> trial_temperature; // global trial temperature vector
135 
136  Col<T> incre_load_factor; // global incremental load vector
137  Col<T> incre_load; // global incremental load vector
138  Col<T> incre_settlement; // global incremental displacement load vector
139  Col<T> incre_resistance; // global incremental resistance vector
140  Col<T> incre_damping_force; // global incremental damping force vector
141  Col<T> incre_nonviscous_force; // global incremental nonviscous damping force vector
142  Col<T> incre_inertial_force; // global incremental inertial force vector
143  Col<T> incre_displacement; // global incremental displacement vector
144  Col<T> incre_velocity; // global incremental velocity vector
145  Col<T> incre_acceleration; // global incremental acceleration vector
146  Col<T> incre_temperature; // global incremental temperature vector
147 
148  Col<T> current_load_factor; // global current load vector
149  Col<T> current_load; // global current load vector
150  Col<T> current_settlement; // global current displacement load vector
151  Col<T> current_resistance; // global current resistance vector
152  Col<T> current_damping_force; // global current damping force vector
153  Col<T> current_nonviscous_force; // global current nonviscous damping force vector
154  Col<T> current_inertial_force; // global current inertial force vector
155  Col<T> current_displacement; // global current displacement vector
156  Col<T> current_velocity; // global current velocity vector
157  Col<T> current_acceleration; // global current acceleration vector
158  Col<T> current_temperature; // global current temperature vector
159 
160  Col<T> pre_load_factor; // global previous load vector
161  Col<T> pre_load; // global previous load vector
162  Col<T> pre_settlement; // global previous displacement load vector
163  Col<T> pre_resistance; // global previous resistance vector
164  Col<T> pre_damping_force; // global previous damping force vector
165  Col<T> pre_nonviscous_force; // global previous nonviscous damping force vector
166  Col<T> pre_inertial_force; // global previous inertial force vector
167  Col<T> pre_displacement; // global previous displacement vector
168  Col<T> pre_velocity; // global previous velocity vector
169  Col<T> pre_acceleration; // global previous acceleration vector
170  Col<T> pre_temperature; // global previous temperature vector
171 
172  shared_ptr<MetaMat<T>> global_mass = nullptr; // global mass matrix
173  shared_ptr<MetaMat<T>> global_damping = nullptr; // global damping matrix
174  shared_ptr<MetaMat<T>> global_nonviscous = nullptr; // global nonviscous damping matrix
175  shared_ptr<MetaMat<T>> global_stiffness = nullptr; // global stiffness matrix
176  shared_ptr<MetaMat<T>> global_geometry = nullptr; // global geometry matrix
177 
178  std::vector<std::mutex> global_mutex = std::vector<std::mutex>(20);
179 
180  Col<T> eigenvalue; // eigenvalues
181 
182  Mat<T> eigenvector; // eigenvectors
183 
184  unique_ptr<MetaMat<T>> get_basic_container();
185  unique_ptr<MetaMat<T>> get_matrix_container();
186 
187  void assemble_matrix_helper(shared_ptr<MetaMat<T>>&, const Mat<T>&, const uvec&, const std::vector<MappingDOF>&);
188 
189 public:
190  const bool initialized = false;
191 
192  explicit Factory(unsigned = 0, AnalysisType = AnalysisType::NONE, StorageScheme = StorageScheme::FULL);
193 
194  void set_size(unsigned);
195  [[nodiscard]] unsigned get_size() const;
196 
197  void set_entry(uword);
198  [[nodiscard]] uword get_entry() const;
199 
200  void set_nlgeom(bool);
201  [[nodiscard]] bool is_nlgeom() const;
202 
203  void set_nonviscous(bool);
204  [[nodiscard]] bool is_nonviscous() const;
205 
206  void set_solver_type(SolverType);
207  [[nodiscard]] SolverType get_solver_type() const;
208 
209  void set_solver_setting(const SolverSetting<double>&);
210  [[nodiscard]] const SolverSetting<double>& get_solver_setting() const;
211 
212 #ifdef SUANPAN_MAGMA
213  void set_solver_setting(const magma_dopts& magma_opt) { magma_setting = magma_opt; }
214 
215  [[nodiscard]] const magma_dopts& get_magma_setting() const { return magma_setting; }
216 #endif
217 
218  void set_analysis_type(AnalysisType);
219  [[nodiscard]] AnalysisType get_analysis_type() const;
220 
221  void set_storage_scheme(StorageScheme);
222  [[nodiscard]] StorageScheme get_storage_scheme() const;
223 
224  [[nodiscard]] bool is_sparse() const;
225 
226  void set_bandwidth(unsigned, unsigned);
227  void get_bandwidth(unsigned&, unsigned&) const;
228 
229  void update_reference_size();
230  void set_reference_size(unsigned);
231  [[nodiscard]] unsigned get_reference_size() const;
232 
233  void update_reference_dof(const uvec&);
234  void set_reference_dof(const suanpan::set<uword>&);
235  [[nodiscard]] const suanpan::set<uword>& get_reference_dof() const;
236 
237  void set_error(T);
238  T get_error() const;
239 
240  /*************************INITIALIZER*************************/
241 
242  int initialize();
243 
244  void initialize_load_factor();
245  void initialize_load();
246  void initialize_settlement();
247  void initialize_resistance();
248  void initialize_damping_force();
249  void initialize_nonviscous_force();
250  void initialize_inertial_force();
251  void initialize_displacement();
252  void initialize_velocity();
253  void initialize_acceleration();
254  void initialize_temperature();
255  void initialize_auxiliary_resistance();
256 
257  void initialize_mass();
258  void initialize_damping();
259  void initialize_nonviscous();
260  void initialize_stiffness();
261  void initialize_geometry();
262  void initialize_eigen();
263 
264  /*************************SETTER*************************/
265 
266  void set_ninja(const Col<T>&);
267  void set_sushi(const Col<T>&);
268 
269  void update_sushi_by(const Col<T>&);
270 
271  void set_mpc(unsigned);
272 
273  void set_reference_load(const SpMat<T>&);
274 
275  void set_trial_time(T);
276  void set_trial_load_factor(const Col<T>&);
277  void set_trial_load(const Col<T>&);
278  void set_trial_settlement(const Col<T>&);
279  void set_trial_resistance(const Col<T>&);
280  void set_trial_damping_force(const Col<T>&);
281  void set_trial_nonviscous_force(const Col<T>&);
282  void set_trial_inertial_force(const Col<T>&);
283  void set_trial_displacement(const Col<T>&);
284  void set_trial_velocity(const Col<T>&);
285  void set_trial_acceleration(const Col<T>&);
286  void set_trial_temperature(const Col<T>&);
287 
288  void set_incre_time(T);
289  void set_incre_load_factor(const Col<T>&);
290  void set_incre_load(const Col<T>&);
291  void set_incre_settlement(const Col<T>&);
292  void set_incre_resistance(const Col<T>&);
293  void set_incre_damping_force(const Col<T>&);
294  void set_incre_nonviscous_force(const Col<T>&);
295  void set_incre_inertial_force(const Col<T>&);
296  void set_incre_displacement(const Col<T>&);
297  void set_incre_velocity(const Col<T>&);
298  void set_incre_acceleration(const Col<T>&);
299  void set_incre_temperature(const Col<T>&);
300 
301  void set_current_time(T);
302  void set_current_load_factor(const Col<T>&);
303  void set_current_load(const Col<T>&);
304  void set_current_settlement(const Col<T>&);
305  void set_current_resistance(const Col<T>&);
306  void set_current_damping_force(const Col<T>&);
307  void set_current_nonviscous_force(const Col<T>&);
308  void set_current_inertial_force(const Col<T>&);
309  void set_current_displacement(const Col<T>&);
310  void set_current_velocity(const Col<T>&);
311  void set_current_acceleration(const Col<T>&);
312  void set_current_temperature(const Col<T>&);
313 
314  void set_pre_time(T);
315  void set_pre_load_factor(const Col<T>&);
316  void set_pre_load(const Col<T>&);
317  void set_pre_settlement(const Col<T>&);
318  void set_pre_resistance(const Col<T>&);
319  void set_pre_damping_force(const Col<T>&);
320  void set_pre_nonviscous_force(const Col<T>&);
321  void set_pre_inertial_force(const Col<T>&);
322  void set_pre_displacement(const Col<T>&);
323  void set_pre_velocity(const Col<T>&);
324  void set_pre_acceleration(const Col<T>&);
325  void set_pre_temperature(const Col<T>&);
326 
327  void set_mass(const shared_ptr<MetaMat<T>>&);
328  void set_damping(const shared_ptr<MetaMat<T>>&);
329  void set_nonviscous(const shared_ptr<MetaMat<T>>&);
330  void set_stiffness(const shared_ptr<MetaMat<T>>&);
331  void set_geometry(const shared_ptr<MetaMat<T>>&);
332 
333  void set_eigenvalue(const Col<T>&);
334  void set_eigenvector(const Mat<T>&);
335 
336  /*************************GETTER*************************/
337 
338  const Col<T>& get_ninja() const;
339  const Col<T>& get_sushi() const;
340 
341  [[nodiscard]] unsigned get_mpc() const;
342 
343  const SpMat<T>& get_reference_load() const;
344 
345  [[nodiscard]] const uvec& get_auxiliary_encoding() const;
346  const Col<T>& get_auxiliary_lambda() const;
347  const Col<T>& get_auxiliary_resistance() const;
348  const Col<T>& get_auxiliary_load() const;
349  const SpMat<T>& get_auxiliary_stiffness() const;
350 
351  const SpCol<T>& get_trial_constraint_resistance() const;
352  const SpCol<T>& get_current_constraint_resistance() const;
353 
354  T get_strain_energy();
355  T get_kinetic_energy();
356  T get_viscous_energy();
357  T get_nonviscous_energy();
358  T get_complementary_energy();
359  const Col<T>& get_momentum();
360 
361  T get_trial_time() const;
362  const Col<T>& get_trial_load_factor() const;
363  const Col<T>& get_trial_load() const;
364  const Col<T>& get_trial_settlement() const;
365  const Col<T>& get_trial_resistance() const;
366  const Col<T>& get_trial_damping_force() const;
367  const Col<T>& get_trial_nonviscous_force() const;
368  const Col<T>& get_trial_inertial_force() const;
369  const Col<T>& get_trial_displacement() const;
370  const Col<T>& get_trial_velocity() const;
371  const Col<T>& get_trial_acceleration() const;
372  const Col<T>& get_trial_temperature() const;
373 
374  T get_incre_time() const;
375  const Col<T>& get_incre_load_factor() const;
376  const Col<T>& get_incre_load() const;
377  const Col<T>& get_incre_settlement() const;
378  const Col<T>& get_incre_resistance() const;
379  const Col<T>& get_incre_damping_force() const;
380  const Col<T>& get_incre_nonviscous_force() const;
381  const Col<T>& get_incre_inertial_force() const;
382  const Col<T>& get_incre_displacement() const;
383  const Col<T>& get_incre_velocity() const;
384  const Col<T>& get_incre_acceleration() const;
385  const Col<T>& get_incre_temperature() const;
386 
387  T get_current_time() const;
388  const Col<T>& get_current_load_factor() const;
389  const Col<T>& get_current_load() const;
390  const Col<T>& get_current_settlement() const;
391  const Col<T>& get_current_resistance() const;
392  const Col<T>& get_current_damping_force() const;
393  const Col<T>& get_current_nonviscous_force() const;
394  const Col<T>& get_current_inertial_force() const;
395  const Col<T>& get_current_displacement() const;
396  const Col<T>& get_current_velocity() const;
397  const Col<T>& get_current_acceleration() const;
398  const Col<T>& get_current_temperature() const;
399 
400  T get_pre_time() const;
401  const Col<T>& get_pre_load_factor() const;
402  const Col<T>& get_pre_load() const;
403  const Col<T>& get_pre_settlement() const;
404  const Col<T>& get_pre_resistance() const;
405  const Col<T>& get_pre_damping_force() const;
406  const Col<T>& get_pre_nonviscous_force() const;
407  const Col<T>& get_pre_inertial_force() const;
408  const Col<T>& get_pre_displacement() const;
409  const Col<T>& get_pre_velocity() const;
410  const Col<T>& get_pre_acceleration() const;
411  const Col<T>& get_pre_temperature() const;
412 
413  const shared_ptr<MetaMat<T>>& get_mass() const;
414  const shared_ptr<MetaMat<T>>& get_damping() const;
415  const shared_ptr<MetaMat<T>>& get_nonviscous() const;
416  const shared_ptr<MetaMat<T>>& get_stiffness() const;
417  const shared_ptr<MetaMat<T>>& get_geometry() const;
418 
419  std::mutex& get_auxiliary_encoding_mutex();
420  std::mutex& get_auxiliary_resistance_mutex();
421  std::mutex& get_auxiliary_load_mutex();
422  std::mutex& get_auxiliary_stiffness_mutex();
423 
424  std::mutex& get_trial_constraint_resistance_mutex();
425 
426  std::mutex& get_trial_load_mutex();
427  std::mutex& get_trial_settlement_mutex();
428  std::mutex& get_reference_load_mutex();
429 
430  std::mutex& get_mass_mutex();
431  std::mutex& get_damping_mutex();
432  std::mutex& get_nonviscous_mutex();
433  std::mutex& get_stiffness_mutex();
434  std::mutex& get_geometry_mutex();
435 
436  const Col<T>& get_eigenvalue() const;
437  const Mat<T>& get_eigenvector() const;
438 
439  /*************************UPDATER*************************/
440 
441  void update_trial_time(T);
442  void update_trial_load_factor(const Col<T>&);
443  void update_trial_load(const Col<T>&);
444  void update_trial_settlement(const Col<T>&);
445  void update_trial_resistance(const Col<T>&);
446  void update_trial_damping_force(const Col<T>&);
447  void update_trial_nonviscous_force(const Col<T>&);
448  void update_trial_inertial_force(const Col<T>&);
449  void update_trial_displacement(const Col<T>&);
450  void update_trial_velocity(const Col<T>&);
451  void update_trial_acceleration(const Col<T>&);
452  void update_trial_temperature(const Col<T>&);
453 
454  void update_incre_time(T);
455  void update_incre_load_factor(const Col<T>&);
456  void update_incre_load(const Col<T>&);
457  void update_incre_settlement(const Col<T>&);
458  void update_incre_resistance(const Col<T>&);
459  void update_incre_damping_force(const Col<T>&);
460  void update_incre_nonviscous_force(const Col<T>&);
461  void update_incre_inertial_force(const Col<T>&);
462  void update_incre_displacement(const Col<T>&);
463  void update_incre_velocity(const Col<T>&);
464  void update_incre_acceleration(const Col<T>&);
465  void update_incre_temperature(const Col<T>&);
466 
467  void update_current_time(T);
468  void update_current_load_factor(const Col<T>&);
469  void update_current_load(const Col<T>&);
470  void update_current_settlement(const Col<T>&);
471  void update_current_resistance(const Col<T>&);
472  void update_current_damping_force(const Col<T>&);
473  void update_current_nonviscous_force(const Col<T>&);
474  void update_current_inertial_force(const Col<T>&);
475  void update_current_displacement(const Col<T>&);
476  void update_current_velocity(const Col<T>&);
477  void update_current_acceleration(const Col<T>&);
478  void update_current_temperature(const Col<T>&);
479 
480  void update_trial_time_by(T);
481  void update_trial_load_factor_by(const Col<T>&);
482  void update_trial_load_by(const Col<T>&);
483  void update_trial_settlement_by(const Col<T>&);
484  void update_trial_resistance_by(const Col<T>&);
485  void update_trial_damping_force_by(const Col<T>&);
486  void update_trial_nonviscous_force_by(const Col<T>&);
487  void update_trial_inertial_force_by(const Col<T>&);
488  void update_trial_displacement_by(const Col<T>&);
489  void update_trial_velocity_by(const Col<T>&);
490  void update_trial_acceleration_by(const Col<T>&);
491  void update_trial_temperature_by(const Col<T>&);
492 
493  void update_incre_time_by(T);
494  void update_incre_load_factor_by(const Col<T>&);
495  void update_incre_load_by(const Col<T>&);
496  void update_incre_settlement_by(const Col<T>&);
497  void update_incre_resistance_by(const Col<T>&);
498  void update_incre_damping_force_by(const Col<T>&);
499  void update_incre_nonviscous_force_by(const Col<T>&);
500  void update_incre_inertial_force_by(const Col<T>&);
501  void update_incre_displacement_by(const Col<T>&);
502  void update_incre_velocity_by(const Col<T>&);
503  void update_incre_acceleration_by(const Col<T>&);
504  void update_incre_temperature_by(const Col<T>&);
505 
506  void update_current_time_by(T);
507  void update_current_load_factor_by(const Col<T>&);
508  void update_current_load_by(const Col<T>&);
509  void update_current_settlement_by(const Col<T>&);
510  void update_current_resistance_by(const Col<T>&);
511  void update_current_damping_force_by(const Col<T>&);
512  void update_current_nonviscous_force_by(const Col<T>&);
513  void update_current_inertial_force_by(const Col<T>&);
514  void update_current_displacement_by(const Col<T>&);
515  void update_current_velocity_by(const Col<T>&);
516  void update_current_acceleration_by(const Col<T>&);
517  void update_current_temperature_by(const Col<T>&);
518 
519  /*************************FRIEND*************************/
520 
521  Col<T>& modify_ninja();
522  Col<T>& modify_sushi();
523 
524  suanpan::set<uword>& modify_reference_dof();
525  SpMat<T>& modify_reference_load();
526 
527  uvec& modify_auxiliary_encoding();
528  Col<T>& modify_auxiliary_lambda();
529  Col<T>& modify_auxiliary_resistance();
530  Col<T>& modify_auxiliary_load();
531  SpMat<T>& modify_auxiliary_stiffness();
532 
533  SpCol<T>& modify_trial_constraint_resistance();
534  SpCol<T>& modify_current_constraint_resistance();
535 
536  T& modify_trial_time();
537  Col<T>& modify_trial_load_factor();
538  Col<T>& modify_trial_load();
539  Col<T>& modify_trial_settlement();
540  Col<T>& modify_trial_resistance();
541  Col<T>& modify_trial_damping_force();
542  Col<T>& modify_trial_nonviscous_force();
543  Col<T>& modify_trial_inertial_force();
544  Col<T>& modify_trial_displacement();
545  Col<T>& modify_trial_velocity();
546  Col<T>& modify_trial_acceleration();
547  Col<T>& modify_trial_temperature();
548 
549  T& modify_incre_time();
550  Col<T>& modify_incre_load_factor();
551  Col<T>& modify_incre_load();
552  Col<T>& modify_incre_settlement();
553  Col<T>& modify_incre_resistance();
554  Col<T>& modify_incre_damping_force();
555  Col<T>& modify_incre_nonviscous_force();
556  Col<T>& modify_incre_inertial_force();
557  Col<T>& modify_incre_displacement();
558  Col<T>& modify_incre_velocity();
559  Col<T>& modify_incre_acceleration();
560  Col<T>& modify_incre_temperature();
561 
562  T& modify_current_time();
563  Col<T>& modify_current_load_factor();
564  Col<T>& modify_current_load();
565  Col<T>& modify_current_settlement();
566  Col<T>& modify_current_resistance();
567  Col<T>& modify_current_damping_force();
568  Col<T>& modify_current_nonviscous_force();
569  Col<T>& modify_current_inertial_force();
570  Col<T>& modify_current_displacement();
571  Col<T>& modify_current_velocity();
572  Col<T>& modify_current_acceleration();
573  Col<T>& modify_current_temperature();
574 
575  T& modify_pre_time();
576  Col<T>& modify_pre_load_factor();
577  Col<T>& modify_pre_load();
578  Col<T>& modify_pre_settlement();
579  Col<T>& modify_pre_resistance();
580  Col<T>& modify_pre_damping_force();
581  Col<T>& modify_pre_nonviscous_force();
582  Col<T>& modify_pre_inertial_force();
583  Col<T>& modify_pre_displacement();
584  Col<T>& modify_pre_velocity();
585  Col<T>& modify_pre_acceleration();
586  Col<T>& modify_pre_temperature();
587 
588  shared_ptr<MetaMat<T>>& modify_mass();
589  shared_ptr<MetaMat<T>>& modify_damping();
590  shared_ptr<MetaMat<T>>& modify_nonviscous();
591  shared_ptr<MetaMat<T>>& modify_stiffness();
592  shared_ptr<MetaMat<T>>& modify_geometry();
593 
594  Col<T>& modify_eigenvalue();
595  Mat<T>& modify_eigenvector();
596 
597  /*************************STATUS*************************/
598 
599  void commit_energy();
600  void clear_energy();
601 
602  void commit_status();
603  void commit_time();
604  void commit_load_factor();
605  void commit_load();
606  void commit_settlement();
607  void commit_resistance();
608  void commit_damping_force();
609  void commit_nonviscous_force();
610  void commit_inertial_force();
611  void commit_displacement();
612  void commit_velocity();
613  void commit_acceleration();
614  void commit_temperature();
615  void commit_auxiliary_resistance();
616 
617  void commit_pre_status();
618  void commit_pre_time();
619  void commit_pre_load_factor();
620  void commit_pre_load();
621  void commit_pre_settlement();
622  void commit_pre_resistance();
623  void commit_pre_damping_force();
624  void commit_pre_nonviscous_force();
625  void commit_pre_inertial_force();
626  void commit_pre_displacement();
627  void commit_pre_velocity();
628  void commit_pre_acceleration();
629  void commit_pre_temperature();
630 
631  void clear_status();
632  void clear_time();
633  void clear_load_factor();
634  void clear_load();
635  void clear_settlement();
636  void clear_resistance();
637  void clear_damping_force();
638  void clear_nonviscous_force();
639  void clear_inertial_force();
640  void clear_displacement();
641  void clear_velocity();
642  void clear_acceleration();
643  void clear_temperature();
644  void clear_auxiliary_resistance();
645 
646  void reset_status();
647  void reset_time();
648  void reset_load_factor();
649  void reset_load();
650  void reset_settlement();
651  void reset_resistance();
652  void reset_damping_force();
653  void reset_nonviscous_force();
654  void reset_inertial_force();
655  void reset_displacement();
656  void reset_velocity();
657  void reset_acceleration();
658  void reset_temperature();
659  void reset_auxiliary_resistance();
660 
661  void clear_eigen();
662  void clear_mass();
663  void clear_damping();
664  void clear_nonviscous();
665  void clear_stiffness();
666  void clear_geometry();
667  void clear_auxiliary();
668 
669  void reset();
670 
671  /*************************ASSEMBLER*************************/
672 
673  void assemble_resistance(const Mat<T>&, const uvec&);
674  void assemble_damping_force(const Mat<T>&, const uvec&);
675  void assemble_nonviscous_force(const Mat<T>&, const uvec&);
676  void assemble_inertial_force(const Mat<T>&, const uvec&);
677 
678  void assemble_mass(const Mat<T>&, const uvec&, const std::vector<MappingDOF>&);
679  void assemble_damping(const Mat<T>&, const uvec&, const std::vector<MappingDOF>&);
680  void assemble_nonviscous(const Mat<T>&, const uvec&, const std::vector<MappingDOF>&);
681  void assemble_stiffness(const Mat<T>&, const uvec&, const std::vector<MappingDOF>&);
682  void assemble_geometry(const Mat<T>&, const uvec&, const std::vector<MappingDOF>&);
683 
684  void assemble_stiffness(const SpMat<T>&, const uvec&);
685 
686  /*************************UTILITY*************************/
687 
688  void print() const;
689 };
690 
691 template<sp_d T> Factory<T>::Factory(const unsigned D, const AnalysisType AT, const StorageScheme SS)
692  : n_size(D)
693  , analysis_type(AT)
694  , storage_type(SS) {}
695 
696 template<sp_d T> void Factory<T>::set_size(const unsigned D) {
697  if(D == n_size) return;
698  n_size = D;
699  access::rw(initialized) = false;
700 }
701 
702 template<sp_d T> unsigned Factory<T>::get_size() const { return n_size; }
703 
704 template<sp_d T> void Factory<T>::set_entry(const uword N) {
705  n_elem = N;
706  if(n_elem > std::numeric_limits<int>::max()) throw invalid_argument("too many elements");
707 }
708 
709 template<sp_d T> uword Factory<T>::get_entry() const { return n_elem; }
710 
711 template<sp_d T> void Factory<T>::set_nlgeom(const bool B) {
712  if(B == nlgeom) return;
713  nlgeom = B;
714  access::rw(initialized) = false;
715 }
716 
717 template<sp_d T> bool Factory<T>::is_nlgeom() const { return nlgeom; }
718 
719 template<sp_d T> void Factory<T>::set_nonviscous(const bool B) {
720  if(B == nonviscous) return;
721  nonviscous = B;
722  access::rw(initialized) = false;
723 }
724 
725 template<sp_d T> bool Factory<T>::is_nonviscous() const { return nonviscous; }
726 
727 template<sp_d T> void Factory<T>::set_solver_type(const SolverType E) { solver = E; }
728 
729 template<sp_d T> SolverType Factory<T>::get_solver_type() const { return solver; }
730 
731 template<sp_d T> void Factory<T>::set_solver_setting(const SolverSetting<double>& SS) { setting = SS; }
732 
733 template<sp_d T> const SolverSetting<double>& Factory<T>::get_solver_setting() const { return setting; }
734 
735 template<sp_d T> void Factory<T>::set_analysis_type(const AnalysisType AT) {
736  if(AT == analysis_type) return;
737  analysis_type = AT;
738  access::rw(initialized) = false;
739 }
740 
741 template<sp_d T> AnalysisType Factory<T>::get_analysis_type() const { return analysis_type; }
742 
743 template<sp_d T> void Factory<T>::set_storage_scheme(const StorageScheme SS) {
744  if(SS == storage_type) return;
745  storage_type = SS;
746  access::rw(initialized) = false;
747 }
748 
749 template<sp_d T> StorageScheme Factory<T>::get_storage_scheme() const { return storage_type; }
750 
751 template<sp_d T> bool Factory<T>::is_sparse() const { return StorageScheme::SPARSE == storage_type || StorageScheme::SPARSESYMM == storage_type; }
752 
753 template<sp_d T> void Factory<T>::set_bandwidth(const unsigned L, const unsigned U) {
754  if(L == n_lobw && U == n_upbw) return;
755  n_lobw = L;
756  n_upbw = U;
757  n_sfbw = L + U;
758  access::rw(initialized) = false;
759 }
760 
761 template<sp_d T> void Factory<T>::get_bandwidth(unsigned& L, unsigned& U) const {
762  L = n_lobw;
763  U = n_upbw;
764 }
765 
766 template<sp_d T> void Factory<T>::update_reference_size() { n_rfld = static_cast<unsigned>(reference_dof.size()); }
767 
768 template<sp_d T> void Factory<T>::set_reference_size(const unsigned S) {
769  if(S == n_rfld) return;
770  n_rfld = S;
771 }
772 
773 template<sp_d T> unsigned Factory<T>::get_reference_size() const { return n_rfld; }
774 
775 template<sp_d T> void Factory<T>::update_reference_dof(const uvec& S) { reference_dof.insert(S.cbegin(), S.cend()); }
776 
777 template<sp_d T> void Factory<T>::set_reference_dof(const suanpan::set<uword>& D) { reference_dof = D; }
778 
779 template<sp_d T> const suanpan::set<uword>& Factory<T>::get_reference_dof() const { return reference_dof; }
780 
781 template<sp_d T> void Factory<T>::set_error(const T E) { error = E; }
782 
783 template<sp_d T> T Factory<T>::get_error() const { return error; }
784 
785 template<sp_d T> int Factory<T>::initialize() {
786  reference_dof.clear(); // clear reference dof vector in every step
787 
788  if(initialized || n_size == 0) return 0;
789 
790  ninja.zeros(n_size);
791  sushi.zeros(n_size);
792 
793  reset();
794 
795  switch(analysis_type) {
796  case AnalysisType::DISP:
797  initialize_displacement();
798  break;
799  case AnalysisType::EIGEN:
800  initialize_mass();
801  initialize_stiffness();
802  initialize_eigen();
803  break;
804  case AnalysisType::BUCKLE:
805  case AnalysisType::STATICS:
806  initialize_load();
807  initialize_resistance();
808  initialize_displacement();
809  initialize_stiffness();
810  initialize_geometry();
811  break;
812  case AnalysisType::DYNAMICS:
813  initialize_load();
814  initialize_resistance();
815  initialize_damping_force();
816  initialize_nonviscous_force();
817  initialize_inertial_force();
818  initialize_displacement();
819  initialize_velocity();
820  initialize_acceleration();
821  initialize_mass();
822  initialize_damping();
823  initialize_nonviscous();
824  initialize_stiffness();
825  initialize_geometry();
826  break;
827  case AnalysisType::NONE:
828  break;
829  }
830 
831  initialize_auxiliary_resistance();
832 
833  access::rw(initialized) = true;
834 
835  return 0;
836 }
837 
838 template<sp_d T> void Factory<T>::initialize_load_factor() {
839  if(n_rfld == 0) return;
840 
841  trial_load_factor.zeros(n_rfld);
842  incre_load_factor.zeros(n_rfld);
843  current_load_factor.zeros(n_rfld);
844 
845  reference_load.zeros(n_size, n_rfld);
846 }
847 
848 template<sp_d T> void Factory<T>::initialize_load() {
849  trial_load.zeros(n_size);
850  incre_load.zeros(n_size);
851  current_load.zeros(n_size);
852 }
853 
854 template<sp_d T> void Factory<T>::initialize_settlement() {
855  trial_settlement.zeros(n_size);
856  incre_settlement.zeros(n_size);
857  current_settlement.zeros(n_size);
858 }
859 
860 template<sp_d T> void Factory<T>::initialize_resistance() {
861  trial_resistance.zeros(n_size);
862  incre_resistance.zeros(n_size);
863  current_resistance.zeros(n_size);
864 }
865 
866 template<sp_d T> void Factory<T>::initialize_damping_force() {
867  trial_damping_force.zeros(n_size);
868  incre_damping_force.zeros(n_size);
869  current_damping_force.zeros(n_size);
870 }
871 
872 template<sp_d T> void Factory<T>::initialize_nonviscous_force() {
873  trial_nonviscous_force.zeros(n_size);
874  incre_nonviscous_force.zeros(n_size);
875  current_nonviscous_force.zeros(n_size);
876 }
877 
878 template<sp_d T> void Factory<T>::initialize_inertial_force() {
879  trial_inertial_force.zeros(n_size);
880  incre_inertial_force.zeros(n_size);
881  current_inertial_force.zeros(n_size);
882 }
883 
884 template<sp_d T> void Factory<T>::initialize_displacement() {
885  trial_displacement.zeros(n_size);
886  incre_displacement.zeros(n_size);
887  current_displacement.zeros(n_size);
888 }
889 
890 template<sp_d T> void Factory<T>::initialize_velocity() {
891  trial_velocity.zeros(n_size);
892  incre_velocity.zeros(n_size);
893  current_velocity.zeros(n_size);
894 }
895 
896 template<sp_d T> void Factory<T>::initialize_acceleration() {
897  trial_acceleration.zeros(n_size);
898  incre_acceleration.zeros(n_size);
899  current_acceleration.zeros(n_size);
900 }
901 
902 template<sp_d T> void Factory<T>::initialize_temperature() {
903  trial_temperature.zeros(n_size);
904  incre_temperature.zeros(n_size);
905  current_temperature.zeros(n_size);
906 }
907 
908 template<sp_d T> void Factory<T>::initialize_auxiliary_resistance() {
909  trial_constraint_resistance.zeros(n_size);
910  current_constraint_resistance.zeros(n_size);
911 }
912 
913 template<sp_d T> void Factory<T>::initialize_mass() { global_mass = get_matrix_container(); }
914 
915 template<sp_d T> void Factory<T>::initialize_damping() { global_damping = get_matrix_container(); }
916 
917 template<sp_d T> void Factory<T>::initialize_nonviscous() {
918  if(!nonviscous) return;
919 
920  global_nonviscous = get_matrix_container();
921 }
922 
923 template<sp_d T> void Factory<T>::initialize_stiffness() { global_stiffness = get_matrix_container(); }
924 
925 template<sp_d T> void Factory<T>::initialize_geometry() {
926  if(!nlgeom) return;
927 
928  global_geometry = get_matrix_container();
929 }
930 
931 template<sp_d T> void Factory<T>::initialize_eigen() {
932  eigenvalue.zeros(n_size);
933  eigenvector.zeros(n_size, n_size);
934 }
935 
936 template<sp_d T> void Factory<T>::set_ninja(const Col<T>& N) { ninja = N; }
937 
938 template<sp_d T> void Factory<T>::set_sushi(const Col<T>& S) { sushi = S; }
939 
940 template<sp_d T> void Factory<T>::update_sushi_by(const Col<T>& S) { sushi += S; }
941 
942 template<sp_d T> void Factory<T>::set_mpc(const unsigned S) {
943  n_mpc = S;
944  auxiliary_encoding.zeros(n_mpc);
945  auxiliary_resistance.zeros(n_mpc);
946  auxiliary_load.zeros(n_mpc);
947  auxiliary_stiffness.zeros(n_size, n_mpc);
948 }
949 
950 template<sp_d T> void Factory<T>::set_reference_load(const SpMat<T>& L) { reference_load = L; }
951 
952 template<sp_d T> void Factory<T>::set_mass(const shared_ptr<MetaMat<T>>& M) { global_mass = M; }
953 
954 template<sp_d T> void Factory<T>::set_damping(const shared_ptr<MetaMat<T>>& C) { global_damping = C; }
955 
956 template<sp_d T> void Factory<T>::set_nonviscous(const shared_ptr<MetaMat<T>>& C) { global_nonviscous = C; }
957 
958 template<sp_d T> void Factory<T>::set_stiffness(const shared_ptr<MetaMat<T>>& K) { global_stiffness = K; }
959 
960 template<sp_d T> void Factory<T>::set_geometry(const shared_ptr<MetaMat<T>>& G) { global_geometry = G; }
961 
962 template<sp_d T> void Factory<T>::set_eigenvalue(const Col<T>& L) { eigenvalue = L; }
963 
964 template<sp_d T> void Factory<T>::set_eigenvector(const Mat<T>& V) { eigenvector = V; }
965 
966 template<sp_d T> const Col<T>& Factory<T>::get_ninja() const { return ninja; }
967 
968 template<sp_d T> const Col<T>& Factory<T>::get_sushi() const { return sushi; }
969 
970 template<sp_d T> unsigned Factory<T>::get_mpc() const { return n_mpc; }
971 
972 template<sp_d T> const SpMat<T>& Factory<T>::get_reference_load() const { return reference_load; }
973 
974 template<sp_d T> const uvec& Factory<T>::get_auxiliary_encoding() const { return auxiliary_encoding; }
975 
976 template<sp_d T> const Col<T>& Factory<T>::get_auxiliary_lambda() const { return auxiliary_lambda; }
977 
978 template<sp_d T> const Col<T>& Factory<T>::get_auxiliary_resistance() const { return auxiliary_resistance; }
979 
980 template<sp_d T> const Col<T>& Factory<T>::get_auxiliary_load() const { return auxiliary_load; }
981 
982 template<sp_d T> const SpMat<T>& Factory<T>::get_auxiliary_stiffness() const { return auxiliary_stiffness; }
983 
984 template<sp_d T> const SpCol<T>& Factory<T>::get_trial_constraint_resistance() const { return trial_constraint_resistance; }
985 
986 template<sp_d T> const SpCol<T>& Factory<T>::get_current_constraint_resistance() const { return current_constraint_resistance; }
987 
988 template<sp_d T> T Factory<T>::get_strain_energy() { return strain_energy; }
989 
990 template<sp_d T> T Factory<T>::get_kinetic_energy() { return kinetic_energy; }
991 
992 template<sp_d T> T Factory<T>::get_viscous_energy() { return viscous_energy; }
993 
994 template<sp_d T> T Factory<T>::get_nonviscous_energy() { return nonviscous_energy; }
995 
996 template<sp_d T> T Factory<T>::get_complementary_energy() { return complementary_energy; }
997 
998 template<sp_d T> const Col<T>& Factory<T>::get_momentum() { return momentum; }
999 
1000 template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_mass() const { return global_mass; }
1001 
1002 template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_damping() const { return global_damping; }
1003 
1004 template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_nonviscous() const { return global_nonviscous; }
1005 
1006 template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_stiffness() const { return global_stiffness; }
1007 
1008 template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_geometry() const { return global_geometry; }
1009 
1010 template<sp_d T> std::mutex& Factory<T>::get_auxiliary_encoding_mutex() { return global_mutex.at(0); }
1011 
1012 template<sp_d T> std::mutex& Factory<T>::get_auxiliary_resistance_mutex() { return global_mutex.at(1); }
1013 
1014 template<sp_d T> std::mutex& Factory<T>::get_auxiliary_load_mutex() { return global_mutex.at(2); }
1015 
1016 template<sp_d T> std::mutex& Factory<T>::get_auxiliary_stiffness_mutex() { return global_mutex.at(3); }
1017 
1018 template<sp_d T> std::mutex& Factory<T>::get_trial_constraint_resistance_mutex() { return global_mutex.at(4); }
1019 
1020 template<sp_d T> std::mutex& Factory<T>::get_trial_load_mutex() { return global_mutex.at(5); }
1021 
1022 template<sp_d T> std::mutex& Factory<T>::get_trial_settlement_mutex() { return global_mutex.at(6); }
1023 
1024 template<sp_d T> std::mutex& Factory<T>::get_reference_load_mutex() { return global_mutex.at(7); }
1025 
1026 template<sp_d T> std::mutex& Factory<T>::get_mass_mutex() { return global_mutex.at(8); }
1027 
1028 template<sp_d T> std::mutex& Factory<T>::get_damping_mutex() { return global_mutex.at(9); }
1029 
1030 template<sp_d T> std::mutex& Factory<T>::get_nonviscous_mutex() { return global_mutex.at(10); }
1031 
1032 template<sp_d T> std::mutex& Factory<T>::get_stiffness_mutex() { return global_mutex.at(11); }
1033 
1034 template<sp_d T> std::mutex& Factory<T>::get_geometry_mutex() { return global_mutex.at(12); }
1035 
1036 template<sp_d T> const Col<T>& Factory<T>::get_eigenvalue() const { return eigenvalue; }
1037 
1038 template<sp_d T> const Mat<T>& Factory<T>::get_eigenvector() const { return eigenvector; }
1039 
1040 template<sp_d T> void Factory<T>::commit_energy() {
1041  auto se = std::async([&] { if(!trial_resistance.empty() && !incre_displacement.empty()) strain_energy += .5 * dot(trial_resistance + current_resistance, incre_displacement); });
1042  auto ke = std::async([&] { if(!trial_inertial_force.empty() && !trial_velocity.empty()) kinetic_energy = .5 * dot(global_mass * trial_velocity, trial_velocity); });
1043  auto ve = std::async([&] { if(!trial_damping_force.empty() && !incre_displacement.empty()) viscous_energy += .5 * dot(trial_damping_force + current_damping_force, incre_displacement); });
1044  auto ne = std::async([&] { if(!trial_nonviscous_force.empty() && !incre_displacement.empty()) nonviscous_energy += .5 * dot(trial_nonviscous_force + current_nonviscous_force, incre_displacement); });
1045  auto ce = std::async([&] { if(!trial_displacement.empty() && !incre_resistance.empty()) complementary_energy += .5 * dot(trial_displacement + current_displacement, incre_resistance); });
1046  auto mm = std::async([&] { if(!trial_inertial_force.empty() && !trial_velocity.empty()) momentum = global_mass * trial_velocity; });
1047 
1048  se.get();
1049  ke.get();
1050  ve.get();
1051  ne.get();
1052  ce.get();
1053  mm.get();
1054 }
1055 
1056 template<sp_d T> void Factory<T>::clear_energy() {
1057  strain_energy = T(0);
1058  kinetic_energy = T(0);
1059  viscous_energy = T(0);
1060  nonviscous_energy = T(0);
1061  complementary_energy = T(0);
1062  momentum.zeros();
1063 }
1064 
1065 template<sp_d T> void Factory<T>::commit_status() {
1066  ninja.zeros();
1067 
1068  commit_energy();
1069 
1070  commit_time();
1071  commit_load_factor();
1072  commit_load();
1073  commit_settlement();
1074  commit_resistance();
1075  commit_damping_force();
1076  commit_nonviscous_force();
1077  commit_inertial_force();
1078  commit_displacement();
1079  commit_velocity();
1080  commit_acceleration();
1081  commit_temperature();
1082  commit_auxiliary_resistance();
1083 }
1084 
1085 template<sp_d T> void Factory<T>::commit_time() {
1086  current_time = trial_time;
1087  incre_time = T(0);
1088 }
1089 
1090 template<sp_d T> void Factory<T>::commit_load_factor() {
1091  if(trial_load_factor.is_empty()) return;
1092  current_load_factor = trial_load_factor;
1093  incre_load_factor.zeros();
1094 }
1095 
1096 template<sp_d T> void Factory<T>::commit_load() {
1097  if(trial_load.is_empty()) return;
1098  current_load = trial_load;
1099  incre_load.zeros();
1100 }
1101 
1102 template<sp_d T> void Factory<T>::commit_settlement() {
1103  if(trial_settlement.is_empty()) return;
1104  current_settlement = trial_settlement;
1105  incre_settlement.zeros();
1106 }
1107 
1108 template<sp_d T> void Factory<T>::commit_resistance() {
1109  if(trial_resistance.is_empty()) return;
1110  current_resistance = trial_resistance;
1111  incre_resistance.zeros();
1112 }
1113 
1114 template<sp_d T> void Factory<T>::commit_damping_force() {
1115  if(trial_damping_force.is_empty()) return;
1116  current_damping_force = trial_damping_force;
1117  incre_damping_force.zeros();
1118 }
1119 
1120 template<sp_d T> void Factory<T>::commit_nonviscous_force() {
1121  if(trial_nonviscous_force.is_empty()) return;
1122  current_nonviscous_force = trial_nonviscous_force;
1123  incre_nonviscous_force.zeros();
1124 }
1125 
1126 template<sp_d T> void Factory<T>::commit_inertial_force() {
1127  if(trial_inertial_force.is_empty()) return;
1128  current_inertial_force = trial_inertial_force;
1129  incre_inertial_force.zeros();
1130 }
1131 
1132 template<sp_d T> void Factory<T>::commit_displacement() {
1133  if(trial_displacement.is_empty()) return;
1134  current_displacement = trial_displacement;
1135  incre_displacement.zeros();
1136 }
1137 
1138 template<sp_d T> void Factory<T>::commit_velocity() {
1139  if(trial_velocity.is_empty()) return;
1140  current_velocity = trial_velocity;
1141  incre_velocity.zeros();
1142 }
1143 
1144 template<sp_d T> void Factory<T>::commit_acceleration() {
1145  if(trial_acceleration.is_empty()) return;
1146  current_acceleration = trial_acceleration;
1147  incre_acceleration.zeros();
1148 }
1149 
1150 template<sp_d T> void Factory<T>::commit_temperature() {
1151  if(trial_temperature.is_empty()) return;
1152  current_temperature = trial_temperature;
1153  incre_temperature.zeros();
1154 }
1155 
1156 template<sp_d T> void Factory<T>::commit_auxiliary_resistance() {
1157  if(trial_constraint_resistance.is_empty()) return;
1158  current_constraint_resistance = trial_constraint_resistance;
1159 }
1160 
1161 template<sp_d T> void Factory<T>::commit_pre_status() {
1162  commit_pre_time();
1163  commit_pre_load_factor();
1164  commit_pre_load();
1165  commit_pre_settlement();
1166  commit_pre_resistance();
1167  commit_pre_damping_force();
1168  commit_pre_nonviscous_force();
1169  commit_pre_inertial_force();
1170  commit_pre_displacement();
1171  commit_pre_velocity();
1172  commit_pre_acceleration();
1173  commit_pre_temperature();
1174 }
1175 
1176 template<sp_d T> void Factory<T>::commit_pre_time() { pre_time = current_time; }
1177 
1178 template<sp_d T> void Factory<T>::commit_pre_load_factor() { if(!current_load_factor.is_empty()) pre_load_factor = current_load_factor; }
1179 
1180 template<sp_d T> void Factory<T>::commit_pre_load() { if(!current_load.is_empty()) pre_load = current_load; }
1181 
1182 template<sp_d T> void Factory<T>::commit_pre_settlement() { if(!current_settlement.is_empty()) pre_settlement = current_settlement; }
1183 
1184 template<sp_d T> void Factory<T>::commit_pre_resistance() { if(!current_resistance.is_empty()) pre_resistance = current_resistance; }
1185 
1186 template<sp_d T> void Factory<T>::commit_pre_damping_force() { if(!current_damping_force.is_empty()) pre_damping_force = current_damping_force; }
1187 
1188 template<sp_d T> void Factory<T>::commit_pre_nonviscous_force() { if(!current_nonviscous_force.is_empty()) pre_nonviscous_force = current_nonviscous_force; }
1189 
1190 template<sp_d T> void Factory<T>::commit_pre_inertial_force() { if(!current_inertial_force.is_empty()) pre_inertial_force = current_inertial_force; }
1191 
1192 template<sp_d T> void Factory<T>::commit_pre_displacement() { if(!current_displacement.is_empty()) pre_displacement = current_displacement; }
1193 
1194 template<sp_d T> void Factory<T>::commit_pre_velocity() { if(!current_velocity.is_empty()) pre_velocity = current_velocity; }
1195 
1196 template<sp_d T> void Factory<T>::commit_pre_acceleration() { if(!current_acceleration.is_empty()) pre_acceleration = current_acceleration; }
1197 
1198 template<sp_d T> void Factory<T>::commit_pre_temperature() { if(!current_temperature.is_empty()) pre_temperature = current_temperature; }
1199 
1200 template<sp_d T> void Factory<T>::clear_status() {
1201  access::rw(initialized) = false;
1202 
1203  ninja.zeros();
1204 
1205  clear_energy();
1206 
1207  clear_time();
1208  clear_load_factor();
1209  clear_load();
1210  clear_settlement();
1211  clear_resistance();
1212  clear_damping_force();
1213  clear_nonviscous_force();
1214  clear_inertial_force();
1215  clear_displacement();
1216  clear_velocity();
1217  clear_acceleration();
1218  clear_temperature();
1219  clear_auxiliary_resistance();
1220 }
1221 
1222 template<sp_d T> void Factory<T>::clear_time() { trial_time = incre_time = current_time = 0.; }
1223 
1224 template<sp_d T> void Factory<T>::clear_load_factor() {
1225  if(!pre_load_factor.is_empty()) pre_load_factor.zeros();
1226  if(!trial_load_factor.is_empty()) trial_load_factor.zeros();
1227  if(!incre_load_factor.is_empty()) incre_load_factor.zeros();
1228  if(!current_load_factor.is_empty()) current_load_factor.zeros();
1229 }
1230 
1231 template<sp_d T> void Factory<T>::clear_load() {
1232  if(!pre_load.is_empty()) pre_load.zeros();
1233  if(!trial_load.is_empty()) trial_load.zeros();
1234  if(!incre_load.is_empty()) incre_load.zeros();
1235  if(!current_load.is_empty()) current_load.zeros();
1236 }
1237 
1238 template<sp_d T> void Factory<T>::clear_settlement() {
1239  if(!pre_settlement.is_empty()) pre_settlement.zeros();
1240  if(!trial_settlement.is_empty()) trial_settlement.zeros();
1241  if(!incre_settlement.is_empty()) incre_settlement.zeros();
1242  if(!current_settlement.is_empty()) current_settlement.zeros();
1243 }
1244 
1245 template<sp_d T> void Factory<T>::clear_resistance() {
1246  if(!pre_resistance.is_empty()) pre_resistance.zeros();
1247  if(!trial_resistance.is_empty()) trial_resistance.zeros();
1248  if(!incre_resistance.is_empty()) incre_resistance.zeros();
1249  if(!current_resistance.is_empty()) current_resistance.zeros();
1250 }
1251 
1252 template<sp_d T> void Factory<T>::clear_damping_force() {
1253  if(!pre_damping_force.is_empty()) pre_damping_force.zeros();
1254  if(!trial_damping_force.is_empty()) trial_damping_force.zeros();
1255  if(!incre_damping_force.is_empty()) incre_damping_force.zeros();
1256  if(!current_damping_force.is_empty()) current_damping_force.zeros();
1257 }
1258 
1259 template<sp_d T> void Factory<T>::clear_nonviscous_force() {
1260  if(!pre_nonviscous_force.is_empty()) pre_nonviscous_force.zeros();
1261  if(!trial_nonviscous_force.is_empty()) trial_nonviscous_force.zeros();
1262  if(!incre_nonviscous_force.is_empty()) incre_nonviscous_force.zeros();
1263  if(!current_nonviscous_force.is_empty()) current_nonviscous_force.zeros();
1264 }
1265 
1266 template<sp_d T> void Factory<T>::clear_inertial_force() {
1267  if(!pre_inertial_force.is_empty()) pre_inertial_force.zeros();
1268  if(!trial_inertial_force.is_empty()) trial_inertial_force.zeros();
1269  if(!incre_inertial_force.is_empty()) incre_inertial_force.zeros();
1270  if(!current_inertial_force.is_empty()) current_inertial_force.zeros();
1271 }
1272 
1273 template<sp_d T> void Factory<T>::clear_displacement() {
1274  if(!pre_displacement.is_empty()) pre_displacement.zeros();
1275  if(!trial_displacement.is_empty()) trial_displacement.zeros();
1276  if(!incre_displacement.is_empty()) incre_displacement.zeros();
1277  if(!current_displacement.is_empty()) current_displacement.zeros();
1278 }
1279 
1280 template<sp_d T> void Factory<T>::clear_velocity() {
1281  if(!pre_velocity.is_empty()) pre_velocity.zeros();
1282  if(!trial_velocity.is_empty()) trial_velocity.zeros();
1283  if(!incre_velocity.is_empty()) incre_velocity.zeros();
1284  if(!current_velocity.is_empty()) current_velocity.zeros();
1285 }
1286 
1287 template<sp_d T> void Factory<T>::clear_acceleration() {
1288  if(!pre_acceleration.is_empty()) pre_acceleration.zeros();
1289  if(!trial_acceleration.is_empty()) trial_acceleration.zeros();
1290  if(!incre_acceleration.is_empty()) incre_acceleration.zeros();
1291  if(!current_acceleration.is_empty()) current_acceleration.zeros();
1292 }
1293 
1294 template<sp_d T> void Factory<T>::clear_temperature() {
1295  if(!pre_temperature.is_empty()) pre_temperature.zeros();
1296  if(!trial_temperature.is_empty()) trial_temperature.zeros();
1297  if(!incre_temperature.is_empty()) incre_temperature.zeros();
1298  if(!current_temperature.is_empty()) current_temperature.zeros();
1299 }
1300 
1301 template<sp_d T> void Factory<T>::clear_auxiliary_resistance() {
1302  if(!trial_constraint_resistance.is_empty()) trial_constraint_resistance.zeros();
1303  if(!current_constraint_resistance.is_empty()) current_constraint_resistance.zeros();
1304 }
1305 
1306 template<sp_d T> void Factory<T>::reset_status() {
1307  ninja.zeros();
1308 
1309  reset_time();
1310  reset_load_factor();
1311  reset_load();
1312  reset_settlement();
1313  reset_resistance();
1314  reset_damping_force();
1315  reset_nonviscous_force();
1316  reset_inertial_force();
1317  reset_displacement();
1318  reset_velocity();
1319  reset_acceleration();
1320  reset_temperature();
1321  reset_auxiliary_resistance();
1322 }
1323 
1324 template<sp_d T> void Factory<T>::reset_time() {
1325  trial_time = current_time;
1326  incre_time = T(0);
1327 }
1328 
1329 template<sp_d T> void Factory<T>::reset_load_factor() {
1330  if(trial_load_factor.is_empty()) return;
1331  trial_load_factor = current_load_factor;
1332  incre_load_factor.zeros();
1333 }
1334 
1335 template<sp_d T> void Factory<T>::reset_load() {
1336  if(trial_load.is_empty()) return;
1337  trial_load = current_load;
1338  incre_load.zeros();
1339 }
1340 
1341 template<sp_d T> void Factory<T>::reset_settlement() {
1342  if(trial_settlement.is_empty()) return;
1343  trial_settlement = current_settlement;
1344  incre_settlement.zeros();
1345 }
1346 
1347 template<sp_d T> void Factory<T>::reset_resistance() {
1348  if(trial_resistance.is_empty()) return;
1349  trial_resistance = current_resistance;
1350  incre_resistance.zeros();
1351 }
1352 
1353 template<sp_d T> void Factory<T>::reset_damping_force() {
1354  if(trial_damping_force.is_empty()) return;
1355  trial_damping_force = current_damping_force;
1356  incre_damping_force.zeros();
1357 }
1358 
1359 template<sp_d T> void Factory<T>::reset_nonviscous_force() {
1360  if(trial_nonviscous_force.is_empty()) return;
1361  trial_nonviscous_force = current_nonviscous_force;
1362  incre_nonviscous_force.zeros();
1363 }
1364 
1365 template<sp_d T> void Factory<T>::reset_inertial_force() {
1366  if(trial_inertial_force.is_empty()) return;
1367  trial_inertial_force = current_inertial_force;
1368  incre_inertial_force.zeros();
1369 }
1370 
1371 template<sp_d T> void Factory<T>::reset_displacement() {
1372  if(trial_displacement.is_empty()) return;
1373  trial_displacement = current_displacement;
1374  incre_displacement.zeros();
1375 }
1376 
1377 template<sp_d T> void Factory<T>::reset_velocity() {
1378  if(trial_velocity.is_empty()) return;
1379  trial_velocity = current_velocity;
1380  incre_velocity.zeros();
1381 }
1382 
1383 template<sp_d T> void Factory<T>::reset_acceleration() {
1384  if(trial_acceleration.is_empty()) return;
1385  trial_acceleration = current_acceleration;
1386  incre_acceleration.zeros();
1387 }
1388 
1389 template<sp_d T> void Factory<T>::reset_temperature() {
1390  if(trial_temperature.is_empty()) return;
1391  trial_temperature = current_temperature;
1392  incre_temperature.zeros();
1393 }
1394 
1395 template<sp_d T> void Factory<T>::reset_auxiliary_resistance() {
1396  if(trial_constraint_resistance.is_empty()) return;
1397  trial_constraint_resistance = current_constraint_resistance;
1398 }
1399 
1400 template<sp_d T> void Factory<T>::clear_eigen() {
1401  if(!eigenvalue.is_empty()) eigenvalue.zeros();
1402  if(!eigenvector.is_empty()) eigenvector.zeros();
1403 }
1404 
1405 template<sp_d T> void Factory<T>::clear_mass() { if(global_mass != nullptr) global_mass->zeros(); }
1406 
1407 template<sp_d T> void Factory<T>::clear_damping() { if(global_damping != nullptr) global_damping->zeros(); }
1408 
1409 template<sp_d T> void Factory<T>::clear_nonviscous() { if(global_nonviscous != nullptr) global_nonviscous->zeros(); }
1410 
1411 template<sp_d T> void Factory<T>::clear_stiffness() { if(global_stiffness != nullptr) global_stiffness->zeros(); }
1412 
1413 template<sp_d T> void Factory<T>::clear_geometry() { if(global_geometry != nullptr) global_geometry->zeros(); }
1414 
1415 template<sp_d T> void Factory<T>::clear_auxiliary() {
1416  n_mpc = 0;
1417  auxiliary_load.reset();
1418  auxiliary_stiffness.set_size(n_size, 0);
1419  auxiliary_resistance.reset();
1420  auxiliary_encoding.reset();
1421 }
1422 
1423 template<sp_d T> void Factory<T>::reset() {
1424  global_mass = nullptr;
1425  global_damping = nullptr;
1426  global_nonviscous = nullptr;
1427  global_stiffness = nullptr;
1428  global_geometry = nullptr;
1429 }
1430 
1431 template<sp_d T> void Factory<T>::assemble_resistance(const Mat<T>& ER, const uvec& EI) {
1432  if(ER.is_empty()) return;
1433  for(auto I = 0llu; I < EI.n_elem; ++I) trial_resistance(EI(I)) += ER(I);
1434 }
1435 
1436 template<sp_d T> void Factory<T>::assemble_damping_force(const Mat<T>& ER, const uvec& EI) {
1437  if(ER.is_empty()) return;
1438  for(auto I = 0llu; I < EI.n_elem; ++I) trial_damping_force(EI(I)) += ER(I);
1439 }
1440 
1441 template<sp_d T> void Factory<T>::assemble_nonviscous_force(const Mat<T>& ER, const uvec& EI) {
1442  if(ER.is_empty()) return;
1443  for(auto I = 0llu; I < EI.n_elem; ++I) trial_nonviscous_force(EI(I)) += ER(I);
1444 }
1445 
1446 template<sp_d T> void Factory<T>::assemble_inertial_force(const Mat<T>& ER, const uvec& EI) {
1447  if(ER.is_empty()) return;
1448  for(auto I = 0llu; I < EI.n_elem; ++I) trial_inertial_force(EI(I)) += ER(I);
1449 }
1450 
1451 template<sp_d T> void Factory<T>::assemble_matrix_helper(shared_ptr<MetaMat<T>>& GM, const Mat<T>& EM, const uvec& EI, const std::vector<MappingDOF>& MAP) {
1452  if(EM.is_empty()) return;
1453 
1454  if(StorageScheme::BANDSYMM == storage_type || StorageScheme::SYMMPACK == storage_type) for(const auto [g_row, g_col, l_row, l_col] : MAP) GM->unsafe_at(g_row, g_col) += EM(l_row, l_col);
1455  else for(auto I = 0llu; I < EI.n_elem; ++I) for(auto J = 0llu; J < EI.n_elem; ++J) GM->unsafe_at(EI(J), EI(I)) += EM(J, I);
1456 }
1457 
1458 template<sp_d T> void Factory<T>::assemble_mass(const Mat<T>& EM, const uvec& EI, const std::vector<MappingDOF>& MAP) { this->assemble_matrix_helper(global_mass, EM, EI, MAP); }
1459 
1460 template<sp_d T> void Factory<T>::assemble_damping(const Mat<T>& EC, const uvec& EI, const std::vector<MappingDOF>& MAP) { this->assemble_matrix_helper(global_damping, EC, EI, MAP); }
1461 
1462 template<sp_d T> void Factory<T>::assemble_nonviscous(const Mat<T>& EC, const uvec& EI, const std::vector<MappingDOF>& MAP) { this->assemble_matrix_helper(global_nonviscous, EC, EI, MAP); }
1463 
1464 template<sp_d T> void Factory<T>::assemble_stiffness(const Mat<T>& EK, const uvec& EI, const std::vector<MappingDOF>& MAP) { this->assemble_matrix_helper(global_stiffness, EK, EI, MAP); }
1465 
1466 template<sp_d T> void Factory<T>::assemble_geometry(const Mat<T>& EG, const uvec& EI, const std::vector<MappingDOF>& MAP) { this->assemble_matrix_helper(global_geometry, EG, EI, MAP); }
1467 
1468 template<sp_d T> void Factory<T>::assemble_stiffness(const SpMat<T>& EK, const uvec& EI) {
1469  if(EK.is_empty()) return;
1470  for(auto I = EK.begin(); I != EK.end(); ++I) global_stiffness->at(EI(I.row()), EI(I.col())) += *I;
1471 }
1472 
1473 template<sp_d T> void Factory<T>::print() const {
1474  suanpan_info("A Factory object with size of {}.\n", n_size);
1475 }
1476 
1477 template<sp_d T> unique_ptr<MetaMat<T>> Factory<T>::get_basic_container() {
1478  switch(storage_type) {
1479  case StorageScheme::FULL:
1480 #ifdef SUANPAN_CUDA
1481  if(SolverType::CUDA == solver) return std::make_unique<FullMatCUDA<T>>(n_size, n_size);
1482 #endif
1483  return std::make_unique<FullMat<T>>(n_size, n_size);
1484  case StorageScheme::BAND:
1485  if(SolverType::SPIKE == solver) return std::make_unique<BandMatSpike<T>>(n_size, n_lobw, n_upbw);
1486  return std::make_unique<BandMat<T>>(n_size, n_lobw, n_upbw);
1487  case StorageScheme::BANDSYMM:
1488  return std::make_unique<BandSymmMat<T>>(n_size, n_lobw);
1489  case StorageScheme::SYMMPACK:
1490  return std::make_unique<SymmPackMat<T>>(n_size);
1491  case StorageScheme::SPARSE:
1492  if(SolverType::MUMPS == solver) return std::make_unique<SparseMatMUMPS<T>>(n_size, n_size, n_elem);
1493  if(SolverType::LIS == solver) return std::make_unique<SparseMatLis<T>>(n_size, n_size, n_elem);
1494  if(SolverType::SUPERLU == solver) return std::make_unique<SparseMatSuperLU<T>>(n_size, n_size, n_elem);
1495 #ifdef SUANPAN_MKL
1496  if(SolverType::PARDISO == solver) return std::make_unique<SparseMatPARDISO<T>>(n_size, n_size, n_elem);
1497  if(SolverType::FGMRES == solver) return std::make_unique<SparseMatFGMRES<T>>(n_size, n_size, n_elem);
1498 #endif
1499 #ifdef SUANPAN_CUDA
1500  if(SolverType::CUDA == solver) return std::make_unique<SparseMatCUDA<T>>(n_size, n_size, n_elem);
1501 #ifdef SUANPAN_MAGMA
1502  if(SolverType::MAGMA == solver) return std::make_unique<SparseMatMAGMA<T>>(n_size, n_size, magma_setting);
1503 #endif
1504 #endif
1505  return std::make_unique<SparseMatSuperLU<T>>(n_size, n_size, n_elem);
1506  case StorageScheme::SPARSESYMM:
1507 #ifdef SUANPAN_MKL
1508  if(SolverType::FGMRES == solver) return std::make_unique<SparseSymmMatFGMRES<T>>(n_size, n_size, n_elem);
1509 #endif
1510  return std::make_unique<SparseSymmMatMUMPS<T>>(n_size, n_size, n_elem);
1511  default:
1512  throw invalid_argument("need a proper storage scheme");
1513  }
1514 }
1515 
1516 template<sp_d T> unique_ptr<MetaMat<T>> Factory<T>::get_matrix_container() {
1517  auto global_mat = get_basic_container();
1518 
1519  global_mat->set_solver_setting(setting);
1520 
1521  return global_mat;
1522 }
1523 
1524 template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_mass() { return global_mass; }
1525 
1526 template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_damping() { return global_damping; }
1527 
1528 template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_nonviscous() { return global_nonviscous; }
1529 
1530 template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_stiffness() { return global_stiffness; }
1531 
1532 template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_geometry() { return global_geometry; }
1533 
1534 template<sp_d T> Col<T>& Factory<T>::modify_ninja() { return ninja; }
1535 
1536 template<sp_d T> Col<T>& Factory<T>::modify_sushi() { return sushi; }
1537 
1538 template<sp_d T> suanpan::set<uword>& Factory<T>::modify_reference_dof() { return reference_dof; }
1539 
1540 template<sp_d T> SpMat<T>& Factory<T>::modify_reference_load() { return reference_load; }
1541 
1542 template<sp_d T> uvec& Factory<T>::modify_auxiliary_encoding() { return auxiliary_encoding; }
1543 
1544 template<sp_d T> Col<T>& Factory<T>::modify_auxiliary_lambda() { return auxiliary_lambda; }
1545 
1546 template<sp_d T> Col<T>& Factory<T>::modify_auxiliary_resistance() { return auxiliary_resistance; }
1547 
1548 template<sp_d T> Col<T>& Factory<T>::modify_auxiliary_load() { return auxiliary_load; }
1549 
1550 template<sp_d T> SpMat<T>& Factory<T>::modify_auxiliary_stiffness() { return auxiliary_stiffness; }
1551 
1552 template<sp_d T> SpCol<T>& Factory<T>::modify_trial_constraint_resistance() { return trial_constraint_resistance; }
1553 
1554 template<sp_d T> SpCol<T>& Factory<T>::modify_current_constraint_resistance() { return current_constraint_resistance; }
1555 
1556 template<sp_d T> Col<T>& Factory<T>::modify_eigenvalue() { return eigenvalue; }
1557 
1558 template<sp_d T> Mat<T>& Factory<T>::modify_eigenvector() { return eigenvector; }
1559 
1560 template<sp_d T> void Factory<T>::set_trial_time(const T M) { trial_time = M; }
1561 
1562 template<sp_d T> void Factory<T>::set_trial_load_factor(const Col<T>& L) { trial_load_factor = L; }
1563 
1564 template<sp_d T> void Factory<T>::set_trial_load(const Col<T>& L) { trial_load = L; }
1565 
1566 template<sp_d T> void Factory<T>::set_trial_settlement(const Col<T>& S) { trial_settlement = S; }
1567 
1568 template<sp_d T> void Factory<T>::set_trial_resistance(const Col<T>& R) { trial_resistance = R; }
1569 
1570 template<sp_d T> void Factory<T>::set_trial_damping_force(const Col<T>& R) { trial_damping_force = R; }
1571 
1572 template<sp_d T> void Factory<T>::set_trial_nonviscous_force(const Col<T>& R) { trial_nonviscous_force = R; }
1573 
1574 template<sp_d T> void Factory<T>::set_trial_inertial_force(const Col<T>& R) { trial_inertial_force = R; }
1575 
1576 template<sp_d T> void Factory<T>::set_trial_displacement(const Col<T>& D) { trial_displacement = D; }
1577 
1578 template<sp_d T> void Factory<T>::set_trial_velocity(const Col<T>& V) { trial_velocity = V; }
1579 
1580 template<sp_d T> void Factory<T>::set_trial_acceleration(const Col<T>& A) { trial_acceleration = A; }
1581 
1582 template<sp_d T> void Factory<T>::set_trial_temperature(const Col<T>& M) { trial_temperature = M; }
1583 
1584 template<sp_d T> void Factory<T>::set_incre_time(const T M) { incre_time = M; }
1585 
1586 template<sp_d T> void Factory<T>::set_incre_load_factor(const Col<T>& L) { incre_load_factor = L; }
1587 
1588 template<sp_d T> void Factory<T>::set_incre_load(const Col<T>& L) { incre_load = L; }
1589 
1590 template<sp_d T> void Factory<T>::set_incre_settlement(const Col<T>& S) { incre_settlement = S; }
1591 
1592 template<sp_d T> void Factory<T>::set_incre_resistance(const Col<T>& R) { incre_resistance = R; }
1593 
1594 template<sp_d T> void Factory<T>::set_incre_damping_force(const Col<T>& R) { incre_damping_force = R; }
1595 
1596 template<sp_d T> void Factory<T>::set_incre_nonviscous_force(const Col<T>& R) { incre_nonviscous_force = R; }
1597 
1598 template<sp_d T> void Factory<T>::set_incre_inertial_force(const Col<T>& R) { incre_inertial_force = R; }
1599 
1600 template<sp_d T> void Factory<T>::set_incre_displacement(const Col<T>& D) { incre_displacement = D; }
1601 
1602 template<sp_d T> void Factory<T>::set_incre_velocity(const Col<T>& V) { incre_velocity = V; }
1603 
1604 template<sp_d T> void Factory<T>::set_incre_acceleration(const Col<T>& A) { incre_acceleration = A; }
1605 
1606 template<sp_d T> void Factory<T>::set_incre_temperature(const Col<T>& M) { incre_temperature = M; }
1607 
1608 template<sp_d T> void Factory<T>::set_current_time(const T M) { current_time = M; }
1609 
1610 template<sp_d T> void Factory<T>::set_current_load_factor(const Col<T>& L) { current_load_factor = L; }
1611 
1612 template<sp_d T> void Factory<T>::set_current_load(const Col<T>& L) { current_load = L; }
1613 
1614 template<sp_d T> void Factory<T>::set_current_settlement(const Col<T>& S) { current_settlement = S; }
1615 
1616 template<sp_d T> void Factory<T>::set_current_resistance(const Col<T>& R) { current_resistance = R; }
1617 
1618 template<sp_d T> void Factory<T>::set_current_damping_force(const Col<T>& R) { current_damping_force = R; }
1619 
1620 template<sp_d T> void Factory<T>::set_current_nonviscous_force(const Col<T>& R) { current_nonviscous_force = R; }
1621 
1622 template<sp_d T> void Factory<T>::set_current_inertial_force(const Col<T>& R) { current_inertial_force = R; }
1623 
1624 template<sp_d T> void Factory<T>::set_current_displacement(const Col<T>& D) { current_displacement = D; }
1625 
1626 template<sp_d T> void Factory<T>::set_current_velocity(const Col<T>& V) { current_velocity = V; }
1627 
1628 template<sp_d T> void Factory<T>::set_current_acceleration(const Col<T>& A) { current_acceleration = A; }
1629 
1630 template<sp_d T> void Factory<T>::set_current_temperature(const Col<T>& M) { current_temperature = M; }
1631 
1632 template<sp_d T> void Factory<T>::set_pre_time(const T M) { pre_time = M; }
1633 
1634 template<sp_d T> void Factory<T>::set_pre_load_factor(const Col<T>& L) { pre_load_factor = L; }
1635 
1636 template<sp_d T> void Factory<T>::set_pre_load(const Col<T>& L) { pre_load = L; }
1637 
1638 template<sp_d T> void Factory<T>::set_pre_settlement(const Col<T>& S) { pre_settlement = S; }
1639 
1640 template<sp_d T> void Factory<T>::set_pre_resistance(const Col<T>& R) { pre_resistance = R; }
1641 
1642 template<sp_d T> void Factory<T>::set_pre_damping_force(const Col<T>& R) { pre_damping_force = R; }
1643 
1644 template<sp_d T> void Factory<T>::set_pre_nonviscous_force(const Col<T>& R) { pre_nonviscous_force = R; }
1645 
1646 template<sp_d T> void Factory<T>::set_pre_inertial_force(const Col<T>& R) { pre_inertial_force = R; }
1647 
1648 template<sp_d T> void Factory<T>::set_pre_displacement(const Col<T>& D) { pre_displacement = D; }
1649 
1650 template<sp_d T> void Factory<T>::set_pre_velocity(const Col<T>& V) { pre_velocity = V; }
1651 
1652 template<sp_d T> void Factory<T>::set_pre_acceleration(const Col<T>& A) { pre_acceleration = A; }
1653 
1654 template<sp_d T> void Factory<T>::set_pre_temperature(const Col<T>& M) { pre_temperature = M; }
1655 
1656 template<sp_d T> T Factory<T>::get_trial_time() const { return trial_time; }
1657 
1658 template<sp_d T> const Col<T>& Factory<T>::get_trial_load_factor() const { return trial_load_factor; }
1659 
1660 template<sp_d T> const Col<T>& Factory<T>::get_trial_load() const { return trial_load; }
1661 
1662 template<sp_d T> const Col<T>& Factory<T>::get_trial_settlement() const { return trial_settlement; }
1663 
1664 template<sp_d T> const Col<T>& Factory<T>::get_trial_resistance() const { return trial_resistance; }
1665 
1666 template<sp_d T> const Col<T>& Factory<T>::get_trial_damping_force() const { return trial_damping_force; }
1667 
1668 template<sp_d T> const Col<T>& Factory<T>::get_trial_nonviscous_force() const { return trial_nonviscous_force; }
1669 
1670 template<sp_d T> const Col<T>& Factory<T>::get_trial_inertial_force() const { return trial_inertial_force; }
1671 
1672 template<sp_d T> const Col<T>& Factory<T>::get_trial_displacement() const { return trial_displacement; }
1673 
1674 template<sp_d T> const Col<T>& Factory<T>::get_trial_velocity() const { return trial_velocity; }
1675 
1676 template<sp_d T> const Col<T>& Factory<T>::get_trial_acceleration() const { return trial_acceleration; }
1677 
1678 template<sp_d T> const Col<T>& Factory<T>::get_trial_temperature() const { return trial_temperature; }
1679 
1680 template<sp_d T> T Factory<T>::get_incre_time() const { return incre_time; }
1681 
1682 template<sp_d T> const Col<T>& Factory<T>::get_incre_load_factor() const { return incre_load_factor; }
1683 
1684 template<sp_d T> const Col<T>& Factory<T>::get_incre_load() const { return incre_load; }
1685 
1686 template<sp_d T> const Col<T>& Factory<T>::get_incre_settlement() const { return incre_settlement; }
1687 
1688 template<sp_d T> const Col<T>& Factory<T>::get_incre_resistance() const { return incre_resistance; }
1689 
1690 template<sp_d T> const Col<T>& Factory<T>::get_incre_damping_force() const { return incre_damping_force; }
1691 
1692 template<sp_d T> const Col<T>& Factory<T>::get_incre_nonviscous_force() const { return incre_nonviscous_force; }
1693 
1694 template<sp_d T> const Col<T>& Factory<T>::get_incre_inertial_force() const { return incre_inertial_force; }
1695 
1696 template<sp_d T> const Col<T>& Factory<T>::get_incre_displacement() const { return incre_displacement; }
1697 
1698 template<sp_d T> const Col<T>& Factory<T>::get_incre_velocity() const { return incre_velocity; }
1699 
1700 template<sp_d T> const Col<T>& Factory<T>::get_incre_acceleration() const { return incre_acceleration; }
1701 
1702 template<sp_d T> const Col<T>& Factory<T>::get_incre_temperature() const { return incre_temperature; }
1703 
1704 template<sp_d T> T Factory<T>::get_current_time() const { return current_time; }
1705 
1706 template<sp_d T> const Col<T>& Factory<T>::get_current_load_factor() const { return current_load_factor; }
1707 
1708 template<sp_d T> const Col<T>& Factory<T>::get_current_load() const { return current_load; }
1709 
1710 template<sp_d T> const Col<T>& Factory<T>::get_current_settlement() const { return current_settlement; }
1711 
1712 template<sp_d T> const Col<T>& Factory<T>::get_current_resistance() const { return current_resistance; }
1713 
1714 template<sp_d T> const Col<T>& Factory<T>::get_current_damping_force() const { return current_damping_force; }
1715 
1716 template<sp_d T> const Col<T>& Factory<T>::get_current_nonviscous_force() const { return current_nonviscous_force; }
1717 
1718 template<sp_d T> const Col<T>& Factory<T>::get_current_inertial_force() const { return current_inertial_force; }
1719 
1720 template<sp_d T> const Col<T>& Factory<T>::get_current_displacement() const { return current_displacement; }
1721 
1722 template<sp_d T> const Col<T>& Factory<T>::get_current_velocity() const { return current_velocity; }
1723 
1724 template<sp_d T> const Col<T>& Factory<T>::get_current_acceleration() const { return current_acceleration; }
1725 
1726 template<sp_d T> const Col<T>& Factory<T>::get_current_temperature() const { return current_temperature; }
1727 
1728 template<sp_d T> T Factory<T>::get_pre_time() const { return pre_time; }
1729 
1730 template<sp_d T> const Col<T>& Factory<T>::get_pre_load_factor() const { return pre_load_factor; }
1731 
1732 template<sp_d T> const Col<T>& Factory<T>::get_pre_load() const { return pre_load; }
1733 
1734 template<sp_d T> const Col<T>& Factory<T>::get_pre_settlement() const { return pre_settlement; }
1735 
1736 template<sp_d T> const Col<T>& Factory<T>::get_pre_resistance() const { return pre_resistance; }
1737 
1738 template<sp_d T> const Col<T>& Factory<T>::get_pre_damping_force() const { return pre_damping_force; }
1739 
1740 template<sp_d T> const Col<T>& Factory<T>::get_pre_nonviscous_force() const { return pre_nonviscous_force; }
1741 
1742 template<sp_d T> const Col<T>& Factory<T>::get_pre_inertial_force() const { return pre_inertial_force; }
1743 
1744 template<sp_d T> const Col<T>& Factory<T>::get_pre_displacement() const { return pre_displacement; }
1745 
1746 template<sp_d T> const Col<T>& Factory<T>::get_pre_velocity() const { return pre_velocity; }
1747 
1748 template<sp_d T> const Col<T>& Factory<T>::get_pre_acceleration() const { return pre_acceleration; }
1749 
1750 template<sp_d T> const Col<T>& Factory<T>::get_pre_temperature() const { return pre_temperature; }
1751 
1752 template<sp_d T> T& Factory<T>::modify_trial_time() { return trial_time; }
1753 
1754 template<sp_d T> Col<T>& Factory<T>::modify_trial_load_factor() { return trial_load_factor; }
1755 
1756 template<sp_d T> Col<T>& Factory<T>::modify_trial_load() { return trial_load; }
1757 
1758 template<sp_d T> Col<T>& Factory<T>::modify_trial_settlement() { return trial_settlement; }
1759 
1760 template<sp_d T> Col<T>& Factory<T>::modify_trial_resistance() { return trial_resistance; }
1761 
1762 template<sp_d T> Col<T>& Factory<T>::modify_trial_damping_force() { return trial_damping_force; }
1763 
1764 template<sp_d T> Col<T>& Factory<T>::modify_trial_nonviscous_force() { return trial_nonviscous_force; }
1765 
1766 template<sp_d T> Col<T>& Factory<T>::modify_trial_inertial_force() { return trial_inertial_force; }
1767 
1768 template<sp_d T> Col<T>& Factory<T>::modify_trial_displacement() { return trial_displacement; }
1769 
1770 template<sp_d T> Col<T>& Factory<T>::modify_trial_velocity() { return trial_velocity; }
1771 
1772 template<sp_d T> Col<T>& Factory<T>::modify_trial_acceleration() { return trial_acceleration; }
1773 
1774 template<sp_d T> Col<T>& Factory<T>::modify_trial_temperature() { return trial_temperature; }
1775 
1776 template<sp_d T> T& Factory<T>::modify_incre_time() { return incre_time; }
1777 
1778 template<sp_d T> Col<T>& Factory<T>::modify_incre_load_factor() { return incre_load_factor; }
1779 
1780 template<sp_d T> Col<T>& Factory<T>::modify_incre_load() { return incre_load; }
1781 
1782 template<sp_d T> Col<T>& Factory<T>::modify_incre_settlement() { return incre_settlement; }
1783 
1784 template<sp_d T> Col<T>& Factory<T>::modify_incre_resistance() { return incre_resistance; }
1785 
1786 template<sp_d T> Col<T>& Factory<T>::modify_incre_damping_force() { return incre_damping_force; }
1787 
1788 template<sp_d T> Col<T>& Factory<T>::modify_incre_nonviscous_force() { return incre_nonviscous_force; }
1789 
1790 template<sp_d T> Col<T>& Factory<T>::modify_incre_inertial_force() { return incre_inertial_force; }
1791 
1792 template<sp_d T> Col<T>& Factory<T>::modify_incre_displacement() { return incre_displacement; }
1793 
1794 template<sp_d T> Col<T>& Factory<T>::modify_incre_velocity() { return incre_velocity; }
1795 
1796 template<sp_d T> Col<T>& Factory<T>::modify_incre_acceleration() { return incre_acceleration; }
1797 
1798 template<sp_d T> Col<T>& Factory<T>::modify_incre_temperature() { return incre_temperature; }
1799 
1800 template<sp_d T> T& Factory<T>::modify_current_time() { return current_time; }
1801 
1802 template<sp_d T> Col<T>& Factory<T>::modify_current_load_factor() { return current_load_factor; }
1803 
1804 template<sp_d T> Col<T>& Factory<T>::modify_current_load() { return current_load; }
1805 
1806 template<sp_d T> Col<T>& Factory<T>::modify_current_settlement() { return current_settlement; }
1807 
1808 template<sp_d T> Col<T>& Factory<T>::modify_current_resistance() { return current_resistance; }
1809 
1810 template<sp_d T> Col<T>& Factory<T>::modify_current_damping_force() { return current_damping_force; }
1811 
1812 template<sp_d T> Col<T>& Factory<T>::modify_current_nonviscous_force() { return current_nonviscous_force; }
1813 
1814 template<sp_d T> Col<T>& Factory<T>::modify_current_inertial_force() { return current_inertial_force; }
1815 
1816 template<sp_d T> Col<T>& Factory<T>::modify_current_displacement() { return current_displacement; }
1817 
1818 template<sp_d T> Col<T>& Factory<T>::modify_current_velocity() { return current_velocity; }
1819 
1820 template<sp_d T> Col<T>& Factory<T>::modify_current_acceleration() { return current_acceleration; }
1821 
1822 template<sp_d T> Col<T>& Factory<T>::modify_current_temperature() { return current_temperature; }
1823 
1824 template<sp_d T> T& Factory<T>::modify_pre_time() { return pre_time; }
1825 
1826 template<sp_d T> Col<T>& Factory<T>::modify_pre_load_factor() { return pre_load_factor; }
1827 
1828 template<sp_d T> Col<T>& Factory<T>::modify_pre_load() { return pre_load; }
1829 
1830 template<sp_d T> Col<T>& Factory<T>::modify_pre_settlement() { return pre_settlement; }
1831 
1832 template<sp_d T> Col<T>& Factory<T>::modify_pre_resistance() { return pre_resistance; }
1833 
1834 template<sp_d T> Col<T>& Factory<T>::modify_pre_damping_force() { return pre_damping_force; }
1835 
1836 template<sp_d T> Col<T>& Factory<T>::modify_pre_nonviscous_force() { return pre_nonviscous_force; }
1837 
1838 template<sp_d T> Col<T>& Factory<T>::modify_pre_inertial_force() { return pre_inertial_force; }
1839 
1840 template<sp_d T> Col<T>& Factory<T>::modify_pre_displacement() { return pre_displacement; }
1841 
1842 template<sp_d T> Col<T>& Factory<T>::modify_pre_velocity() { return pre_velocity; }
1843 
1844 template<sp_d T> Col<T>& Factory<T>::modify_pre_acceleration() { return pre_acceleration; }
1845 
1846 template<sp_d T> Col<T>& Factory<T>::modify_pre_temperature() { return pre_temperature; }
1847 
1848 template<sp_d T> void Factory<T>::update_trial_time(const T M) {
1849  trial_time = M;
1850  incre_time = trial_time - current_time;
1851 }
1852 
1853 template<sp_d T> void Factory<T>::update_trial_load_factor(const Col<T>& L) {
1854  trial_load_factor = L;
1855  incre_load_factor = trial_load_factor - current_load_factor;
1856 }
1857 
1858 template<sp_d T> void Factory<T>::update_trial_load(const Col<T>& L) {
1859  trial_load = L;
1860  incre_load = trial_load - current_load;
1861 }
1862 
1863 template<sp_d T> void Factory<T>::update_trial_settlement(const Col<T>& S) {
1864  trial_settlement = S;
1865  incre_settlement = trial_settlement - current_settlement;
1866 }
1867 
1868 template<sp_d T> void Factory<T>::update_trial_resistance(const Col<T>& R) {
1869  trial_resistance = R;
1870  incre_resistance = trial_resistance - current_resistance;
1871 }
1872 
1873 template<sp_d T> void Factory<T>::update_trial_damping_force(const Col<T>& R) {
1874  trial_damping_force = R;
1875  incre_damping_force = trial_damping_force - current_damping_force;
1876 }
1877 
1878 template<sp_d T> void Factory<T>::update_trial_nonviscous_force(const Col<T>& R) {
1879  trial_nonviscous_force = R;
1880  incre_nonviscous_force = trial_nonviscous_force - current_nonviscous_force;
1881 }
1882 
1883 template<sp_d T> void Factory<T>::update_trial_inertial_force(const Col<T>& R) {
1884  trial_inertial_force = R;
1885  incre_inertial_force = trial_inertial_force - current_inertial_force;
1886 }
1887 
1888 template<sp_d T> void Factory<T>::update_trial_displacement(const Col<T>& D) {
1889  trial_displacement = D;
1890  incre_displacement = trial_displacement - current_displacement;
1891 }
1892 
1893 template<sp_d T> void Factory<T>::update_trial_velocity(const Col<T>& V) {
1894  trial_velocity = V;
1895  incre_velocity = trial_velocity - current_velocity;
1896 }
1897 
1898 template<sp_d T> void Factory<T>::update_trial_acceleration(const Col<T>& A) {
1899  trial_acceleration = A;
1900  incre_acceleration = trial_acceleration - current_acceleration;
1901 }
1902 
1903 template<sp_d T> void Factory<T>::update_trial_temperature(const Col<T>& M) {
1904  trial_temperature = M;
1905  incre_temperature = trial_temperature - current_temperature;
1906 }
1907 
1908 template<sp_d T> void Factory<T>::update_incre_time(const T M) {
1909  incre_time = M;
1910  trial_time = current_time + incre_time;
1911 }
1912 
1913 template<sp_d T> void Factory<T>::update_incre_load_factor(const Col<T>& L) {
1914  incre_load_factor = L;
1915  trial_load_factor = current_load_factor + incre_load_factor;
1916 }
1917 
1918 template<sp_d T> void Factory<T>::update_incre_load(const Col<T>& L) {
1919  incre_load = L;
1920  trial_load = current_load + incre_load;
1921 }
1922 
1923 template<sp_d T> void Factory<T>::update_incre_settlement(const Col<T>& S) {
1924  incre_settlement = S;
1925  trial_settlement = current_settlement + incre_settlement;
1926 }
1927 
1928 template<sp_d T> void Factory<T>::update_incre_resistance(const Col<T>& R) {
1929  incre_resistance = R;
1930  trial_resistance = current_resistance + incre_resistance;
1931 }
1932 
1933 template<sp_d T> void Factory<T>::update_incre_damping_force(const Col<T>& R) {
1934  incre_damping_force = R;
1935  trial_damping_force = current_damping_force + incre_damping_force;
1936 }
1937 
1938 template<sp_d T> void Factory<T>::update_incre_nonviscous_force(const Col<T>& R) {
1939  incre_nonviscous_force = R;
1940  trial_nonviscous_force = current_nonviscous_force + incre_nonviscous_force;
1941 }
1942 
1943 template<sp_d T> void Factory<T>::update_incre_inertial_force(const Col<T>& R) {
1944  incre_inertial_force = R;
1945  trial_inertial_force = current_inertial_force + incre_inertial_force;
1946 }
1947 
1948 template<sp_d T> void Factory<T>::update_incre_displacement(const Col<T>& D) {
1949  incre_displacement = D;
1950  trial_displacement = current_displacement + incre_displacement;
1951 }
1952 
1953 template<sp_d T> void Factory<T>::update_incre_velocity(const Col<T>& V) {
1954  incre_velocity = V;
1955  trial_velocity = current_velocity + incre_velocity;
1956 }
1957 
1958 template<sp_d T> void Factory<T>::update_incre_acceleration(const Col<T>& A) {
1959  incre_acceleration = A;
1960  trial_acceleration = current_acceleration + incre_acceleration;
1961 }
1962 
1963 template<sp_d T> void Factory<T>::update_incre_temperature(const Col<T>& M) {
1964  incre_temperature = M;
1965  trial_temperature = current_temperature + incre_temperature;
1966 }
1967 
1968 template<sp_d T> void Factory<T>::update_current_time(const T M) {
1969  trial_time = current_time = M;
1970  incre_time = T(0);
1971 }
1972 
1973 template<sp_d T> void Factory<T>::update_current_load_factor(const Col<T>& L) {
1974  trial_load_factor = current_load_factor = L;
1975  incre_load_factor.zeros();
1976 }
1977 
1978 template<sp_d T> void Factory<T>::update_current_load(const Col<T>& L) {
1979  trial_load = current_load = L;
1980  incre_load.zeros();
1981 }
1982 
1983 template<sp_d T> void Factory<T>::update_current_settlement(const Col<T>& S) {
1984  trial_settlement = current_settlement = S;
1985  incre_settlement.zeros();
1986 }
1987 
1988 template<sp_d T> void Factory<T>::update_current_resistance(const Col<T>& R) {
1989  trial_resistance = current_resistance = R;
1990  incre_resistance.zeros();
1991 }
1992 
1993 template<sp_d T> void Factory<T>::update_current_damping_force(const Col<T>& R) {
1994  trial_damping_force = current_damping_force = R;
1995  incre_damping_force.zeros();
1996 }
1997 
1998 template<sp_d T> void Factory<T>::update_current_nonviscous_force(const Col<T>& R) {
1999  trial_nonviscous_force = current_nonviscous_force = R;
2000  incre_nonviscous_force.zeros();
2001 }
2002 
2003 template<sp_d T> void Factory<T>::update_current_inertial_force(const Col<T>& R) {
2004  trial_inertial_force = current_inertial_force = R;
2005  incre_inertial_force.zeros();
2006 }
2007 
2008 template<sp_d T> void Factory<T>::update_current_displacement(const Col<T>& D) {
2009  trial_displacement = current_displacement = D;
2010  incre_displacement.zeros();
2011 }
2012 
2013 template<sp_d T> void Factory<T>::update_current_velocity(const Col<T>& V) {
2014  trial_velocity = current_velocity = V;
2015  incre_velocity.zeros();
2016 }
2017 
2018 template<sp_d T> void Factory<T>::update_current_acceleration(const Col<T>& A) {
2019  trial_acceleration = current_acceleration = A;
2020  incre_acceleration.zeros();
2021 }
2022 
2023 template<sp_d T> void Factory<T>::update_current_temperature(const Col<T>& M) {
2024  trial_temperature = current_temperature = M;
2025  incre_temperature.zeros();
2026 }
2027 
2028 template<sp_d T> void Factory<T>::update_trial_time_by(const T M) {
2029  trial_time += M;
2030  incre_time = trial_time - current_time;
2031 }
2032 
2033 template<sp_d T> void Factory<T>::update_trial_load_factor_by(const Col<T>& L) {
2034  trial_load_factor += L;
2035  incre_load_factor = trial_load_factor - current_load_factor;
2036 }
2037 
2038 template<sp_d T> void Factory<T>::update_trial_load_by(const Col<T>& L) {
2039  trial_load += L;
2040  incre_load = trial_load - current_load;
2041 }
2042 
2043 template<sp_d T> void Factory<T>::update_trial_settlement_by(const Col<T>& S) {
2044  trial_settlement += S;
2045  incre_settlement = trial_settlement - current_settlement;
2046 }
2047 
2048 template<sp_d T> void Factory<T>::update_trial_resistance_by(const Col<T>& R) {
2049  trial_resistance += R;
2050  incre_resistance = trial_resistance - current_resistance;
2051 }
2052 
2053 template<sp_d T> void Factory<T>::update_trial_damping_force_by(const Col<T>& R) {
2054  trial_damping_force += R;
2055  incre_damping_force = trial_damping_force - current_damping_force;
2056 }
2057 
2058 template<sp_d T> void Factory<T>::update_trial_nonviscous_force_by(const Col<T>& R) {
2059  trial_nonviscous_force += R;
2060  incre_nonviscous_force = trial_nonviscous_force - current_nonviscous_force;
2061 }
2062 
2063 template<sp_d T> void Factory<T>::update_trial_inertial_force_by(const Col<T>& R) {
2064  trial_inertial_force += R;
2065  incre_inertial_force = trial_inertial_force - current_inertial_force;
2066 }
2067 
2068 template<sp_d T> void Factory<T>::update_trial_displacement_by(const Col<T>& D) {
2069  trial_displacement += D;
2070  incre_displacement = trial_displacement - current_displacement;
2071 }
2072 
2073 template<sp_d T> void Factory<T>::update_trial_velocity_by(const Col<T>& V) {
2074  trial_velocity += V;
2075  incre_velocity = trial_velocity - current_velocity;
2076 }
2077 
2078 template<sp_d T> void Factory<T>::update_trial_acceleration_by(const Col<T>& A) {
2079  trial_acceleration += A;
2080  incre_acceleration = trial_acceleration - current_acceleration;
2081 }
2082 
2083 template<sp_d T> void Factory<T>::update_trial_temperature_by(const Col<T>& M) {
2084  trial_temperature += M;
2085  incre_temperature = trial_temperature - current_temperature;
2086 }
2087 
2088 template<sp_d T> void Factory<T>::update_incre_time_by(const T M) {
2089  incre_time += M;
2090  trial_time = current_time + incre_time;
2091 }
2092 
2093 template<sp_d T> void Factory<T>::update_incre_load_factor_by(const Col<T>& L) {
2094  incre_load_factor += L;
2095  trial_load_factor = current_load_factor + incre_load_factor;
2096 }
2097 
2098 template<sp_d T> void Factory<T>::update_incre_load_by(const Col<T>& L) {
2099  incre_load += L;
2100  trial_load = current_load + incre_load;
2101 }
2102 
2103 template<sp_d T> void Factory<T>::update_incre_settlement_by(const Col<T>& S) {
2104  incre_settlement += S;
2105  trial_settlement = current_settlement + incre_settlement;
2106 }
2107 
2108 template<sp_d T> void Factory<T>::update_incre_resistance_by(const Col<T>& R) {
2109  incre_resistance += R;
2110  trial_resistance = current_resistance + incre_resistance;
2111 }
2112 
2113 template<sp_d T> void Factory<T>::update_incre_damping_force_by(const Col<T>& R) {
2114  incre_damping_force += R;
2115  trial_damping_force = current_damping_force + incre_damping_force;
2116 }
2117 
2118 template<sp_d T> void Factory<T>::update_incre_nonviscous_force_by(const Col<T>& R) {
2119  incre_nonviscous_force += R;
2120  trial_nonviscous_force = current_nonviscous_force + incre_nonviscous_force;
2121 }
2122 
2123 template<sp_d T> void Factory<T>::update_incre_inertial_force_by(const Col<T>& R) {
2124  incre_inertial_force += R;
2125  trial_inertial_force = current_inertial_force + incre_inertial_force;
2126 }
2127 
2128 template<sp_d T> void Factory<T>::update_incre_displacement_by(const Col<T>& D) {
2129  incre_displacement += D;
2130  trial_displacement = current_displacement + incre_displacement;
2131 }
2132 
2133 template<sp_d T> void Factory<T>::update_incre_velocity_by(const Col<T>& V) {
2134  incre_velocity += V;
2135  trial_velocity = current_velocity + incre_velocity;
2136 }
2137 
2138 template<sp_d T> void Factory<T>::update_incre_acceleration_by(const Col<T>& A) {
2139  incre_acceleration += A;
2140  trial_acceleration = current_acceleration + incre_acceleration;
2141 }
2142 
2143 template<sp_d T> void Factory<T>::update_incre_temperature_by(const Col<T>& M) {
2144  incre_temperature += M;
2145  trial_temperature = current_temperature + incre_temperature;
2146 }
2147 
2148 template<sp_d T> void Factory<T>::update_current_time_by(const T M) {
2149  trial_time = current_time += M;
2150  incre_time = 0.;
2151 }
2152 
2153 template<sp_d T> void Factory<T>::update_current_load_factor_by(const Col<T>& L) {
2154  trial_load_factor = current_load_factor += L;
2155  incre_load_factor.zeros();
2156 }
2157 
2158 template<sp_d T> void Factory<T>::update_current_load_by(const Col<T>& L) {
2159  trial_load = current_load += L;
2160  incre_load.zeros();
2161 }
2162 
2163 template<sp_d T> void Factory<T>::update_current_settlement_by(const Col<T>& S) {
2164  trial_settlement = current_settlement += S;
2165  incre_settlement.zeros();
2166 }
2167 
2168 template<sp_d T> void Factory<T>::update_current_resistance_by(const Col<T>& R) {
2169  trial_resistance = current_resistance += R;
2170  incre_resistance.zeros();
2171 }
2172 
2173 template<sp_d T> void Factory<T>::update_current_damping_force_by(const Col<T>& R) {
2174  trial_damping_force = current_damping_force += R;
2175  incre_damping_force.zeros();
2176 }
2177 
2178 template<sp_d T> void Factory<T>::update_current_nonviscous_force_by(const Col<T>& R) {
2179  trial_nonviscous_force = current_nonviscous_force += R;
2180  incre_nonviscous_force.zeros();
2181 }
2182 
2183 template<sp_d T> void Factory<T>::update_current_inertial_force_by(const Col<T>& R) {
2184  trial_inertial_force = current_inertial_force += R;
2185  incre_inertial_force.zeros();
2186 }
2187 
2188 template<sp_d T> void Factory<T>::update_current_displacement_by(const Col<T>& D) {
2189  trial_displacement = current_displacement += D;
2190  incre_displacement.zeros();
2191 }
2192 
2193 template<sp_d T> void Factory<T>::update_current_velocity_by(const Col<T>& V) {
2194  trial_velocity = current_velocity += V;
2195  incre_velocity.zeros();
2196 }
2197 
2198 template<sp_d T> void Factory<T>::update_current_acceleration_by(const Col<T>& A) {
2199  trial_acceleration = current_acceleration += A;
2200  incre_acceleration.zeros();
2201 }
2202 
2203 template<sp_d T> void Factory<T>::update_current_temperature_by(const Col<T>& M) {
2204  trial_temperature = current_temperature += M;
2205  incre_temperature.zeros();
2206 }
2207 
2208 #endif // FACTORY_HPP
2209 
reset
void reset(ExternalMaterialData *data, int *info)
Definition: ElasticExternal.cpp:74
Factory
A Factory class.
Definition: Factory.hpp:73
Factory::initialized
const bool initialized
Definition: Factory.hpp:190
MetaMat
A MetaMat class that holds matrices.
Definition: MetaMat.hpp:39
PlaneType::E
@ E
PlaneType::S
@ S
PlaneType::A
@ A
PlaneType::N
@ N
DOF::T
@ T
Factory::set_pre_inertial_force
void set_pre_inertial_force(const Col< T > &)
Definition: Factory.hpp:1646
Factory::modify_trial_time
T & modify_trial_time()
Definition: Factory.hpp:1752
Factory::set_eigenvalue
void set_eigenvalue(const Col< T > &)
Definition: Factory.hpp:962
Factory::clear_acceleration
void clear_acceleration()
Definition: Factory.hpp:1287
Factory::initialize_load
void initialize_load()
Definition: Factory.hpp:848
Factory::set_mpc
void set_mpc(unsigned)
Definition: Factory.hpp:942
Factory::modify_stiffness
shared_ptr< MetaMat< T > > & modify_stiffness()
Definition: Factory.hpp:1530
Factory::modify_trial_inertial_force
Col< T > & modify_trial_inertial_force()
Definition: Factory.hpp:1766
Factory::modify_trial_nonviscous_force
Col< T > & modify_trial_nonviscous_force()
Definition: Factory.hpp:1764
Factory::commit_temperature
void commit_temperature()
Definition: Factory.hpp:1150
Factory::is_sparse
bool is_sparse() const
Definition: Factory.hpp:751
Factory::update_current_nonviscous_force
void update_current_nonviscous_force(const Col< T > &)
Definition: Factory.hpp:1998
Factory::set_incre_velocity
void set_incre_velocity(const Col< T > &)
Definition: Factory.hpp:1602
Factory::get_entry
uword get_entry() const
Definition: Factory.hpp:709
Factory::set_incre_temperature
void set_incre_temperature(const Col< T > &)
Definition: Factory.hpp:1606
Factory::assemble_stiffness
void assemble_stiffness(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition: Factory.hpp:1464
Factory::print
void print() const
Definition: Factory.hpp:1473
Factory::clear_resistance
void clear_resistance()
Definition: Factory.hpp:1245
Factory::initialize_auxiliary_resistance
void initialize_auxiliary_resistance()
Definition: Factory.hpp:908
Factory::clear_load_factor
void clear_load_factor()
Definition: Factory.hpp:1224
Factory::set_incre_acceleration
void set_incre_acceleration(const Col< T > &)
Definition: Factory.hpp:1604
Factory::initialize
int initialize()
Definition: Factory.hpp:785
Factory::modify_incre_load
Col< T > & modify_incre_load()
Definition: Factory.hpp:1780
Factory::get_current_acceleration
const Col< T > & get_current_acceleration() const
Definition: Factory.hpp:1724
Factory::update_incre_damping_force_by
void update_incre_damping_force_by(const Col< T > &)
Definition: Factory.hpp:2113
Factory::get_pre_damping_force
const Col< T > & get_pre_damping_force() const
Definition: Factory.hpp:1738
Factory::reset_displacement
void reset_displacement()
Definition: Factory.hpp:1371
Factory::update_incre_temperature_by
void update_incre_temperature_by(const Col< T > &)
Definition: Factory.hpp:2143
Factory::set_ninja
void set_ninja(const Col< T > &)
Definition: Factory.hpp:936
Factory::modify_trial_damping_force
Col< T > & modify_trial_damping_force()
Definition: Factory.hpp:1762
Factory::update_trial_temperature_by
void update_trial_temperature_by(const Col< T > &)
Definition: Factory.hpp:2083
Factory::is_nlgeom
bool is_nlgeom() const
Definition: Factory.hpp:717
Factory::update_incre_load_factor_by
void update_incre_load_factor_by(const Col< T > &)
Definition: Factory.hpp:2093
Factory::get_eigenvector
const Mat< T > & get_eigenvector() const
Definition: Factory.hpp:1038
Factory::get_trial_velocity
const Col< T > & get_trial_velocity() const
Definition: Factory.hpp:1674
Factory::get_trial_resistance
const Col< T > & get_trial_resistance() const
Definition: Factory.hpp:1664
Factory::update_trial_load_factor_by
void update_trial_load_factor_by(const Col< T > &)
Definition: Factory.hpp:2033
Factory::get_ninja
const Col< T > & get_ninja() const
Definition: Factory.hpp:966
Factory::modify_trial_temperature
Col< T > & modify_trial_temperature()
Definition: Factory.hpp:1774
Factory::set_pre_velocity
void set_pre_velocity(const Col< T > &)
Definition: Factory.hpp:1650
Factory::get_current_load
const Col< T > & get_current_load() const
Definition: Factory.hpp:1708
Factory::set_trial_settlement
void set_trial_settlement(const Col< T > &)
Definition: Factory.hpp:1566
Factory::set_incre_load_factor
void set_incre_load_factor(const Col< T > &)
Definition: Factory.hpp:1586
Factory::set_trial_time
void set_trial_time(T)
Definition: Factory.hpp:1560
Factory::modify_incre_resistance
Col< T > & modify_incre_resistance()
Definition: Factory.hpp:1784
Factory::update_incre_load_by
void update_incre_load_by(const Col< T > &)
Definition: Factory.hpp:2098
Factory::set_solver_type
void set_solver_type(SolverType)
Definition: Factory.hpp:727
Factory::get_pre_load
const Col< T > & get_pre_load() const
Definition: Factory.hpp:1732
Factory::commit_acceleration
void commit_acceleration()
Definition: Factory.hpp:1144
Factory::get_analysis_type
AnalysisType get_analysis_type() const
Definition: Factory.hpp:741
Factory::clear_nonviscous
void clear_nonviscous()
Definition: Factory.hpp:1409
Factory::set_current_resistance
void set_current_resistance(const Col< T > &)
Definition: Factory.hpp:1616
Factory::update_incre_displacement
void update_incre_displacement(const Col< T > &)
Definition: Factory.hpp:1948
Factory::set_incre_displacement
void set_incre_displacement(const Col< T > &)
Definition: Factory.hpp:1600
Factory::update_current_acceleration_by
void update_current_acceleration_by(const Col< T > &)
Definition: Factory.hpp:2198
Factory::get_auxiliary_encoding
const uvec & get_auxiliary_encoding() const
Definition: Factory.hpp:974
Factory::reset_auxiliary_resistance
void reset_auxiliary_resistance()
Definition: Factory.hpp:1395
Factory::modify_pre_displacement
Col< T > & modify_pre_displacement()
Definition: Factory.hpp:1840
Factory::commit_resistance
void commit_resistance()
Definition: Factory.hpp:1108
Factory::get_incre_inertial_force
const Col< T > & get_incre_inertial_force() const
Definition: Factory.hpp:1694
Factory::set_storage_scheme
void set_storage_scheme(StorageScheme)
Definition: Factory.hpp:743
Factory::update_trial_nonviscous_force_by
void update_trial_nonviscous_force_by(const Col< T > &)
Definition: Factory.hpp:2058
Factory::initialize_damping
void initialize_damping()
Definition: Factory.hpp:915
Factory::update_incre_velocity
void update_incre_velocity(const Col< T > &)
Definition: Factory.hpp:1953
Factory::modify_incre_acceleration
Col< T > & modify_incre_acceleration()
Definition: Factory.hpp:1796
Factory::initialize_geometry
void initialize_geometry()
Definition: Factory.hpp:925
Factory::update_incre_displacement_by
void update_incre_displacement_by(const Col< T > &)
Definition: Factory.hpp:2128
Factory::update_current_damping_force_by
void update_current_damping_force_by(const Col< T > &)
Definition: Factory.hpp:2173
Factory::assemble_mass
void assemble_mass(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition: Factory.hpp:1458
Factory::set_trial_velocity
void set_trial_velocity(const Col< T > &)
Definition: Factory.hpp:1578
Factory::update_current_resistance
void update_current_resistance(const Col< T > &)
Definition: Factory.hpp:1988
Factory::clear_inertial_force
void clear_inertial_force()
Definition: Factory.hpp:1266
Factory::modify_ninja
Col< T > & modify_ninja()
Definition: Factory.hpp:1534
Factory::set_pre_nonviscous_force
void set_pre_nonviscous_force(const Col< T > &)
Definition: Factory.hpp:1644
Factory::update_trial_damping_force_by
void update_trial_damping_force_by(const Col< T > &)
Definition: Factory.hpp:2053
Factory::get_mpc
unsigned get_mpc() const
Definition: Factory.hpp:970
Factory::modify_eigenvalue
Col< T > & modify_eigenvalue()
Definition: Factory.hpp:1556
Factory::get_current_settlement
const Col< T > & get_current_settlement() const
Definition: Factory.hpp:1710
Factory::get_solver_setting
const SolverSetting< double > & get_solver_setting() const
Definition: Factory.hpp:733
Factory::commit_load_factor
void commit_load_factor()
Definition: Factory.hpp:1090
Factory::get_damping_mutex
std::mutex & get_damping_mutex()
Definition: Factory.hpp:1028
Factory::update_trial_velocity_by
void update_trial_velocity_by(const Col< T > &)
Definition: Factory.hpp:2073
Factory::update_current_load_by
void update_current_load_by(const Col< T > &)
Definition: Factory.hpp:2158
Factory::modify_trial_constraint_resistance
SpCol< T > & modify_trial_constraint_resistance()
Definition: Factory.hpp:1552
Factory::get_damping
const shared_ptr< MetaMat< T > > & get_damping() const
Definition: Factory.hpp:1002
Factory::set_pre_settlement
void set_pre_settlement(const Col< T > &)
Definition: Factory.hpp:1638
Factory::set_nlgeom
void set_nlgeom(bool)
Definition: Factory.hpp:711
Factory::get_storage_scheme
StorageScheme get_storage_scheme() const
Definition: Factory.hpp:749
Factory::commit_inertial_force
void commit_inertial_force()
Definition: Factory.hpp:1126
Factory::update_current_time
void update_current_time(T)
Definition: Factory.hpp:1968
Factory::initialize_resistance
void initialize_resistance()
Definition: Factory.hpp:860
Factory::get_current_damping_force
const Col< T > & get_current_damping_force() const
Definition: Factory.hpp:1714
Factory::set_solver_setting
void set_solver_setting(const SolverSetting< double > &)
Definition: Factory.hpp:731
Factory::update_trial_displacement_by
void update_trial_displacement_by(const Col< T > &)
Definition: Factory.hpp:2068
Factory::reset_velocity
void reset_velocity()
Definition: Factory.hpp:1377
Factory::get_nonviscous
const shared_ptr< MetaMat< T > > & get_nonviscous() const
Definition: Factory.hpp:1004
Factory::get_trial_load_factor
const Col< T > & get_trial_load_factor() const
Definition: Factory.hpp:1658
Factory::set_current_load
void set_current_load(const Col< T > &)
Definition: Factory.hpp:1612
Factory::get_trial_load_mutex
std::mutex & get_trial_load_mutex()
Definition: Factory.hpp:1020
Factory::initialize_stiffness
void initialize_stiffness()
Definition: Factory.hpp:923
Factory::initialize_damping_force
void initialize_damping_force()
Definition: Factory.hpp:866
Factory::get_current_time
T get_current_time() const
Definition: Factory.hpp:1704
Factory::get_pre_settlement
const Col< T > & get_pre_settlement() const
Definition: Factory.hpp:1734
Factory::update_trial_temperature
void update_trial_temperature(const Col< T > &)
Definition: Factory.hpp:1903
Factory::commit_velocity
void commit_velocity()
Definition: Factory.hpp:1138
Factory::set_pre_time
void set_pre_time(T)
Definition: Factory.hpp:1632
Factory::get_complementary_energy
T get_complementary_energy()
Definition: Factory.hpp:996
Factory::reset
void reset()
Definition: Factory.hpp:1423
Factory::get_incre_displacement
const Col< T > & get_incre_displacement() const
Definition: Factory.hpp:1696
Factory::set_current_damping_force
void set_current_damping_force(const Col< T > &)
Definition: Factory.hpp:1618
Factory::modify_current_nonviscous_force
Col< T > & modify_current_nonviscous_force()
Definition: Factory.hpp:1812
Factory::update_trial_acceleration
void update_trial_acceleration(const Col< T > &)
Definition: Factory.hpp:1898
Factory::set_current_time
void set_current_time(T)
Definition: Factory.hpp:1608
Factory::get_auxiliary_load
const Col< T > & get_auxiliary_load() const
Definition: Factory.hpp:980
Factory::commit_pre_settlement
void commit_pre_settlement()
Definition: Factory.hpp:1182
Factory::modify_pre_settlement
Col< T > & modify_pre_settlement()
Definition: Factory.hpp:1830
Factory::get_mass
const shared_ptr< MetaMat< T > > & get_mass() const
Definition: Factory.hpp:1000
Factory::commit_status
void commit_status()
Definition: Factory.hpp:1065
Factory::commit_pre_load_factor
void commit_pre_load_factor()
Definition: Factory.hpp:1178
Factory::get_reference_dof
const suanpan::set< uword > & get_reference_dof() const
Definition: Factory.hpp:779
Factory::set_incre_time
void set_incre_time(T)
Definition: Factory.hpp:1584
Factory::modify_damping
shared_ptr< MetaMat< T > > & modify_damping()
Definition: Factory.hpp:1526
Factory::modify_pre_velocity
Col< T > & modify_pre_velocity()
Definition: Factory.hpp:1842
Factory::get_reference_load_mutex
std::mutex & get_reference_load_mutex()
Definition: Factory.hpp:1024
Factory::assemble_damping
void assemble_damping(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition: Factory.hpp:1460
Factory::update_incre_nonviscous_force
void update_incre_nonviscous_force(const Col< T > &)
Definition: Factory.hpp:1938
Factory::update_trial_inertial_force
void update_trial_inertial_force(const Col< T > &)
Definition: Factory.hpp:1883
Factory::set_current_velocity
void set_current_velocity(const Col< T > &)
Definition: Factory.hpp:1626
Factory::commit_displacement
void commit_displacement()
Definition: Factory.hpp:1132
Factory::update_current_velocity_by
void update_current_velocity_by(const Col< T > &)
Definition: Factory.hpp:2193
Factory::get_incre_damping_force
const Col< T > & get_incre_damping_force() const
Definition: Factory.hpp:1690
Factory::update_trial_load_factor
void update_trial_load_factor(const Col< T > &)
Definition: Factory.hpp:1853
Factory::reset_load_factor
void reset_load_factor()
Definition: Factory.hpp:1329
Factory::clear_velocity
void clear_velocity()
Definition: Factory.hpp:1280
Factory::update_current_load
void update_current_load(const Col< T > &)
Definition: Factory.hpp:1978
Factory::update_incre_time
void update_incre_time(T)
Definition: Factory.hpp:1908
Factory::update_incre_settlement_by
void update_incre_settlement_by(const Col< T > &)
Definition: Factory.hpp:2103
Factory::get_reference_size
unsigned get_reference_size() const
Definition: Factory.hpp:773
Factory::update_current_acceleration
void update_current_acceleration(const Col< T > &)
Definition: Factory.hpp:2018
StorageScheme
StorageScheme
Definition: Factory.hpp:52
Factory::commit_pre_temperature
void commit_pre_temperature()
Definition: Factory.hpp:1198
Factory::commit_pre_status
void commit_pre_status()
Definition: Factory.hpp:1161
Factory::update_current_time_by
void update_current_time_by(T)
Definition: Factory.hpp:2148
Factory::modify_reference_dof
suanpan::set< uword > & modify_reference_dof()
Definition: Factory.hpp:1538
Factory::set_trial_acceleration
void set_trial_acceleration(const Col< T > &)
Definition: Factory.hpp:1580
Factory::update_trial_damping_force
void update_trial_damping_force(const Col< T > &)
Definition: Factory.hpp:1873
Factory::get_incre_settlement
const Col< T > & get_incre_settlement() const
Definition: Factory.hpp:1686
Factory::reset_inertial_force
void reset_inertial_force()
Definition: Factory.hpp:1365
Factory::set_reference_dof
void set_reference_dof(const suanpan::set< uword > &)
Definition: Factory.hpp:777
Factory::get_momentum
const Col< T > & get_momentum()
Definition: Factory.hpp:998
Factory::update_current_displacement
void update_current_displacement(const Col< T > &)
Definition: Factory.hpp:2008
Factory::clear_settlement
void clear_settlement()
Definition: Factory.hpp:1238
Factory::set_pre_load
void set_pre_load(const Col< T > &)
Definition: Factory.hpp:1636
Factory::get_auxiliary_stiffness_mutex
std::mutex & get_auxiliary_stiffness_mutex()
Definition: Factory.hpp:1016
Factory::get_incre_time
T get_incre_time() const
Definition: Factory.hpp:1680
Factory::commit_pre_damping_force
void commit_pre_damping_force()
Definition: Factory.hpp:1186
Factory::modify_current_inertial_force
Col< T > & modify_current_inertial_force()
Definition: Factory.hpp:1814
Factory::get_current_nonviscous_force
const Col< T > & get_current_nonviscous_force() const
Definition: Factory.hpp:1716
Factory::get_strain_energy
T get_strain_energy()
Definition: Factory.hpp:988
Factory::commit_pre_inertial_force
void commit_pre_inertial_force()
Definition: Factory.hpp:1190
Factory::update_trial_settlement
void update_trial_settlement(const Col< T > &)
Definition: Factory.hpp:1863
Factory::set_trial_inertial_force
void set_trial_inertial_force(const Col< T > &)
Definition: Factory.hpp:1574
Factory::get_eigenvalue
const Col< T > & get_eigenvalue() const
Definition: Factory.hpp:1036
Factory::commit_pre_displacement
void commit_pre_displacement()
Definition: Factory.hpp:1192
Factory::get_geometry_mutex
std::mutex & get_geometry_mutex()
Definition: Factory.hpp:1034
Factory::set_incre_nonviscous_force
void set_incre_nonviscous_force(const Col< T > &)
Definition: Factory.hpp:1596
Factory::commit_pre_acceleration
void commit_pre_acceleration()
Definition: Factory.hpp:1196
Factory::get_incre_velocity
const Col< T > & get_incre_velocity() const
Definition: Factory.hpp:1698
Factory::modify_current_settlement
Col< T > & modify_current_settlement()
Definition: Factory.hpp:1806
Factory::get_trial_time
T get_trial_time() const
Definition: Factory.hpp:1656
Factory::update_current_temperature_by
void update_current_temperature_by(const Col< T > &)
Definition: Factory.hpp:2203
Factory::set_incre_load
void set_incre_load(const Col< T > &)
Definition: Factory.hpp:1588
Factory::update_reference_size
void update_reference_size()
Definition: Factory.hpp:766
Factory::set_pre_acceleration
void set_pre_acceleration(const Col< T > &)
Definition: Factory.hpp:1652
Factory::set_incre_inertial_force
void set_incre_inertial_force(const Col< T > &)
Definition: Factory.hpp:1598
Factory::get_trial_nonviscous_force
const Col< T > & get_trial_nonviscous_force() const
Definition: Factory.hpp:1668
Factory::get_kinetic_energy
T get_kinetic_energy()
Definition: Factory.hpp:990
Factory::set_current_settlement
void set_current_settlement(const Col< T > &)
Definition: Factory.hpp:1614
Factory::update_trial_settlement_by
void update_trial_settlement_by(const Col< T > &)
Definition: Factory.hpp:2043
Factory::initialize_inertial_force
void initialize_inertial_force()
Definition: Factory.hpp:878
Factory::set_pre_resistance
void set_pre_resistance(const Col< T > &)
Definition: Factory.hpp:1640
Factory::commit_load
void commit_load()
Definition: Factory.hpp:1096
Factory::update_current_nonviscous_force_by
void update_current_nonviscous_force_by(const Col< T > &)
Definition: Factory.hpp:2178
Factory::update_trial_acceleration_by
void update_trial_acceleration_by(const Col< T > &)
Definition: Factory.hpp:2078
Factory::get_pre_acceleration
const Col< T > & get_pre_acceleration() const
Definition: Factory.hpp:1748
Factory::update_incre_acceleration_by
void update_incre_acceleration_by(const Col< T > &)
Definition: Factory.hpp:2138
Factory::commit_pre_nonviscous_force
void commit_pre_nonviscous_force()
Definition: Factory.hpp:1188
Factory::commit_pre_load
void commit_pre_load()
Definition: Factory.hpp:1180
Factory::commit_pre_velocity
void commit_pre_velocity()
Definition: Factory.hpp:1194
Factory::update_trial_resistance_by
void update_trial_resistance_by(const Col< T > &)
Definition: Factory.hpp:2048
Factory::modify_current_resistance
Col< T > & modify_current_resistance()
Definition: Factory.hpp:1808
AnalysisType
AnalysisType
Definition: Factory.hpp:43
Factory::is_nonviscous
bool is_nonviscous() const
Definition: Factory.hpp:725
Factory::commit_pre_time
void commit_pre_time()
Definition: Factory.hpp:1176
Factory::modify_geometry
shared_ptr< MetaMat< T > > & modify_geometry()
Definition: Factory.hpp:1532
Factory::commit_auxiliary_resistance
void commit_auxiliary_resistance()
Definition: Factory.hpp:1156
Factory::update_current_settlement
void update_current_settlement(const Col< T > &)
Definition: Factory.hpp:1983
Factory::set_stiffness
void set_stiffness(const shared_ptr< MetaMat< T >> &)
Definition: Factory.hpp:958
Factory::update_trial_load
void update_trial_load(const Col< T > &)
Definition: Factory.hpp:1858
Factory::modify_pre_nonviscous_force
Col< T > & modify_pre_nonviscous_force()
Definition: Factory.hpp:1836
Factory::update_incre_load
void update_incre_load(const Col< T > &)
Definition: Factory.hpp:1918
Factory::update_trial_time
void update_trial_time(T)
Definition: Factory.hpp:1848
Factory::clear_nonviscous_force
void clear_nonviscous_force()
Definition: Factory.hpp:1259
Factory::get_stiffness
const shared_ptr< MetaMat< T > > & get_stiffness() const
Definition: Factory.hpp:1006
Factory::commit_settlement
void commit_settlement()
Definition: Factory.hpp:1102
Factory::set_trial_nonviscous_force
void set_trial_nonviscous_force(const Col< T > &)
Definition: Factory.hpp:1572
Factory::get_auxiliary_lambda
const Col< T > & get_auxiliary_lambda() const
Definition: Factory.hpp:976
Factory::reset_load
void reset_load()
Definition: Factory.hpp:1335
Factory::reset_damping_force
void reset_damping_force()
Definition: Factory.hpp:1353
Factory::update_current_inertial_force_by
void update_current_inertial_force_by(const Col< T > &)
Definition: Factory.hpp:2183
Factory::set_trial_temperature
void set_trial_temperature(const Col< T > &)
Definition: Factory.hpp:1582
Factory::get_auxiliary_encoding_mutex
std::mutex & get_auxiliary_encoding_mutex()
Definition: Factory.hpp:1010
Factory::modify_trial_load
Col< T > & modify_trial_load()
Definition: Factory.hpp:1756
SolverType
SolverType
Definition: Factory.hpp:61
Factory::assemble_damping_force
void assemble_damping_force(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1436
Factory::set_current_nonviscous_force
void set_current_nonviscous_force(const Col< T > &)
Definition: Factory.hpp:1620
Factory::get_pre_displacement
const Col< T > & get_pre_displacement() const
Definition: Factory.hpp:1744
Factory::get_current_inertial_force
const Col< T > & get_current_inertial_force() const
Definition: Factory.hpp:1718
Factory::get_mass_mutex
std::mutex & get_mass_mutex()
Definition: Factory.hpp:1026
Factory::set_nonviscous
void set_nonviscous(bool)
Definition: Factory.hpp:719
Factory::get_pre_load_factor
const Col< T > & get_pre_load_factor() const
Definition: Factory.hpp:1730
Factory::modify_current_acceleration
Col< T > & modify_current_acceleration()
Definition: Factory.hpp:1820
Factory::get_trial_displacement
const Col< T > & get_trial_displacement() const
Definition: Factory.hpp:1672
Factory::update_trial_velocity
void update_trial_velocity(const Col< T > &)
Definition: Factory.hpp:1893
Factory::update_current_temperature
void update_current_temperature(const Col< T > &)
Definition: Factory.hpp:2023
Factory::reset_temperature
void reset_temperature()
Definition: Factory.hpp:1389
Factory::get_auxiliary_resistance_mutex
std::mutex & get_auxiliary_resistance_mutex()
Definition: Factory.hpp:1012
Factory::set_current_acceleration
void set_current_acceleration(const Col< T > &)
Definition: Factory.hpp:1628
Factory::get_nonviscous_energy
T get_nonviscous_energy()
Definition: Factory.hpp:994
Factory::update_current_settlement_by
void update_current_settlement_by(const Col< T > &)
Definition: Factory.hpp:2163
Factory::initialize_settlement
void initialize_settlement()
Definition: Factory.hpp:854
Factory::clear_damping
void clear_damping()
Definition: Factory.hpp:1407
Factory::get_incre_nonviscous_force
const Col< T > & get_incre_nonviscous_force() const
Definition: Factory.hpp:1692
Factory::get_incre_load_factor
const Col< T > & get_incre_load_factor() const
Definition: Factory.hpp:1682
Factory::clear_energy
void clear_energy()
Definition: Factory.hpp:1056
Factory::get_reference_load
const SpMat< T > & get_reference_load() const
Definition: Factory.hpp:972
Factory::initialize_displacement
void initialize_displacement()
Definition: Factory.hpp:884
Factory::modify_auxiliary_load
Col< T > & modify_auxiliary_load()
Definition: Factory.hpp:1548
Factory::reset_time
void reset_time()
Definition: Factory.hpp:1324
Factory::get_current_displacement
const Col< T > & get_current_displacement() const
Definition: Factory.hpp:1720
Factory::modify_current_velocity
Col< T > & modify_current_velocity()
Definition: Factory.hpp:1818
Factory::get_size
unsigned get_size() const
Definition: Factory.hpp:702
Factory::modify_current_time
T & modify_current_time()
Definition: Factory.hpp:1800
Factory::reset_settlement
void reset_settlement()
Definition: Factory.hpp:1341
Factory::clear_damping_force
void clear_damping_force()
Definition: Factory.hpp:1252
Factory::set_analysis_type
void set_analysis_type(AnalysisType)
Definition: Factory.hpp:735
Factory::get_incre_load
const Col< T > & get_incre_load() const
Definition: Factory.hpp:1684
Factory::initialize_nonviscous_force
void initialize_nonviscous_force()
Definition: Factory.hpp:872
Factory::set_entry
void set_entry(uword)
Definition: Factory.hpp:704
Factory::modify_pre_damping_force
Col< T > & modify_pre_damping_force()
Definition: Factory.hpp:1834
Factory::get_incre_acceleration
const Col< T > & get_incre_acceleration() const
Definition: Factory.hpp:1700
Factory::get_pre_time
T get_pre_time() const
Definition: Factory.hpp:1728
Factory::clear_geometry
void clear_geometry()
Definition: Factory.hpp:1413
Factory::get_viscous_energy
T get_viscous_energy()
Definition: Factory.hpp:992
Factory::get_trial_constraint_resistance_mutex
std::mutex & get_trial_constraint_resistance_mutex()
Definition: Factory.hpp:1018
Factory::get_current_temperature
const Col< T > & get_current_temperature() const
Definition: Factory.hpp:1726
Factory::update_incre_time_by
void update_incre_time_by(T)
Definition: Factory.hpp:2088
Factory::assemble_nonviscous
void assemble_nonviscous(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition: Factory.hpp:1462
Factory::set_reference_size
void set_reference_size(unsigned)
Definition: Factory.hpp:768
Factory::modify_trial_settlement
Col< T > & modify_trial_settlement()
Definition: Factory.hpp:1758
Factory::initialize_temperature
void initialize_temperature()
Definition: Factory.hpp:902
Factory::set_current_displacement
void set_current_displacement(const Col< T > &)
Definition: Factory.hpp:1624
Factory::update_reference_dof
void update_reference_dof(const uvec &)
Definition: Factory.hpp:775
Factory::get_trial_inertial_force
const Col< T > & get_trial_inertial_force() const
Definition: Factory.hpp:1670
Factory::set_current_inertial_force
void set_current_inertial_force(const Col< T > &)
Definition: Factory.hpp:1622
Factory::modify_current_constraint_resistance
SpCol< T > & modify_current_constraint_resistance()
Definition: Factory.hpp:1554
Factory::modify_incre_load_factor
Col< T > & modify_incre_load_factor()
Definition: Factory.hpp:1778
Factory::set_trial_load
void set_trial_load(const Col< T > &)
Definition: Factory.hpp:1564
Factory::modify_auxiliary_resistance
Col< T > & modify_auxiliary_resistance()
Definition: Factory.hpp:1546
Factory::modify_pre_resistance
Col< T > & modify_pre_resistance()
Definition: Factory.hpp:1832
Factory::modify_incre_temperature
Col< T > & modify_incre_temperature()
Definition: Factory.hpp:1798
Factory::modify_pre_time
T & modify_pre_time()
Definition: Factory.hpp:1824
Factory::update_incre_temperature
void update_incre_temperature(const Col< T > &)
Definition: Factory.hpp:1963
Factory::modify_nonviscous
shared_ptr< MetaMat< T > > & modify_nonviscous()
Definition: Factory.hpp:1528
Factory::update_current_velocity
void update_current_velocity(const Col< T > &)
Definition: Factory.hpp:2013
Factory::set_error
void set_error(T)
Definition: Factory.hpp:781
Factory::modify_incre_nonviscous_force
Col< T > & modify_incre_nonviscous_force()
Definition: Factory.hpp:1788
Factory::assemble_geometry
void assemble_geometry(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition: Factory.hpp:1466
Factory::get_trial_settlement
const Col< T > & get_trial_settlement() const
Definition: Factory.hpp:1662
Factory::set_eigenvector
void set_eigenvector(const Mat< T > &)
Definition: Factory.hpp:964
Factory::initialize_load_factor
void initialize_load_factor()
Definition: Factory.hpp:838
Factory::modify_incre_inertial_force
Col< T > & modify_incre_inertial_force()
Definition: Factory.hpp:1790
Factory::get_trial_load
const Col< T > & get_trial_load() const
Definition: Factory.hpp:1660
Factory::modify_auxiliary_encoding
uvec & modify_auxiliary_encoding()
Definition: Factory.hpp:1542
Factory::update_current_displacement_by
void update_current_displacement_by(const Col< T > &)
Definition: Factory.hpp:2188
Factory::set_trial_resistance
void set_trial_resistance(const Col< T > &)
Definition: Factory.hpp:1568
Factory::commit_nonviscous_force
void commit_nonviscous_force()
Definition: Factory.hpp:1120
Factory::set_pre_load_factor
void set_pre_load_factor(const Col< T > &)
Definition: Factory.hpp:1634
Factory::update_current_damping_force
void update_current_damping_force(const Col< T > &)
Definition: Factory.hpp:1993
Factory::modify_current_damping_force
Col< T > & modify_current_damping_force()
Definition: Factory.hpp:1810
Factory::update_current_load_factor
void update_current_load_factor(const Col< T > &)
Definition: Factory.hpp:1973
Factory::commit_energy
void commit_energy()
Definition: Factory.hpp:1040
Factory::commit_damping_force
void commit_damping_force()
Definition: Factory.hpp:1114
Factory::get_error
T get_error() const
Definition: Factory.hpp:783
Factory::update_trial_time_by
void update_trial_time_by(T)
Definition: Factory.hpp:2028
Factory::update_incre_acceleration
void update_incre_acceleration(const Col< T > &)
Definition: Factory.hpp:1958
Factory::get_auxiliary_stiffness
const SpMat< T > & get_auxiliary_stiffness() const
Definition: Factory.hpp:982
Factory::assemble_inertial_force
void assemble_inertial_force(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1446
Factory::clear_status
void clear_status()
Definition: Factory.hpp:1200
Factory::set_bandwidth
void set_bandwidth(unsigned, unsigned)
Definition: Factory.hpp:753
Factory::update_incre_velocity_by
void update_incre_velocity_by(const Col< T > &)
Definition: Factory.hpp:2133
Factory::get_current_load_factor
const Col< T > & get_current_load_factor() const
Definition: Factory.hpp:1706
Factory::commit_time
void commit_time()
Definition: Factory.hpp:1085
Factory::clear_mass
void clear_mass()
Definition: Factory.hpp:1405
Factory::get_bandwidth
void get_bandwidth(unsigned &, unsigned &) const
Definition: Factory.hpp:761
Factory::get_pre_inertial_force
const Col< T > & get_pre_inertial_force() const
Definition: Factory.hpp:1742
Factory::commit_pre_resistance
void commit_pre_resistance()
Definition: Factory.hpp:1184
Factory::update_trial_nonviscous_force
void update_trial_nonviscous_force(const Col< T > &)
Definition: Factory.hpp:1878
Factory::reset_resistance
void reset_resistance()
Definition: Factory.hpp:1347
Factory::get_solver_type
SolverType get_solver_type() const
Definition: Factory.hpp:729
Factory::modify_pre_temperature
Col< T > & modify_pre_temperature()
Definition: Factory.hpp:1846
Factory::get_auxiliary_load_mutex
std::mutex & get_auxiliary_load_mutex()
Definition: Factory.hpp:1014
Factory::get_trial_acceleration
const Col< T > & get_trial_acceleration() const
Definition: Factory.hpp:1676
Factory::assemble_resistance
void assemble_resistance(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1431
Factory::set_incre_damping_force
void set_incre_damping_force(const Col< T > &)
Definition: Factory.hpp:1594
Factory::modify_incre_displacement
Col< T > & modify_incre_displacement()
Definition: Factory.hpp:1792
Factory::modify_pre_load
Col< T > & modify_pre_load()
Definition: Factory.hpp:1828
Factory::get_trial_constraint_resistance
const SpCol< T > & get_trial_constraint_resistance() const
Definition: Factory.hpp:984
Factory::update_incre_damping_force
void update_incre_damping_force(const Col< T > &)
Definition: Factory.hpp:1933
Factory::get_pre_velocity
const Col< T > & get_pre_velocity() const
Definition: Factory.hpp:1746
Factory::get_current_resistance
const Col< T > & get_current_resistance() const
Definition: Factory.hpp:1712
Factory::assemble_nonviscous_force
void assemble_nonviscous_force(const Mat< T > &, const uvec &)
Definition: Factory.hpp:1441
Factory::initialize_velocity
void initialize_velocity()
Definition: Factory.hpp:890
Factory::get_stiffness_mutex
std::mutex & get_stiffness_mutex()
Definition: Factory.hpp:1032
Factory::modify_pre_acceleration
Col< T > & modify_pre_acceleration()
Definition: Factory.hpp:1844
Factory::update_incre_inertial_force_by
void update_incre_inertial_force_by(const Col< T > &)
Definition: Factory.hpp:2123
Factory::get_current_velocity
const Col< T > & get_current_velocity() const
Definition: Factory.hpp:1722
Factory::update_incre_load_factor
void update_incre_load_factor(const Col< T > &)
Definition: Factory.hpp:1913
Factory::modify_auxiliary_stiffness
SpMat< T > & modify_auxiliary_stiffness()
Definition: Factory.hpp:1550
Factory::set_incre_resistance
void set_incre_resistance(const Col< T > &)
Definition: Factory.hpp:1592
Factory::initialize_nonviscous
void initialize_nonviscous()
Definition: Factory.hpp:917
Factory::modify_trial_velocity
Col< T > & modify_trial_velocity()
Definition: Factory.hpp:1770
Factory::modify_trial_displacement
Col< T > & modify_trial_displacement()
Definition: Factory.hpp:1768
Factory::get_pre_temperature
const Col< T > & get_pre_temperature() const
Definition: Factory.hpp:1750
Factory::modify_trial_acceleration
Col< T > & modify_trial_acceleration()
Definition: Factory.hpp:1772
Factory::clear_load
void clear_load()
Definition: Factory.hpp:1231
Factory::get_incre_temperature
const Col< T > & get_incre_temperature() const
Definition: Factory.hpp:1702
Factory::modify_pre_load_factor
Col< T > & modify_pre_load_factor()
Definition: Factory.hpp:1826
Factory::Factory
Factory(unsigned=0, AnalysisType=AnalysisType::NONE, StorageScheme=StorageScheme::FULL)
Definition: Factory.hpp:691
Factory::modify_trial_load_factor
Col< T > & modify_trial_load_factor()
Definition: Factory.hpp:1754
Factory::set_size
void set_size(unsigned)
Definition: Factory.hpp:696
Factory::update_trial_displacement
void update_trial_displacement(const Col< T > &)
Definition: Factory.hpp:1888
Factory::get_incre_resistance
const Col< T > & get_incre_resistance() const
Definition: Factory.hpp:1688
Factory::modify_trial_resistance
Col< T > & modify_trial_resistance()
Definition: Factory.hpp:1760
Factory::get_sushi
const Col< T > & get_sushi() const
Definition: Factory.hpp:968
Factory::get_auxiliary_resistance
const Col< T > & get_auxiliary_resistance() const
Definition: Factory.hpp:978
Factory::get_trial_damping_force
const Col< T > & get_trial_damping_force() const
Definition: Factory.hpp:1666
Factory::modify_eigenvector
Mat< T > & modify_eigenvector()
Definition: Factory.hpp:1558
Factory::update_current_resistance_by
void update_current_resistance_by(const Col< T > &)
Definition: Factory.hpp:2168
Factory::set_damping
void set_damping(const shared_ptr< MetaMat< T >> &)
Definition: Factory.hpp:954
Factory::set_pre_temperature
void set_pre_temperature(const Col< T > &)
Definition: Factory.hpp:1654
Factory::update_trial_load_by
void update_trial_load_by(const Col< T > &)
Definition: Factory.hpp:2038
Factory::modify_auxiliary_lambda
Col< T > & modify_auxiliary_lambda()
Definition: Factory.hpp:1544
Factory::get_current_constraint_resistance
const SpCol< T > & get_current_constraint_resistance() const
Definition: Factory.hpp:986
Factory::clear_auxiliary_resistance
void clear_auxiliary_resistance()
Definition: Factory.hpp:1301
Factory::get_pre_nonviscous_force
const Col< T > & get_pre_nonviscous_force() const
Definition: Factory.hpp:1740
Factory::update_incre_resistance_by
void update_incre_resistance_by(const Col< T > &)
Definition: Factory.hpp:2108
Factory::update_sushi_by
void update_sushi_by(const Col< T > &)
Definition: Factory.hpp:940
Factory::set_incre_settlement
void set_incre_settlement(const Col< T > &)
Definition: Factory.hpp:1590
Factory::modify_pre_inertial_force
Col< T > & modify_pre_inertial_force()
Definition: Factory.hpp:1838
Factory::set_sushi
void set_sushi(const Col< T > &)
Definition: Factory.hpp:938
Factory::modify_mass
shared_ptr< MetaMat< T > > & modify_mass()
Definition: Factory.hpp:1524
Factory::update_incre_settlement
void update_incre_settlement(const Col< T > &)
Definition: Factory.hpp:1923
Factory::set_pre_displacement
void set_pre_displacement(const Col< T > &)
Definition: Factory.hpp:1648
Factory::get_nonviscous_mutex
std::mutex & get_nonviscous_mutex()
Definition: Factory.hpp:1030
Factory::set_current_load_factor
void set_current_load_factor(const Col< T > &)
Definition: Factory.hpp:1610
Factory::set_trial_displacement
void set_trial_displacement(const Col< T > &)
Definition: Factory.hpp:1576
Factory::update_trial_resistance
void update_trial_resistance(const Col< T > &)
Definition: Factory.hpp:1868
Factory::modify_current_load_factor
Col< T > & modify_current_load_factor()
Definition: Factory.hpp:1802
Factory::clear_eigen
void clear_eigen()
Definition: Factory.hpp:1400
Factory::clear_auxiliary
void clear_auxiliary()
Definition: Factory.hpp:1415
Factory::set_geometry
void set_geometry(const shared_ptr< MetaMat< T >> &)
Definition: Factory.hpp:960
Factory::set_reference_load
void set_reference_load(const SpMat< T > &)
Definition: Factory.hpp:950
Factory::modify_incre_time
T & modify_incre_time()
Definition: Factory.hpp:1776
Factory::update_incre_resistance
void update_incre_resistance(const Col< T > &)
Definition: Factory.hpp:1928
Factory::modify_reference_load
SpMat< T > & modify_reference_load()
Definition: Factory.hpp:1540
Factory::modify_incre_damping_force
Col< T > & modify_incre_damping_force()
Definition: Factory.hpp:1786
Factory::modify_incre_settlement
Col< T > & modify_incre_settlement()
Definition: Factory.hpp:1782
Factory::update_current_load_factor_by
void update_current_load_factor_by(const Col< T > &)
Definition: Factory.hpp:2153
Factory::set_trial_load_factor
void set_trial_load_factor(const Col< T > &)
Definition: Factory.hpp:1562
Factory::initialize_eigen
void initialize_eigen()
Definition: Factory.hpp:931
Factory::update_incre_inertial_force
void update_incre_inertial_force(const Col< T > &)
Definition: Factory.hpp:1943
Factory::clear_time
void clear_time()
Definition: Factory.hpp:1222
Factory::clear_displacement
void clear_displacement()
Definition: Factory.hpp:1273
Factory::set_mass
void set_mass(const shared_ptr< MetaMat< T >> &)
Definition: Factory.hpp:952
Factory::get_geometry
const shared_ptr< MetaMat< T > > & get_geometry() const
Definition: Factory.hpp:1008
Factory::modify_current_load
Col< T > & modify_current_load()
Definition: Factory.hpp:1804
Factory::reset_status
void reset_status()
Definition: Factory.hpp:1306
Factory::modify_current_temperature
Col< T > & modify_current_temperature()
Definition: Factory.hpp:1822
Factory::update_current_inertial_force
void update_current_inertial_force(const Col< T > &)
Definition: Factory.hpp:2003
Factory::get_trial_temperature
const Col< T > & get_trial_temperature() const
Definition: Factory.hpp:1678
Factory::set_trial_damping_force
void set_trial_damping_force(const Col< T > &)
Definition: Factory.hpp:1570
Factory::get_trial_settlement_mutex
std::mutex & get_trial_settlement_mutex()
Definition: Factory.hpp:1022
Factory::initialize_mass
void initialize_mass()
Definition: Factory.hpp:913
Factory::modify_sushi
Col< T > & modify_sushi()
Definition: Factory.hpp:1536
Factory::set_pre_damping_force
void set_pre_damping_force(const Col< T > &)
Definition: Factory.hpp:1642
Factory::clear_temperature
void clear_temperature()
Definition: Factory.hpp:1294
Factory::modify_current_displacement
Col< T > & modify_current_displacement()
Definition: Factory.hpp:1816
Factory::initialize_acceleration
void initialize_acceleration()
Definition: Factory.hpp:896
Factory::update_trial_inertial_force_by
void update_trial_inertial_force_by(const Col< T > &)
Definition: Factory.hpp:2063
Factory::set_current_temperature
void set_current_temperature(const Col< T > &)
Definition: Factory.hpp:1630
Factory::modify_incre_velocity
Col< T > & modify_incre_velocity()
Definition: Factory.hpp:1794
Factory::reset_acceleration
void reset_acceleration()
Definition: Factory.hpp:1383
Factory::reset_nonviscous_force
void reset_nonviscous_force()
Definition: Factory.hpp:1359
Factory::get_pre_resistance
const Col< T > & get_pre_resistance() const
Definition: Factory.hpp:1736
Factory::clear_stiffness
void clear_stiffness()
Definition: Factory.hpp:1411
Factory::update_incre_nonviscous_force_by
void update_incre_nonviscous_force_by(const Col< T > &)
Definition: Factory.hpp:2118
StorageScheme::SPARSE
@ SPARSE
StorageScheme::SPARSESYMM
@ SPARSESYMM
StorageScheme::BAND
@ BAND
StorageScheme::FULL
@ FULL
StorageScheme::BANDSYMM
@ BANDSYMM
StorageScheme::SYMMPACK
@ SYMMPACK
AnalysisType::DYNAMICS
@ DYNAMICS
AnalysisType::BUCKLE
@ BUCKLE
AnalysisType::DISP
@ DISP
AnalysisType::STATICS
@ STATICS
AnalysisType::NONE
@ NONE
AnalysisType::EIGEN
@ EIGEN
SolverType::PARDISO
@ PARDISO
SolverType::FGMRES
@ FGMRES
SolverType::MAGMA
@ MAGMA
SolverType::SPIKE
@ SPIKE
SolverType::LIS
@ LIS
SolverType::MUMPS
@ MUMPS
SolverType::LAPACK
@ LAPACK
SolverType::CUDA
@ CUDA
SolverType::SUPERLU
@ SUPERLU
suanpan::error
void error(const std::string_view file_name, const int line, const std::string_view format_str, const T &... args)
Definition: suanPan.h:234
suanpan::set
std::set< T > set
Definition: container.h:54
suanpan_info
#define suanpan_info
Definition: suanPan.h:305