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