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