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 <future>
35#include <Toolbox/container.h>
36#include <Element/MappingDOF.h>
37#include <Domain/MetaMat/MetaMat>
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_mpc = 0; // multipoint 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 = T(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 = T(0); // global trial (pseudo) time
106 T incre_time = T(0); // global incremental (pseudo) time
107 T current_time = T(0); // global current (pseudo) time
108 T pre_time = T(0); // global previous (pseudo) time
109
110 T strain_energy = T(0);
111 T kinetic_energy = T(0);
112 T viscous_energy = T(0);
113 T nonviscous_energy = T(0);
114 T complementary_energy = T(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_mpc(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_mpc() 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 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) {
760 if(S == n_rfld) return;
761 n_rfld = S;
762}
763
764template<sp_d T> unsigned Factory<T>::get_reference_size() const { return n_rfld; }
765
766template<sp_d T> void Factory<T>::update_reference_dof(const uvec& S) { reference_dof.insert(S.cbegin(), S.cend()); }
767
768template<sp_d T> void Factory<T>::set_reference_dof(const suanpan::set<uword>& D) { reference_dof = D; }
769
770template<sp_d T> const suanpan::set<uword>& Factory<T>::get_reference_dof() const { return reference_dof; }
771
772template<sp_d T> void Factory<T>::set_error(const T E) { error = E; }
773
774template<sp_d T> T Factory<T>::get_error() const { return error; }
775
776template<sp_d T> int Factory<T>::initialize() {
777 reference_dof.clear(); // clear reference dof vector in every step
778
779 if(initialized || n_size == 0) return 0;
780
781 ninja.zeros(n_size);
782 sushi.zeros(n_size);
783
784 reset();
785
786 switch(analysis_type) {
787 case AnalysisType::DISP:
788 initialize_displacement();
789 break;
790 case AnalysisType::EIGEN:
791 initialize_mass();
792 initialize_stiffness();
793 initialize_eigen();
794 break;
795 case AnalysisType::BUCKLE:
796 case AnalysisType::STATICS:
797 initialize_load();
798 initialize_resistance();
799 initialize_displacement();
800 initialize_stiffness();
801 initialize_geometry();
802 break;
803 case AnalysisType::DYNAMICS:
804 initialize_load();
805 initialize_resistance();
806 initialize_damping_force();
807 initialize_nonviscous_force();
808 initialize_inertial_force();
809 initialize_displacement();
810 initialize_velocity();
811 initialize_acceleration();
812 initialize_mass();
813 initialize_damping();
814 initialize_nonviscous();
815 initialize_stiffness();
816 initialize_geometry();
817 break;
818 case AnalysisType::NONE:
819 break;
820 }
821
822 initialize_auxiliary_resistance();
823
824 access::rw(initialized) = true;
825
826 return 0;
827}
828
829template<sp_d T> void Factory<T>::initialize_load_factor() {
830 if(n_rfld == 0) return;
831
832 trial_load_factor.zeros(n_rfld);
833 incre_load_factor.zeros(n_rfld);
834 current_load_factor.zeros(n_rfld);
835
836 reference_load.zeros(n_size, n_rfld);
837}
838
839template<sp_d T> void Factory<T>::initialize_load() {
840 trial_load.zeros(n_size);
841 incre_load.zeros(n_size);
842 current_load.zeros(n_size);
843}
844
845template<sp_d T> void Factory<T>::initialize_settlement() {
846 trial_settlement.zeros(n_size);
847 incre_settlement.zeros(n_size);
848 current_settlement.zeros(n_size);
849}
850
851template<sp_d T> void Factory<T>::initialize_resistance() {
852 trial_resistance.zeros(n_size);
853 incre_resistance.zeros(n_size);
854 current_resistance.zeros(n_size);
855}
856
857template<sp_d T> void Factory<T>::initialize_damping_force() {
858 trial_damping_force.zeros(n_size);
859 incre_damping_force.zeros(n_size);
860 current_damping_force.zeros(n_size);
861}
862
863template<sp_d T> void Factory<T>::initialize_nonviscous_force() {
864 trial_nonviscous_force.zeros(n_size);
865 incre_nonviscous_force.zeros(n_size);
866 current_nonviscous_force.zeros(n_size);
867}
868
869template<sp_d T> void Factory<T>::initialize_inertial_force() {
870 trial_inertial_force.zeros(n_size);
871 incre_inertial_force.zeros(n_size);
872 current_inertial_force.zeros(n_size);
873}
874
875template<sp_d T> void Factory<T>::initialize_displacement() {
876 trial_displacement.zeros(n_size);
877 incre_displacement.zeros(n_size);
878 current_displacement.zeros(n_size);
879}
880
881template<sp_d T> void Factory<T>::initialize_velocity() {
882 trial_velocity.zeros(n_size);
883 incre_velocity.zeros(n_size);
884 current_velocity.zeros(n_size);
885}
886
887template<sp_d T> void Factory<T>::initialize_acceleration() {
888 trial_acceleration.zeros(n_size);
889 incre_acceleration.zeros(n_size);
890 current_acceleration.zeros(n_size);
891}
892
893template<sp_d T> void Factory<T>::initialize_temperature() {
894 trial_temperature.zeros(n_size);
895 incre_temperature.zeros(n_size);
896 current_temperature.zeros(n_size);
897}
898
899template<sp_d T> void Factory<T>::initialize_auxiliary_resistance() {
900 trial_constraint_resistance.zeros(n_size);
901 current_constraint_resistance.zeros(n_size);
902}
903
904template<sp_d T> void Factory<T>::initialize_mass() { global_mass = get_matrix_container(); }
905
906template<sp_d T> void Factory<T>::initialize_damping() { global_damping = get_matrix_container(); }
907
908template<sp_d T> void Factory<T>::initialize_nonviscous() {
909 if(!nonviscous) return;
910
911 global_nonviscous = get_matrix_container();
912}
913
914template<sp_d T> void Factory<T>::initialize_stiffness() { global_stiffness = get_matrix_container(); }
915
916template<sp_d T> void Factory<T>::initialize_geometry() {
917 if(!nlgeom) return;
918
919 global_geometry = get_matrix_container();
920}
921
922template<sp_d T> void Factory<T>::initialize_eigen() {
923 eigenvalue.zeros(n_size);
924 eigenvector.zeros(n_size, n_size);
925}
926
927template<sp_d T> void Factory<T>::set_ninja(const Col<T>& N) { ninja = N; }
928
929template<sp_d T> void Factory<T>::set_sushi(const Col<T>& S) { sushi = S; }
930
931template<sp_d T> void Factory<T>::update_sushi_by(const Col<T>& S) { sushi += S; }
932
933template<sp_d T> void Factory<T>::set_mpc(const unsigned S) {
934 n_mpc = S;
935 auxiliary_encoding.zeros(n_mpc);
936 auxiliary_resistance.zeros(n_mpc);
937 auxiliary_load.zeros(n_mpc);
938 auxiliary_stiffness.zeros(n_size, n_mpc);
939}
940
941template<sp_d T> void Factory<T>::set_reference_load(const SpMat<T>& L) { reference_load = L; }
942
943template<sp_d T> void Factory<T>::set_mass(const shared_ptr<MetaMat<T>>& M) { global_mass = M; }
944
945template<sp_d T> void Factory<T>::set_damping(const shared_ptr<MetaMat<T>>& C) { global_damping = C; }
946
947template<sp_d T> void Factory<T>::set_nonviscous(const shared_ptr<MetaMat<T>>& C) { global_nonviscous = C; }
948
949template<sp_d T> void Factory<T>::set_stiffness(const shared_ptr<MetaMat<T>>& K) { global_stiffness = K; }
950
951template<sp_d T> void Factory<T>::set_geometry(const shared_ptr<MetaMat<T>>& G) { global_geometry = G; }
952
953template<sp_d T> void Factory<T>::set_eigenvalue(const Col<T>& L) { eigenvalue = L; }
954
955template<sp_d T> void Factory<T>::set_eigenvector(const Mat<T>& V) { eigenvector = V; }
956
957template<sp_d T> const Col<T>& Factory<T>::get_ninja() const { return ninja; }
958
959template<sp_d T> const Col<T>& Factory<T>::get_sushi() const { return sushi; }
960
961template<sp_d T> unsigned Factory<T>::get_mpc() const { return n_mpc; }
962
963template<sp_d T> const SpMat<T>& Factory<T>::get_reference_load() const { return reference_load; }
964
965template<sp_d T> const uvec& Factory<T>::get_auxiliary_encoding() const { return auxiliary_encoding; }
966
967template<sp_d T> const Col<T>& Factory<T>::get_auxiliary_lambda() const { return auxiliary_lambda; }
968
969template<sp_d T> const Col<T>& Factory<T>::get_auxiliary_resistance() const { return auxiliary_resistance; }
970
971template<sp_d T> const Col<T>& Factory<T>::get_auxiliary_load() const { return auxiliary_load; }
972
973template<sp_d T> const SpMat<T>& Factory<T>::get_auxiliary_stiffness() const { return auxiliary_stiffness; }
974
975template<sp_d T> const SpCol<T>& Factory<T>::get_trial_constraint_resistance() const { return trial_constraint_resistance; }
976
977template<sp_d T> const SpCol<T>& Factory<T>::get_current_constraint_resistance() const { return current_constraint_resistance; }
978
979template<sp_d T> T Factory<T>::get_strain_energy() { return strain_energy; }
980
981template<sp_d T> T Factory<T>::get_kinetic_energy() { return kinetic_energy; }
982
983template<sp_d T> T Factory<T>::get_viscous_energy() { return viscous_energy; }
984
985template<sp_d T> T Factory<T>::get_nonviscous_energy() { return nonviscous_energy; }
986
987template<sp_d T> T Factory<T>::get_complementary_energy() { return complementary_energy; }
988
989template<sp_d T> const Col<T>& Factory<T>::get_momentum() { return momentum; }
990
991template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_mass() const { return global_mass; }
992
993template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_damping() const { return global_damping; }
994
995template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_nonviscous() const { return global_nonviscous; }
996
997template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_stiffness() const { return global_stiffness; }
998
999template<sp_d T> const shared_ptr<MetaMat<T>>& Factory<T>::get_geometry() const { return global_geometry; }
1000
1001template<sp_d T> std::mutex& Factory<T>::get_auxiliary_encoding_mutex() { return global_mutex.at(0); }
1002
1003template<sp_d T> std::mutex& Factory<T>::get_auxiliary_resistance_mutex() { return global_mutex.at(1); }
1004
1005template<sp_d T> std::mutex& Factory<T>::get_auxiliary_load_mutex() { return global_mutex.at(2); }
1006
1007template<sp_d T> std::mutex& Factory<T>::get_auxiliary_stiffness_mutex() { return global_mutex.at(3); }
1008
1009template<sp_d T> std::mutex& Factory<T>::get_trial_constraint_resistance_mutex() { return global_mutex.at(4); }
1010
1011template<sp_d T> std::mutex& Factory<T>::get_trial_load_mutex() { return global_mutex.at(5); }
1012
1013template<sp_d T> std::mutex& Factory<T>::get_trial_settlement_mutex() { return global_mutex.at(6); }
1014
1015template<sp_d T> std::mutex& Factory<T>::get_reference_load_mutex() { return global_mutex.at(7); }
1016
1017template<sp_d T> std::mutex& Factory<T>::get_mass_mutex() { return global_mutex.at(8); }
1018
1019template<sp_d T> std::mutex& Factory<T>::get_damping_mutex() { return global_mutex.at(9); }
1020
1021template<sp_d T> std::mutex& Factory<T>::get_nonviscous_mutex() { return global_mutex.at(10); }
1022
1023template<sp_d T> std::mutex& Factory<T>::get_stiffness_mutex() { return global_mutex.at(11); }
1024
1025template<sp_d T> std::mutex& Factory<T>::get_geometry_mutex() { return global_mutex.at(12); }
1026
1027template<sp_d T> const Col<T>& Factory<T>::get_eigenvalue() const { return eigenvalue; }
1028
1029template<sp_d T> const Mat<T>& Factory<T>::get_eigenvector() const { return eigenvector; }
1030
1031template<sp_d T> void Factory<T>::commit_energy() {
1032 auto se = std::async([&] { if(!trial_resistance.empty() && !incre_displacement.empty()) strain_energy += .5 * dot(trial_resistance + current_resistance, incre_displacement); });
1033 auto ke = std::async([&] { if(!trial_inertial_force.empty() && !trial_velocity.empty()) kinetic_energy = .5 * dot(global_mass * trial_velocity, trial_velocity); });
1034 auto ve = std::async([&] { if(!trial_damping_force.empty() && !incre_displacement.empty()) viscous_energy += .5 * dot(trial_damping_force + current_damping_force, incre_displacement); });
1035 auto ne = std::async([&] { if(!trial_nonviscous_force.empty() && !incre_displacement.empty()) nonviscous_energy += .5 * dot(trial_nonviscous_force + current_nonviscous_force, incre_displacement); });
1036 auto ce = std::async([&] { if(!trial_displacement.empty() && !incre_resistance.empty()) complementary_energy += .5 * dot(trial_displacement + current_displacement, incre_resistance); });
1037 auto mm = std::async([&] { if(!trial_inertial_force.empty() && !trial_velocity.empty()) momentum = global_mass * trial_velocity; });
1038
1039 se.get();
1040 ke.get();
1041 ve.get();
1042 ne.get();
1043 ce.get();
1044 mm.get();
1045}
1046
1047template<sp_d T> void Factory<T>::clear_energy() {
1048 strain_energy = T(0);
1049 kinetic_energy = T(0);
1050 viscous_energy = T(0);
1051 nonviscous_energy = T(0);
1052 complementary_energy = T(0);
1053 momentum.zeros();
1054}
1055
1056template<sp_d T> void Factory<T>::commit_status() {
1057 ninja.zeros();
1058
1059 commit_energy();
1060
1061 commit_time();
1062 commit_load_factor();
1063 commit_load();
1064 commit_settlement();
1065 commit_resistance();
1066 commit_damping_force();
1067 commit_nonviscous_force();
1068 commit_inertial_force();
1069 commit_displacement();
1070 commit_velocity();
1071 commit_acceleration();
1072 commit_temperature();
1073 commit_auxiliary_resistance();
1074}
1075
1076template<sp_d T> void Factory<T>::commit_time() {
1077 current_time = trial_time;
1078 incre_time = T(0);
1079}
1080
1081template<sp_d T> void Factory<T>::commit_load_factor() {
1082 if(trial_load_factor.is_empty()) return;
1083 current_load_factor = trial_load_factor;
1084 incre_load_factor.zeros();
1085}
1086
1087template<sp_d T> void Factory<T>::commit_load() {
1088 if(trial_load.is_empty()) return;
1089 current_load = trial_load;
1090 incre_load.zeros();
1091}
1092
1093template<sp_d T> void Factory<T>::commit_settlement() {
1094 if(trial_settlement.is_empty()) return;
1095 current_settlement = trial_settlement;
1096 incre_settlement.zeros();
1097}
1098
1099template<sp_d T> void Factory<T>::commit_resistance() {
1100 if(trial_resistance.is_empty()) return;
1101 current_resistance = trial_resistance;
1102 incre_resistance.zeros();
1103}
1104
1105template<sp_d T> void Factory<T>::commit_damping_force() {
1106 if(trial_damping_force.is_empty()) return;
1107 current_damping_force = trial_damping_force;
1108 incre_damping_force.zeros();
1109}
1110
1111template<sp_d T> void Factory<T>::commit_nonviscous_force() {
1112 if(trial_nonviscous_force.is_empty()) return;
1113 current_nonviscous_force = trial_nonviscous_force;
1114 incre_nonviscous_force.zeros();
1115}
1116
1117template<sp_d T> void Factory<T>::commit_inertial_force() {
1118 if(trial_inertial_force.is_empty()) return;
1119 current_inertial_force = trial_inertial_force;
1120 incre_inertial_force.zeros();
1121}
1122
1123template<sp_d T> void Factory<T>::commit_displacement() {
1124 if(trial_displacement.is_empty()) return;
1125 current_displacement = trial_displacement;
1126 incre_displacement.zeros();
1127}
1128
1129template<sp_d T> void Factory<T>::commit_velocity() {
1130 if(trial_velocity.is_empty()) return;
1131 current_velocity = trial_velocity;
1132 incre_velocity.zeros();
1133}
1134
1135template<sp_d T> void Factory<T>::commit_acceleration() {
1136 if(trial_acceleration.is_empty()) return;
1137 current_acceleration = trial_acceleration;
1138 incre_acceleration.zeros();
1139}
1140
1141template<sp_d T> void Factory<T>::commit_temperature() {
1142 if(trial_temperature.is_empty()) return;
1143 current_temperature = trial_temperature;
1144 incre_temperature.zeros();
1145}
1146
1147template<sp_d T> void Factory<T>::commit_auxiliary_resistance() {
1148 if(trial_constraint_resistance.is_empty()) return;
1149 current_constraint_resistance = trial_constraint_resistance;
1150}
1151
1152template<sp_d T> void Factory<T>::commit_pre_status() {
1153 commit_pre_time();
1154 commit_pre_load_factor();
1155 commit_pre_load();
1156 commit_pre_settlement();
1157 commit_pre_resistance();
1158 commit_pre_damping_force();
1159 commit_pre_nonviscous_force();
1160 commit_pre_inertial_force();
1161 commit_pre_displacement();
1162 commit_pre_velocity();
1163 commit_pre_acceleration();
1164 commit_pre_temperature();
1165}
1166
1167template<sp_d T> void Factory<T>::commit_pre_time() { pre_time = current_time; }
1168
1169template<sp_d T> void Factory<T>::commit_pre_load_factor() { if(!current_load_factor.is_empty()) pre_load_factor = current_load_factor; }
1170
1171template<sp_d T> void Factory<T>::commit_pre_load() { if(!current_load.is_empty()) pre_load = current_load; }
1172
1173template<sp_d T> void Factory<T>::commit_pre_settlement() { if(!current_settlement.is_empty()) pre_settlement = current_settlement; }
1174
1175template<sp_d T> void Factory<T>::commit_pre_resistance() { if(!current_resistance.is_empty()) pre_resistance = current_resistance; }
1176
1177template<sp_d T> void Factory<T>::commit_pre_damping_force() { if(!current_damping_force.is_empty()) pre_damping_force = current_damping_force; }
1178
1179template<sp_d T> void Factory<T>::commit_pre_nonviscous_force() { if(!current_nonviscous_force.is_empty()) pre_nonviscous_force = current_nonviscous_force; }
1180
1181template<sp_d T> void Factory<T>::commit_pre_inertial_force() { if(!current_inertial_force.is_empty()) pre_inertial_force = current_inertial_force; }
1182
1183template<sp_d T> void Factory<T>::commit_pre_displacement() { if(!current_displacement.is_empty()) pre_displacement = current_displacement; }
1184
1185template<sp_d T> void Factory<T>::commit_pre_velocity() { if(!current_velocity.is_empty()) pre_velocity = current_velocity; }
1186
1187template<sp_d T> void Factory<T>::commit_pre_acceleration() { if(!current_acceleration.is_empty()) pre_acceleration = current_acceleration; }
1188
1189template<sp_d T> void Factory<T>::commit_pre_temperature() { if(!current_temperature.is_empty()) pre_temperature = current_temperature; }
1190
1191template<sp_d T> void Factory<T>::clear_status() {
1192 access::rw(initialized) = false;
1193
1194 ninja.zeros();
1195
1196 clear_energy();
1197
1198 clear_time();
1199 clear_load_factor();
1200 clear_load();
1201 clear_settlement();
1202 clear_resistance();
1203 clear_damping_force();
1204 clear_nonviscous_force();
1205 clear_inertial_force();
1206 clear_displacement();
1207 clear_velocity();
1208 clear_acceleration();
1209 clear_temperature();
1210 clear_auxiliary_resistance();
1211}
1212
1213template<sp_d T> void Factory<T>::clear_time() { trial_time = incre_time = current_time = 0.; }
1214
1215template<sp_d T> void Factory<T>::clear_load_factor() {
1216 if(!pre_load_factor.is_empty()) pre_load_factor.zeros();
1217 if(!trial_load_factor.is_empty()) trial_load_factor.zeros();
1218 if(!incre_load_factor.is_empty()) incre_load_factor.zeros();
1219 if(!current_load_factor.is_empty()) current_load_factor.zeros();
1220}
1221
1222template<sp_d T> void Factory<T>::clear_load() {
1223 if(!pre_load.is_empty()) pre_load.zeros();
1224 if(!trial_load.is_empty()) trial_load.zeros();
1225 if(!incre_load.is_empty()) incre_load.zeros();
1226 if(!current_load.is_empty()) current_load.zeros();
1227}
1228
1229template<sp_d T> void Factory<T>::clear_settlement() {
1230 if(!pre_settlement.is_empty()) pre_settlement.zeros();
1231 if(!trial_settlement.is_empty()) trial_settlement.zeros();
1232 if(!incre_settlement.is_empty()) incre_settlement.zeros();
1233 if(!current_settlement.is_empty()) current_settlement.zeros();
1234}
1235
1236template<sp_d T> void Factory<T>::clear_resistance() {
1237 if(!pre_resistance.is_empty()) pre_resistance.zeros();
1238 if(!trial_resistance.is_empty()) trial_resistance.zeros();
1239 if(!incre_resistance.is_empty()) incre_resistance.zeros();
1240 if(!current_resistance.is_empty()) current_resistance.zeros();
1241}
1242
1243template<sp_d T> void Factory<T>::clear_damping_force() {
1244 if(!pre_damping_force.is_empty()) pre_damping_force.zeros();
1245 if(!trial_damping_force.is_empty()) trial_damping_force.zeros();
1246 if(!incre_damping_force.is_empty()) incre_damping_force.zeros();
1247 if(!current_damping_force.is_empty()) current_damping_force.zeros();
1248}
1249
1250template<sp_d T> void Factory<T>::clear_nonviscous_force() {
1251 if(!pre_nonviscous_force.is_empty()) pre_nonviscous_force.zeros();
1252 if(!trial_nonviscous_force.is_empty()) trial_nonviscous_force.zeros();
1253 if(!incre_nonviscous_force.is_empty()) incre_nonviscous_force.zeros();
1254 if(!current_nonviscous_force.is_empty()) current_nonviscous_force.zeros();
1255}
1256
1257template<sp_d T> void Factory<T>::clear_inertial_force() {
1258 if(!pre_inertial_force.is_empty()) pre_inertial_force.zeros();
1259 if(!trial_inertial_force.is_empty()) trial_inertial_force.zeros();
1260 if(!incre_inertial_force.is_empty()) incre_inertial_force.zeros();
1261 if(!current_inertial_force.is_empty()) current_inertial_force.zeros();
1262}
1263
1264template<sp_d T> void Factory<T>::clear_displacement() {
1265 if(!pre_displacement.is_empty()) pre_displacement.zeros();
1266 if(!trial_displacement.is_empty()) trial_displacement.zeros();
1267 if(!incre_displacement.is_empty()) incre_displacement.zeros();
1268 if(!current_displacement.is_empty()) current_displacement.zeros();
1269}
1270
1271template<sp_d T> void Factory<T>::clear_velocity() {
1272 if(!pre_velocity.is_empty()) pre_velocity.zeros();
1273 if(!trial_velocity.is_empty()) trial_velocity.zeros();
1274 if(!incre_velocity.is_empty()) incre_velocity.zeros();
1275 if(!current_velocity.is_empty()) current_velocity.zeros();
1276}
1277
1278template<sp_d T> void Factory<T>::clear_acceleration() {
1279 if(!pre_acceleration.is_empty()) pre_acceleration.zeros();
1280 if(!trial_acceleration.is_empty()) trial_acceleration.zeros();
1281 if(!incre_acceleration.is_empty()) incre_acceleration.zeros();
1282 if(!current_acceleration.is_empty()) current_acceleration.zeros();
1283}
1284
1285template<sp_d T> void Factory<T>::clear_temperature() {
1286 if(!pre_temperature.is_empty()) pre_temperature.zeros();
1287 if(!trial_temperature.is_empty()) trial_temperature.zeros();
1288 if(!incre_temperature.is_empty()) incre_temperature.zeros();
1289 if(!current_temperature.is_empty()) current_temperature.zeros();
1290}
1291
1292template<sp_d T> void Factory<T>::clear_auxiliary_resistance() {
1293 if(!trial_constraint_resistance.is_empty()) trial_constraint_resistance.zeros();
1294 if(!current_constraint_resistance.is_empty()) current_constraint_resistance.zeros();
1295}
1296
1297template<sp_d T> void Factory<T>::reset_status() {
1298 ninja.zeros();
1299
1300 reset_time();
1301 reset_load_factor();
1302 reset_load();
1303 reset_settlement();
1304 reset_resistance();
1305 reset_damping_force();
1306 reset_nonviscous_force();
1307 reset_inertial_force();
1308 reset_displacement();
1309 reset_velocity();
1310 reset_acceleration();
1311 reset_temperature();
1312 reset_auxiliary_resistance();
1313}
1314
1315template<sp_d T> void Factory<T>::reset_time() {
1316 trial_time = current_time;
1317 incre_time = T(0);
1318}
1319
1320template<sp_d T> void Factory<T>::reset_load_factor() {
1321 if(trial_load_factor.is_empty()) return;
1322 trial_load_factor = current_load_factor;
1323 incre_load_factor.zeros();
1324}
1325
1326template<sp_d T> void Factory<T>::reset_load() {
1327 if(trial_load.is_empty()) return;
1328 trial_load = current_load;
1329 incre_load.zeros();
1330}
1331
1332template<sp_d T> void Factory<T>::reset_settlement() {
1333 if(trial_settlement.is_empty()) return;
1334 trial_settlement = current_settlement;
1335 incre_settlement.zeros();
1336}
1337
1338template<sp_d T> void Factory<T>::reset_resistance() {
1339 if(trial_resistance.is_empty()) return;
1340 trial_resistance = current_resistance;
1341 incre_resistance.zeros();
1342}
1343
1344template<sp_d T> void Factory<T>::reset_damping_force() {
1345 if(trial_damping_force.is_empty()) return;
1346 trial_damping_force = current_damping_force;
1347 incre_damping_force.zeros();
1348}
1349
1350template<sp_d T> void Factory<T>::reset_nonviscous_force() {
1351 if(trial_nonviscous_force.is_empty()) return;
1352 trial_nonviscous_force = current_nonviscous_force;
1353 incre_nonviscous_force.zeros();
1354}
1355
1356template<sp_d T> void Factory<T>::reset_inertial_force() {
1357 if(trial_inertial_force.is_empty()) return;
1358 trial_inertial_force = current_inertial_force;
1359 incre_inertial_force.zeros();
1360}
1361
1362template<sp_d T> void Factory<T>::reset_displacement() {
1363 if(trial_displacement.is_empty()) return;
1364 trial_displacement = current_displacement;
1365 incre_displacement.zeros();
1366}
1367
1368template<sp_d T> void Factory<T>::reset_velocity() {
1369 if(trial_velocity.is_empty()) return;
1370 trial_velocity = current_velocity;
1371 incre_velocity.zeros();
1372}
1373
1374template<sp_d T> void Factory<T>::reset_acceleration() {
1375 if(trial_acceleration.is_empty()) return;
1376 trial_acceleration = current_acceleration;
1377 incre_acceleration.zeros();
1378}
1379
1380template<sp_d T> void Factory<T>::reset_temperature() {
1381 if(trial_temperature.is_empty()) return;
1382 trial_temperature = current_temperature;
1383 incre_temperature.zeros();
1384}
1385
1386template<sp_d T> void Factory<T>::reset_auxiliary_resistance() {
1387 if(trial_constraint_resistance.is_empty()) return;
1388 trial_constraint_resistance = current_constraint_resistance;
1389}
1390
1391template<sp_d T> void Factory<T>::clear_eigen() {
1392 if(!eigenvalue.is_empty()) eigenvalue.zeros();
1393 if(!eigenvector.is_empty()) eigenvector.zeros();
1394}
1395
1396template<sp_d T> void Factory<T>::clear_mass() { if(global_mass != nullptr) global_mass->zeros(); }
1397
1398template<sp_d T> void Factory<T>::clear_damping() { if(global_damping != nullptr) global_damping->zeros(); }
1399
1400template<sp_d T> void Factory<T>::clear_nonviscous() { if(global_nonviscous != nullptr) global_nonviscous->zeros(); }
1401
1402template<sp_d T> void Factory<T>::clear_stiffness() { if(global_stiffness != nullptr) global_stiffness->zeros(); }
1403
1404template<sp_d T> void Factory<T>::clear_geometry() { if(global_geometry != nullptr) global_geometry->zeros(); }
1405
1406template<sp_d T> void Factory<T>::clear_auxiliary() {
1407 n_mpc = 0;
1408 auxiliary_load.reset();
1409 auxiliary_stiffness.set_size(n_size, 0);
1410 auxiliary_resistance.reset();
1411 auxiliary_encoding.reset();
1412}
1413
1414template<sp_d T> void Factory<T>::reset() {
1415 global_mass = nullptr;
1416 global_damping = nullptr;
1417 global_nonviscous = nullptr;
1418 global_stiffness = nullptr;
1419 global_geometry = nullptr;
1420}
1421
1422template<sp_d T> void Factory<T>::assemble_resistance(const Mat<T>& ER, const uvec& EI) {
1423 if(ER.is_empty()) return;
1424 for(auto I = 0llu; I < EI.n_elem; ++I) trial_resistance(EI(I)) += ER(I);
1425}
1426
1427template<sp_d T> void Factory<T>::assemble_damping_force(const Mat<T>& ER, const uvec& EI) {
1428 if(ER.is_empty()) return;
1429 for(auto I = 0llu; I < EI.n_elem; ++I) trial_damping_force(EI(I)) += ER(I);
1430}
1431
1432template<sp_d T> void Factory<T>::assemble_nonviscous_force(const Mat<T>& ER, const uvec& EI) {
1433 if(ER.is_empty()) return;
1434 for(auto I = 0llu; I < EI.n_elem; ++I) trial_nonviscous_force(EI(I)) += ER(I);
1435}
1436
1437template<sp_d T> void Factory<T>::assemble_inertial_force(const Mat<T>& ER, const uvec& EI) {
1438 if(ER.is_empty()) return;
1439 for(auto I = 0llu; I < EI.n_elem; ++I) trial_inertial_force(EI(I)) += ER(I);
1440}
1441
1442template<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) {
1443 if(EM.is_empty()) return;
1444
1445 if(StorageScheme::BANDSYMM == storage_type || StorageScheme::SYMMPACK == storage_type) for(const auto [g_row, g_col, l_row, l_col] : MAP) GM->unsafe_at(g_row, g_col) += EM(l_row, l_col);
1446 else for(auto I = 0llu; I < EI.n_elem; ++I) for(auto J = 0llu; J < EI.n_elem; ++J) GM->unsafe_at(EI(J), EI(I)) += EM(J, I);
1447}
1448
1449template<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); }
1450
1451template<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); }
1452
1453template<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); }
1454
1455template<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); }
1456
1457template<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); }
1458
1459template<sp_d T> void Factory<T>::assemble_stiffness(const SpMat<T>& EK, const uvec& EI) {
1460 if(EK.is_empty()) return;
1461 for(auto I = EK.begin(); I != EK.end(); ++I) global_stiffness->at(EI(I.row()), EI(I.col())) += *I;
1462}
1463
1464template<sp_d T> void Factory<T>::print() const {
1465 suanpan_info("A Factory object with size of {}.\n", n_size);
1466}
1467
1468template<sp_d T> unique_ptr<MetaMat<T>> Factory<T>::get_basic_container() {
1469#ifdef SUANPAN_DISTRIBUTED
1470 switch(storage_type) {
1471 case StorageScheme::FULL:
1472 return std::make_unique<FullMatCluster<T>>(n_size, n_size);
1473 case StorageScheme::SYMMPACK:
1474 return std::make_unique<FullSymmMatCluster<T>>(n_size, n_size);
1475 case StorageScheme::BAND:
1476 return std::make_unique<BandMatCluster<T>>(n_size, n_lobw, n_upbw);
1477 case StorageScheme::BANDSYMM:
1478 return std::make_unique<BandSymmMatCluster<T>>(n_size, n_lobw);
1479 case StorageScheme::SPARSE:
1480#ifdef SUANPAN_MKL
1481 if(contain_solver_type(SolverType::PARDISO)) return std::make_unique<SparseMatClusterPARDISO<T>>(n_size, n_size, n_elem);
1482#endif
1483 if(contain_solver_type(SolverType::LIS)) return std::make_unique<SparseMatClusterLIS<T>>(n_size, n_size, n_elem);
1484 return std::make_unique<SparseMatClusterMUMPS<T>>(n_size, n_size, n_elem);
1485 case StorageScheme::SPARSESYMM:
1486#ifdef SUANPAN_MKL
1487 if(contain_solver_type(SolverType::PARDISO)) return std::make_unique<SparseSymmMatClusterPARDISO<T>>(n_size, n_size, n_elem);
1488#endif
1489 if(contain_solver_type(SolverType::LIS)) return std::make_unique<SparseMatClusterLIS<T>>(n_size, n_size, n_elem);
1490 return std::make_unique<SparseSymmMatClusterMUMPS<T>>(n_size, n_size, n_elem);
1491 default:
1492 throw invalid_argument("need a proper storage scheme");
1493 }
1494#else
1495 switch(storage_type) {
1496 case StorageScheme::FULL:
1497#ifdef SUANPAN_CUDA
1498 if(contain_solver_type(SolverType::CUDA)) return std::make_unique<FullMatCUDA<T>>(n_size, n_size);
1499#endif
1500 return std::make_unique<FullMat<T>>(n_size, n_size);
1501 case StorageScheme::BAND:
1502 if(contain_solver_type(SolverType::SPIKE)) return std::make_unique<BandMatSpike<T>>(n_size, n_lobw, n_upbw);
1503#ifdef SUANPAN_MAGMA
1504 if(contain_solver_type(SolverType::MAGMA)) return std::make_unique<BandMatMAGMA<T>>(n_size, n_lobw, n_upbw);
1505#endif
1506 return std::make_unique<BandMat<T>>(n_size, n_lobw, n_upbw);
1507 case StorageScheme::BANDSYMM:
1508 return std::make_unique<BandSymmMat<T>>(n_size, n_lobw);
1509 case StorageScheme::SYMMPACK:
1510 return std::make_unique<SymmPackMat<T>>(n_size);
1511 case StorageScheme::SPARSESYMM:
1512#ifdef SUANPAN_MKL
1513#pragma GCC diagnostic push
1514#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
1515 if(contain_solver_type(SolverType::PARDISO)) return std::make_unique<SparseSymmMatPARDISO<T>>(n_size, n_size, n_elem);
1516#pragma GCC diagnostic pop
1517#endif
1518 case StorageScheme::SPARSE:
1519#ifdef SUANPAN_MKL
1520 if(contain_solver_type(SolverType::PARDISO)) return std::make_unique<SparseMatPARDISO<T>>(n_size, n_size, n_elem);
1521 if(contain_solver_type(SolverType::FGMRES)) return std::make_unique<SparseMatFGMRES<T>>(n_size, n_size, n_elem);
1522#endif
1523#ifdef SUANPAN_CUDA
1524 if(contain_solver_type(SolverType::CUDA)) return std::make_unique<SparseMatCUDA<T>>(n_size, n_size, n_elem);
1525#ifdef SUANPAN_MAGMA
1526 if(contain_solver_type(SolverType::MAGMA)) return std::make_unique<SparseMatMAGMA<T>>(n_size, n_size, n_elem);
1527#endif
1528#endif
1529 return std::make_unique<SparseMatSuperLU<T>>(n_size, n_size, n_elem);
1530 default:
1531 throw invalid_argument("need a proper storage scheme");
1532 }
1533#endif
1534}
1535
1536template<sp_d T> unique_ptr<MetaMat<T>> Factory<T>::get_matrix_container() {
1537 auto global_mat = get_basic_container();
1538
1539 global_mat->set_solver_setting(setting);
1540
1541 return global_mat;
1542}
1543
1544template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_mass() { return global_mass; }
1545
1546template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_damping() { return global_damping; }
1547
1548template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_nonviscous() { return global_nonviscous; }
1549
1550template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_stiffness() { return global_stiffness; }
1551
1552template<sp_d T> shared_ptr<MetaMat<T>>& Factory<T>::modify_geometry() { return global_geometry; }
1553
1554template<sp_d T> Col<T>& Factory<T>::modify_ninja() { return ninja; }
1555
1556template<sp_d T> Col<T>& Factory<T>::modify_sushi() { return sushi; }
1557
1558template<sp_d T> suanpan::set<uword>& Factory<T>::modify_reference_dof() { return reference_dof; }
1559
1560template<sp_d T> SpMat<T>& Factory<T>::modify_reference_load() { return reference_load; }
1561
1562template<sp_d T> uvec& Factory<T>::modify_auxiliary_encoding() { return auxiliary_encoding; }
1563
1564template<sp_d T> Col<T>& Factory<T>::modify_auxiliary_lambda() { return auxiliary_lambda; }
1565
1566template<sp_d T> Col<T>& Factory<T>::modify_auxiliary_resistance() { return auxiliary_resistance; }
1567
1568template<sp_d T> Col<T>& Factory<T>::modify_auxiliary_load() { return auxiliary_load; }
1569
1570template<sp_d T> SpMat<T>& Factory<T>::modify_auxiliary_stiffness() { return auxiliary_stiffness; }
1571
1572template<sp_d T> SpCol<T>& Factory<T>::modify_trial_constraint_resistance() { return trial_constraint_resistance; }
1573
1574template<sp_d T> SpCol<T>& Factory<T>::modify_current_constraint_resistance() { return current_constraint_resistance; }
1575
1576template<sp_d T> Col<T>& Factory<T>::modify_eigenvalue() { return eigenvalue; }
1577
1578template<sp_d T> Mat<T>& Factory<T>::modify_eigenvector() { return eigenvector; }
1579
1580template<sp_d T> void Factory<T>::set_trial_time(const T M) { trial_time = M; }
1581
1582template<sp_d T> void Factory<T>::set_trial_load_factor(const Col<T>& L) { trial_load_factor = L; }
1583
1584template<sp_d T> void Factory<T>::set_trial_load(const Col<T>& L) { trial_load = L; }
1585
1586template<sp_d T> void Factory<T>::set_trial_settlement(const Col<T>& S) { trial_settlement = S; }
1587
1588template<sp_d T> void Factory<T>::set_trial_resistance(const Col<T>& R) { trial_resistance = R; }
1589
1590template<sp_d T> void Factory<T>::set_trial_damping_force(const Col<T>& R) { trial_damping_force = R; }
1591
1592template<sp_d T> void Factory<T>::set_trial_nonviscous_force(const Col<T>& R) { trial_nonviscous_force = R; }
1593
1594template<sp_d T> void Factory<T>::set_trial_inertial_force(const Col<T>& R) { trial_inertial_force = R; }
1595
1596template<sp_d T> void Factory<T>::set_trial_displacement(const Col<T>& D) { trial_displacement = D; }
1597
1598template<sp_d T> void Factory<T>::set_trial_velocity(const Col<T>& V) { trial_velocity = V; }
1599
1600template<sp_d T> void Factory<T>::set_trial_acceleration(const Col<T>& A) { trial_acceleration = A; }
1601
1602template<sp_d T> void Factory<T>::set_trial_temperature(const Col<T>& M) { trial_temperature = M; }
1603
1604template<sp_d T> void Factory<T>::set_incre_time(const T M) { incre_time = M; }
1605
1606template<sp_d T> void Factory<T>::set_incre_load_factor(const Col<T>& L) { incre_load_factor = L; }
1607
1608template<sp_d T> void Factory<T>::set_incre_load(const Col<T>& L) { incre_load = L; }
1609
1610template<sp_d T> void Factory<T>::set_incre_settlement(const Col<T>& S) { incre_settlement = S; }
1611
1612template<sp_d T> void Factory<T>::set_incre_resistance(const Col<T>& R) { incre_resistance = R; }
1613
1614template<sp_d T> void Factory<T>::set_incre_damping_force(const Col<T>& R) { incre_damping_force = R; }
1615
1616template<sp_d T> void Factory<T>::set_incre_nonviscous_force(const Col<T>& R) { incre_nonviscous_force = R; }
1617
1618template<sp_d T> void Factory<T>::set_incre_inertial_force(const Col<T>& R) { incre_inertial_force = R; }
1619
1620template<sp_d T> void Factory<T>::set_incre_displacement(const Col<T>& D) { incre_displacement = D; }
1621
1622template<sp_d T> void Factory<T>::set_incre_velocity(const Col<T>& V) { incre_velocity = V; }
1623
1624template<sp_d T> void Factory<T>::set_incre_acceleration(const Col<T>& A) { incre_acceleration = A; }
1625
1626template<sp_d T> void Factory<T>::set_incre_temperature(const Col<T>& M) { incre_temperature = M; }
1627
1628template<sp_d T> void Factory<T>::set_current_time(const T M) { current_time = M; }
1629
1630template<sp_d T> void Factory<T>::set_current_load_factor(const Col<T>& L) { current_load_factor = L; }
1631
1632template<sp_d T> void Factory<T>::set_current_load(const Col<T>& L) { current_load = L; }
1633
1634template<sp_d T> void Factory<T>::set_current_settlement(const Col<T>& S) { current_settlement = S; }
1635
1636template<sp_d T> void Factory<T>::set_current_resistance(const Col<T>& R) { current_resistance = R; }
1637
1638template<sp_d T> void Factory<T>::set_current_damping_force(const Col<T>& R) { current_damping_force = R; }
1639
1640template<sp_d T> void Factory<T>::set_current_nonviscous_force(const Col<T>& R) { current_nonviscous_force = R; }
1641
1642template<sp_d T> void Factory<T>::set_current_inertial_force(const Col<T>& R) { current_inertial_force = R; }
1643
1644template<sp_d T> void Factory<T>::set_current_displacement(const Col<T>& D) { current_displacement = D; }
1645
1646template<sp_d T> void Factory<T>::set_current_velocity(const Col<T>& V) { current_velocity = V; }
1647
1648template<sp_d T> void Factory<T>::set_current_acceleration(const Col<T>& A) { current_acceleration = A; }
1649
1650template<sp_d T> void Factory<T>::set_current_temperature(const Col<T>& M) { current_temperature = M; }
1651
1652template<sp_d T> void Factory<T>::set_pre_time(const T M) { pre_time = M; }
1653
1654template<sp_d T> void Factory<T>::set_pre_load_factor(const Col<T>& L) { pre_load_factor = L; }
1655
1656template<sp_d T> void Factory<T>::set_pre_load(const Col<T>& L) { pre_load = L; }
1657
1658template<sp_d T> void Factory<T>::set_pre_settlement(const Col<T>& S) { pre_settlement = S; }
1659
1660template<sp_d T> void Factory<T>::set_pre_resistance(const Col<T>& R) { pre_resistance = R; }
1661
1662template<sp_d T> void Factory<T>::set_pre_damping_force(const Col<T>& R) { pre_damping_force = R; }
1663
1664template<sp_d T> void Factory<T>::set_pre_nonviscous_force(const Col<T>& R) { pre_nonviscous_force = R; }
1665
1666template<sp_d T> void Factory<T>::set_pre_inertial_force(const Col<T>& R) { pre_inertial_force = R; }
1667
1668template<sp_d T> void Factory<T>::set_pre_displacement(const Col<T>& D) { pre_displacement = D; }
1669
1670template<sp_d T> void Factory<T>::set_pre_velocity(const Col<T>& V) { pre_velocity = V; }
1671
1672template<sp_d T> void Factory<T>::set_pre_acceleration(const Col<T>& A) { pre_acceleration = A; }
1673
1674template<sp_d T> void Factory<T>::set_pre_temperature(const Col<T>& M) { pre_temperature = M; }
1675
1676template<sp_d T> T Factory<T>::get_trial_time() const { return trial_time; }
1677
1678template<sp_d T> const Col<T>& Factory<T>::get_trial_load_factor() const { return trial_load_factor; }
1679
1680template<sp_d T> const Col<T>& Factory<T>::get_trial_load() const { return trial_load; }
1681
1682template<sp_d T> const Col<T>& Factory<T>::get_trial_settlement() const { return trial_settlement; }
1683
1684template<sp_d T> const Col<T>& Factory<T>::get_trial_resistance() const { return trial_resistance; }
1685
1686template<sp_d T> const Col<T>& Factory<T>::get_trial_damping_force() const { return trial_damping_force; }
1687
1688template<sp_d T> const Col<T>& Factory<T>::get_trial_nonviscous_force() const { return trial_nonviscous_force; }
1689
1690template<sp_d T> const Col<T>& Factory<T>::get_trial_inertial_force() const { return trial_inertial_force; }
1691
1692template<sp_d T> const Col<T>& Factory<T>::get_trial_displacement() const { return trial_displacement; }
1693
1694template<sp_d T> const Col<T>& Factory<T>::get_trial_velocity() const { return trial_velocity; }
1695
1696template<sp_d T> const Col<T>& Factory<T>::get_trial_acceleration() const { return trial_acceleration; }
1697
1698template<sp_d T> const Col<T>& Factory<T>::get_trial_temperature() const { return trial_temperature; }
1699
1700template<sp_d T> T Factory<T>::get_incre_time() const { return incre_time; }
1701
1702template<sp_d T> const Col<T>& Factory<T>::get_incre_load_factor() const { return incre_load_factor; }
1703
1704template<sp_d T> const Col<T>& Factory<T>::get_incre_load() const { return incre_load; }
1705
1706template<sp_d T> const Col<T>& Factory<T>::get_incre_settlement() const { return incre_settlement; }
1707
1708template<sp_d T> const Col<T>& Factory<T>::get_incre_resistance() const { return incre_resistance; }
1709
1710template<sp_d T> const Col<T>& Factory<T>::get_incre_damping_force() const { return incre_damping_force; }
1711
1712template<sp_d T> const Col<T>& Factory<T>::get_incre_nonviscous_force() const { return incre_nonviscous_force; }
1713
1714template<sp_d T> const Col<T>& Factory<T>::get_incre_inertial_force() const { return incre_inertial_force; }
1715
1716template<sp_d T> const Col<T>& Factory<T>::get_incre_displacement() const { return incre_displacement; }
1717
1718template<sp_d T> const Col<T>& Factory<T>::get_incre_velocity() const { return incre_velocity; }
1719
1720template<sp_d T> const Col<T>& Factory<T>::get_incre_acceleration() const { return incre_acceleration; }
1721
1722template<sp_d T> const Col<T>& Factory<T>::get_incre_temperature() const { return incre_temperature; }
1723
1724template<sp_d T> T Factory<T>::get_current_time() const { return current_time; }
1725
1726template<sp_d T> const Col<T>& Factory<T>::get_current_load_factor() const { return current_load_factor; }
1727
1728template<sp_d T> const Col<T>& Factory<T>::get_current_load() const { return current_load; }
1729
1730template<sp_d T> const Col<T>& Factory<T>::get_current_settlement() const { return current_settlement; }
1731
1732template<sp_d T> const Col<T>& Factory<T>::get_current_resistance() const { return current_resistance; }
1733
1734template<sp_d T> const Col<T>& Factory<T>::get_current_damping_force() const { return current_damping_force; }
1735
1736template<sp_d T> const Col<T>& Factory<T>::get_current_nonviscous_force() const { return current_nonviscous_force; }
1737
1738template<sp_d T> const Col<T>& Factory<T>::get_current_inertial_force() const { return current_inertial_force; }
1739
1740template<sp_d T> const Col<T>& Factory<T>::get_current_displacement() const { return current_displacement; }
1741
1742template<sp_d T> const Col<T>& Factory<T>::get_current_velocity() const { return current_velocity; }
1743
1744template<sp_d T> const Col<T>& Factory<T>::get_current_acceleration() const { return current_acceleration; }
1745
1746template<sp_d T> const Col<T>& Factory<T>::get_current_temperature() const { return current_temperature; }
1747
1748template<sp_d T> T Factory<T>::get_pre_time() const { return pre_time; }
1749
1750template<sp_d T> const Col<T>& Factory<T>::get_pre_load_factor() const { return pre_load_factor; }
1751
1752template<sp_d T> const Col<T>& Factory<T>::get_pre_load() const { return pre_load; }
1753
1754template<sp_d T> const Col<T>& Factory<T>::get_pre_settlement() const { return pre_settlement; }
1755
1756template<sp_d T> const Col<T>& Factory<T>::get_pre_resistance() const { return pre_resistance; }
1757
1758template<sp_d T> const Col<T>& Factory<T>::get_pre_damping_force() const { return pre_damping_force; }
1759
1760template<sp_d T> const Col<T>& Factory<T>::get_pre_nonviscous_force() const { return pre_nonviscous_force; }
1761
1762template<sp_d T> const Col<T>& Factory<T>::get_pre_inertial_force() const { return pre_inertial_force; }
1763
1764template<sp_d T> const Col<T>& Factory<T>::get_pre_displacement() const { return pre_displacement; }
1765
1766template<sp_d T> const Col<T>& Factory<T>::get_pre_velocity() const { return pre_velocity; }
1767
1768template<sp_d T> const Col<T>& Factory<T>::get_pre_acceleration() const { return pre_acceleration; }
1769
1770template<sp_d T> const Col<T>& Factory<T>::get_pre_temperature() const { return pre_temperature; }
1771
1772template<sp_d T> T& Factory<T>::modify_trial_time() { return trial_time; }
1773
1774template<sp_d T> Col<T>& Factory<T>::modify_trial_load_factor() { return trial_load_factor; }
1775
1776template<sp_d T> Col<T>& Factory<T>::modify_trial_load() { return trial_load; }
1777
1778template<sp_d T> Col<T>& Factory<T>::modify_trial_settlement() { return trial_settlement; }
1779
1780template<sp_d T> Col<T>& Factory<T>::modify_trial_resistance() { return trial_resistance; }
1781
1782template<sp_d T> Col<T>& Factory<T>::modify_trial_damping_force() { return trial_damping_force; }
1783
1784template<sp_d T> Col<T>& Factory<T>::modify_trial_nonviscous_force() { return trial_nonviscous_force; }
1785
1786template<sp_d T> Col<T>& Factory<T>::modify_trial_inertial_force() { return trial_inertial_force; }
1787
1788template<sp_d T> Col<T>& Factory<T>::modify_trial_displacement() { return trial_displacement; }
1789
1790template<sp_d T> Col<T>& Factory<T>::modify_trial_velocity() { return trial_velocity; }
1791
1792template<sp_d T> Col<T>& Factory<T>::modify_trial_acceleration() { return trial_acceleration; }
1793
1794template<sp_d T> Col<T>& Factory<T>::modify_trial_temperature() { return trial_temperature; }
1795
1796template<sp_d T> T& Factory<T>::modify_incre_time() { return incre_time; }
1797
1798template<sp_d T> Col<T>& Factory<T>::modify_incre_load_factor() { return incre_load_factor; }
1799
1800template<sp_d T> Col<T>& Factory<T>::modify_incre_load() { return incre_load; }
1801
1802template<sp_d T> Col<T>& Factory<T>::modify_incre_settlement() { return incre_settlement; }
1803
1804template<sp_d T> Col<T>& Factory<T>::modify_incre_resistance() { return incre_resistance; }
1805
1806template<sp_d T> Col<T>& Factory<T>::modify_incre_damping_force() { return incre_damping_force; }
1807
1808template<sp_d T> Col<T>& Factory<T>::modify_incre_nonviscous_force() { return incre_nonviscous_force; }
1809
1810template<sp_d T> Col<T>& Factory<T>::modify_incre_inertial_force() { return incre_inertial_force; }
1811
1812template<sp_d T> Col<T>& Factory<T>::modify_incre_displacement() { return incre_displacement; }
1813
1814template<sp_d T> Col<T>& Factory<T>::modify_incre_velocity() { return incre_velocity; }
1815
1816template<sp_d T> Col<T>& Factory<T>::modify_incre_acceleration() { return incre_acceleration; }
1817
1818template<sp_d T> Col<T>& Factory<T>::modify_incre_temperature() { return incre_temperature; }
1819
1820template<sp_d T> T& Factory<T>::modify_current_time() { return current_time; }
1821
1822template<sp_d T> Col<T>& Factory<T>::modify_current_load_factor() { return current_load_factor; }
1823
1824template<sp_d T> Col<T>& Factory<T>::modify_current_load() { return current_load; }
1825
1826template<sp_d T> Col<T>& Factory<T>::modify_current_settlement() { return current_settlement; }
1827
1828template<sp_d T> Col<T>& Factory<T>::modify_current_resistance() { return current_resistance; }
1829
1830template<sp_d T> Col<T>& Factory<T>::modify_current_damping_force() { return current_damping_force; }
1831
1832template<sp_d T> Col<T>& Factory<T>::modify_current_nonviscous_force() { return current_nonviscous_force; }
1833
1834template<sp_d T> Col<T>& Factory<T>::modify_current_inertial_force() { return current_inertial_force; }
1835
1836template<sp_d T> Col<T>& Factory<T>::modify_current_displacement() { return current_displacement; }
1837
1838template<sp_d T> Col<T>& Factory<T>::modify_current_velocity() { return current_velocity; }
1839
1840template<sp_d T> Col<T>& Factory<T>::modify_current_acceleration() { return current_acceleration; }
1841
1842template<sp_d T> Col<T>& Factory<T>::modify_current_temperature() { return current_temperature; }
1843
1844template<sp_d T> T& Factory<T>::modify_pre_time() { return pre_time; }
1845
1846template<sp_d T> Col<T>& Factory<T>::modify_pre_load_factor() { return pre_load_factor; }
1847
1848template<sp_d T> Col<T>& Factory<T>::modify_pre_load() { return pre_load; }
1849
1850template<sp_d T> Col<T>& Factory<T>::modify_pre_settlement() { return pre_settlement; }
1851
1852template<sp_d T> Col<T>& Factory<T>::modify_pre_resistance() { return pre_resistance; }
1853
1854template<sp_d T> Col<T>& Factory<T>::modify_pre_damping_force() { return pre_damping_force; }
1855
1856template<sp_d T> Col<T>& Factory<T>::modify_pre_nonviscous_force() { return pre_nonviscous_force; }
1857
1858template<sp_d T> Col<T>& Factory<T>::modify_pre_inertial_force() { return pre_inertial_force; }
1859
1860template<sp_d T> Col<T>& Factory<T>::modify_pre_displacement() { return pre_displacement; }
1861
1862template<sp_d T> Col<T>& Factory<T>::modify_pre_velocity() { return pre_velocity; }
1863
1864template<sp_d T> Col<T>& Factory<T>::modify_pre_acceleration() { return pre_acceleration; }
1865
1866template<sp_d T> Col<T>& Factory<T>::modify_pre_temperature() { return pre_temperature; }
1867
1868template<sp_d T> void Factory<T>::update_trial_time(const T M) {
1869 trial_time = M;
1870 incre_time = trial_time - current_time;
1871}
1872
1873template<sp_d T> void Factory<T>::update_trial_load_factor(const Col<T>& L) {
1874 trial_load_factor = L;
1875 incre_load_factor = trial_load_factor - current_load_factor;
1876}
1877
1878template<sp_d T> void Factory<T>::update_trial_load(const Col<T>& L) {
1879 trial_load = L;
1880 incre_load = trial_load - current_load;
1881}
1882
1883template<sp_d T> void Factory<T>::update_trial_settlement(const Col<T>& S) {
1884 trial_settlement = S;
1885 incre_settlement = trial_settlement - current_settlement;
1886}
1887
1888template<sp_d T> void Factory<T>::update_trial_resistance(const Col<T>& R) {
1889 trial_resistance = R;
1890 incre_resistance = trial_resistance - current_resistance;
1891}
1892
1893template<sp_d T> void Factory<T>::update_trial_damping_force(const Col<T>& R) {
1894 trial_damping_force = R;
1895 incre_damping_force = trial_damping_force - current_damping_force;
1896}
1897
1898template<sp_d T> void Factory<T>::update_trial_nonviscous_force(const Col<T>& R) {
1899 trial_nonviscous_force = R;
1900 incre_nonviscous_force = trial_nonviscous_force - current_nonviscous_force;
1901}
1902
1903template<sp_d T> void Factory<T>::update_trial_inertial_force(const Col<T>& R) {
1904 trial_inertial_force = R;
1905 incre_inertial_force = trial_inertial_force - current_inertial_force;
1906}
1907
1908template<sp_d T> void Factory<T>::update_trial_displacement(const Col<T>& D) {
1909 trial_displacement = D;
1910 incre_displacement = trial_displacement - current_displacement;
1911}
1912
1913template<sp_d T> void Factory<T>::update_trial_velocity(const Col<T>& V) {
1914 trial_velocity = V;
1915 incre_velocity = trial_velocity - current_velocity;
1916}
1917
1918template<sp_d T> void Factory<T>::update_trial_acceleration(const Col<T>& A) {
1919 trial_acceleration = A;
1920 incre_acceleration = trial_acceleration - current_acceleration;
1921}
1922
1923template<sp_d T> void Factory<T>::update_trial_temperature(const Col<T>& M) {
1924 trial_temperature = M;
1925 incre_temperature = trial_temperature - current_temperature;
1926}
1927
1928template<sp_d T> void Factory<T>::update_incre_time(const T M) {
1929 incre_time = M;
1930 trial_time = current_time + incre_time;
1931}
1932
1933template<sp_d T> void Factory<T>::update_incre_load_factor(const Col<T>& L) {
1934 incre_load_factor = L;
1935 trial_load_factor = current_load_factor + incre_load_factor;
1936}
1937
1938template<sp_d T> void Factory<T>::update_incre_load(const Col<T>& L) {
1939 incre_load = L;
1940 trial_load = current_load + incre_load;
1941}
1942
1943template<sp_d T> void Factory<T>::update_incre_settlement(const Col<T>& S) {
1944 incre_settlement = S;
1945 trial_settlement = current_settlement + incre_settlement;
1946}
1947
1948template<sp_d T> void Factory<T>::update_incre_resistance(const Col<T>& R) {
1949 incre_resistance = R;
1950 trial_resistance = current_resistance + incre_resistance;
1951}
1952
1953template<sp_d T> void Factory<T>::update_incre_damping_force(const Col<T>& R) {
1954 incre_damping_force = R;
1955 trial_damping_force = current_damping_force + incre_damping_force;
1956}
1957
1958template<sp_d T> void Factory<T>::update_incre_nonviscous_force(const Col<T>& R) {
1959 incre_nonviscous_force = R;
1960 trial_nonviscous_force = current_nonviscous_force + incre_nonviscous_force;
1961}
1962
1963template<sp_d T> void Factory<T>::update_incre_inertial_force(const Col<T>& R) {
1964 incre_inertial_force = R;
1965 trial_inertial_force = current_inertial_force + incre_inertial_force;
1966}
1967
1968template<sp_d T> void Factory<T>::update_incre_displacement(const Col<T>& D) {
1969 incre_displacement = D;
1970 trial_displacement = current_displacement + incre_displacement;
1971}
1972
1973template<sp_d T> void Factory<T>::update_incre_velocity(const Col<T>& V) {
1974 incre_velocity = V;
1975 trial_velocity = current_velocity + incre_velocity;
1976}
1977
1978template<sp_d T> void Factory<T>::update_incre_acceleration(const Col<T>& A) {
1979 incre_acceleration = A;
1980 trial_acceleration = current_acceleration + incre_acceleration;
1981}
1982
1983template<sp_d T> void Factory<T>::update_incre_temperature(const Col<T>& M) {
1984 incre_temperature = M;
1985 trial_temperature = current_temperature + incre_temperature;
1986}
1987
1988template<sp_d T> void Factory<T>::update_current_time(const T M) {
1989 trial_time = current_time = M;
1990 incre_time = T(0);
1991}
1992
1993template<sp_d T> void Factory<T>::update_current_load_factor(const Col<T>& L) {
1994 trial_load_factor = current_load_factor = L;
1995 incre_load_factor.zeros();
1996}
1997
1998template<sp_d T> void Factory<T>::update_current_load(const Col<T>& L) {
1999 trial_load = current_load = L;
2000 incre_load.zeros();
2001}
2002
2003template<sp_d T> void Factory<T>::update_current_settlement(const Col<T>& S) {
2004 trial_settlement = current_settlement = S;
2005 incre_settlement.zeros();
2006}
2007
2008template<sp_d T> void Factory<T>::update_current_resistance(const Col<T>& R) {
2009 trial_resistance = current_resistance = R;
2010 incre_resistance.zeros();
2011}
2012
2013template<sp_d T> void Factory<T>::update_current_damping_force(const Col<T>& R) {
2014 trial_damping_force = current_damping_force = R;
2015 incre_damping_force.zeros();
2016}
2017
2018template<sp_d T> void Factory<T>::update_current_nonviscous_force(const Col<T>& R) {
2019 trial_nonviscous_force = current_nonviscous_force = R;
2020 incre_nonviscous_force.zeros();
2021}
2022
2023template<sp_d T> void Factory<T>::update_current_inertial_force(const Col<T>& R) {
2024 trial_inertial_force = current_inertial_force = R;
2025 incre_inertial_force.zeros();
2026}
2027
2028template<sp_d T> void Factory<T>::update_current_displacement(const Col<T>& D) {
2029 trial_displacement = current_displacement = D;
2030 incre_displacement.zeros();
2031}
2032
2033template<sp_d T> void Factory<T>::update_current_velocity(const Col<T>& V) {
2034 trial_velocity = current_velocity = V;
2035 incre_velocity.zeros();
2036}
2037
2038template<sp_d T> void Factory<T>::update_current_acceleration(const Col<T>& A) {
2039 trial_acceleration = current_acceleration = A;
2040 incre_acceleration.zeros();
2041}
2042
2043template<sp_d T> void Factory<T>::update_current_temperature(const Col<T>& M) {
2044 trial_temperature = current_temperature = M;
2045 incre_temperature.zeros();
2046}
2047
2048template<sp_d T> void Factory<T>::update_trial_time_by(const T M) {
2049 trial_time += M;
2050 incre_time = trial_time - current_time;
2051}
2052
2053template<sp_d T> void Factory<T>::update_trial_load_factor_by(const Col<T>& L) {
2054 trial_load_factor += L;
2055 incre_load_factor = trial_load_factor - current_load_factor;
2056}
2057
2058template<sp_d T> void Factory<T>::update_trial_load_by(const Col<T>& L) {
2059 trial_load += L;
2060 incre_load = trial_load - current_load;
2061}
2062
2063template<sp_d T> void Factory<T>::update_trial_settlement_by(const Col<T>& S) {
2064 trial_settlement += S;
2065 incre_settlement = trial_settlement - current_settlement;
2066}
2067
2068template<sp_d T> void Factory<T>::update_trial_resistance_by(const Col<T>& R) {
2069 trial_resistance += R;
2070 incre_resistance = trial_resistance - current_resistance;
2071}
2072
2073template<sp_d T> void Factory<T>::update_trial_damping_force_by(const Col<T>& R) {
2074 trial_damping_force += R;
2075 incre_damping_force = trial_damping_force - current_damping_force;
2076}
2077
2078template<sp_d T> void Factory<T>::update_trial_nonviscous_force_by(const Col<T>& R) {
2079 trial_nonviscous_force += R;
2080 incre_nonviscous_force = trial_nonviscous_force - current_nonviscous_force;
2081}
2082
2083template<sp_d T> void Factory<T>::update_trial_inertial_force_by(const Col<T>& R) {
2084 trial_inertial_force += R;
2085 incre_inertial_force = trial_inertial_force - current_inertial_force;
2086}
2087
2088template<sp_d T> void Factory<T>::update_trial_displacement_by(const Col<T>& D) {
2089 trial_displacement += D;
2090 incre_displacement = trial_displacement - current_displacement;
2091}
2092
2093template<sp_d T> void Factory<T>::update_trial_velocity_by(const Col<T>& V) {
2094 trial_velocity += V;
2095 incre_velocity = trial_velocity - current_velocity;
2096}
2097
2098template<sp_d T> void Factory<T>::update_trial_acceleration_by(const Col<T>& A) {
2099 trial_acceleration += A;
2100 incre_acceleration = trial_acceleration - current_acceleration;
2101}
2102
2103template<sp_d T> void Factory<T>::update_trial_temperature_by(const Col<T>& M) {
2104 trial_temperature += M;
2105 incre_temperature = trial_temperature - current_temperature;
2106}
2107
2108template<sp_d T> void Factory<T>::update_incre_time_by(const T M) {
2109 incre_time += M;
2110 trial_time = current_time + incre_time;
2111}
2112
2113template<sp_d T> void Factory<T>::update_incre_load_factor_by(const Col<T>& L) {
2114 incre_load_factor += L;
2115 trial_load_factor = current_load_factor + incre_load_factor;
2116}
2117
2118template<sp_d T> void Factory<T>::update_incre_load_by(const Col<T>& L) {
2119 incre_load += L;
2120 trial_load = current_load + incre_load;
2121}
2122
2123template<sp_d T> void Factory<T>::update_incre_settlement_by(const Col<T>& S) {
2124 incre_settlement += S;
2125 trial_settlement = current_settlement + incre_settlement;
2126}
2127
2128template<sp_d T> void Factory<T>::update_incre_resistance_by(const Col<T>& R) {
2129 incre_resistance += R;
2130 trial_resistance = current_resistance + incre_resistance;
2131}
2132
2133template<sp_d T> void Factory<T>::update_incre_damping_force_by(const Col<T>& R) {
2134 incre_damping_force += R;
2135 trial_damping_force = current_damping_force + incre_damping_force;
2136}
2137
2138template<sp_d T> void Factory<T>::update_incre_nonviscous_force_by(const Col<T>& R) {
2139 incre_nonviscous_force += R;
2140 trial_nonviscous_force = current_nonviscous_force + incre_nonviscous_force;
2141}
2142
2143template<sp_d T> void Factory<T>::update_incre_inertial_force_by(const Col<T>& R) {
2144 incre_inertial_force += R;
2145 trial_inertial_force = current_inertial_force + incre_inertial_force;
2146}
2147
2148template<sp_d T> void Factory<T>::update_incre_displacement_by(const Col<T>& D) {
2149 incre_displacement += D;
2150 trial_displacement = current_displacement + incre_displacement;
2151}
2152
2153template<sp_d T> void Factory<T>::update_incre_velocity_by(const Col<T>& V) {
2154 incre_velocity += V;
2155 trial_velocity = current_velocity + incre_velocity;
2156}
2157
2158template<sp_d T> void Factory<T>::update_incre_acceleration_by(const Col<T>& A) {
2159 incre_acceleration += A;
2160 trial_acceleration = current_acceleration + incre_acceleration;
2161}
2162
2163template<sp_d T> void Factory<T>::update_incre_temperature_by(const Col<T>& M) {
2164 incre_temperature += M;
2165 trial_temperature = current_temperature + incre_temperature;
2166}
2167
2168template<sp_d T> void Factory<T>::update_current_time_by(const T M) {
2169 trial_time = current_time += M;
2170 incre_time = 0.;
2171}
2172
2173template<sp_d T> void Factory<T>::update_current_load_factor_by(const Col<T>& L) {
2174 trial_load_factor = current_load_factor += L;
2175 incre_load_factor.zeros();
2176}
2177
2178template<sp_d T> void Factory<T>::update_current_load_by(const Col<T>& L) {
2179 trial_load = current_load += L;
2180 incre_load.zeros();
2181}
2182
2183template<sp_d T> void Factory<T>::update_current_settlement_by(const Col<T>& S) {
2184 trial_settlement = current_settlement += S;
2185 incre_settlement.zeros();
2186}
2187
2188template<sp_d T> void Factory<T>::update_current_resistance_by(const Col<T>& R) {
2189 trial_resistance = current_resistance += R;
2190 incre_resistance.zeros();
2191}
2192
2193template<sp_d T> void Factory<T>::update_current_damping_force_by(const Col<T>& R) {
2194 trial_damping_force = current_damping_force += R;
2195 incre_damping_force.zeros();
2196}
2197
2198template<sp_d T> void Factory<T>::update_current_nonviscous_force_by(const Col<T>& R) {
2199 trial_nonviscous_force = current_nonviscous_force += R;
2200 incre_nonviscous_force.zeros();
2201}
2202
2203template<sp_d T> void Factory<T>::update_current_inertial_force_by(const Col<T>& R) {
2204 trial_inertial_force = current_inertial_force += R;
2205 incre_inertial_force.zeros();
2206}
2207
2208template<sp_d T> void Factory<T>::update_current_displacement_by(const Col<T>& D) {
2209 trial_displacement = current_displacement += D;
2210 incre_displacement.zeros();
2211}
2212
2213template<sp_d T> void Factory<T>::update_current_velocity_by(const Col<T>& V) {
2214 trial_velocity = current_velocity += V;
2215 incre_velocity.zeros();
2216}
2217
2218template<sp_d T> void Factory<T>::update_current_acceleration_by(const Col<T>& A) {
2219 trial_acceleration = current_acceleration += A;
2220 incre_acceleration.zeros();
2221}
2222
2223template<sp_d T> void Factory<T>::update_current_temperature_by(const Col<T>& M) {
2224 trial_temperature = current_temperature += M;
2225 incre_temperature.zeros();
2226}
2227
2228#endif // FACTORY_HPP
2229
reset
void reset(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
MetaMat
A MetaMat class that holds matrices.
Definition MetaMat.hpp:74
SparseMatCUDA
A SparseMatCUDA class that holds matrices.
Definition SparseMatCUDA.hpp:41
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:255
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:86
SparseSymmMatPARDISO
SparseMatBasePARDISO< T, -2 > SparseSymmMatPARDISO
Definition SparseMatPARDISO.hpp:132
DOF::T
@ T
Factory::set_pre_inertial_force
void set_pre_inertial_force(const Col< T > &)
Definition Factory.hpp:1666
Factory::modify_trial_time
T & modify_trial_time()
Definition Factory.hpp:1772
Factory::set_eigenvalue
void set_eigenvalue(const Col< T > &)
Definition Factory.hpp:953
Factory::clear_acceleration
void clear_acceleration()
Definition Factory.hpp:1278
Factory::initialize_load
void initialize_load()
Definition Factory.hpp:839
Factory::set_mpc
void set_mpc(unsigned)
Definition Factory.hpp:933
Factory::modify_stiffness
shared_ptr< MetaMat< T > > & modify_stiffness()
Definition Factory.hpp:1550
Factory::modify_trial_inertial_force
Col< T > & modify_trial_inertial_force()
Definition Factory.hpp:1786
Factory::modify_trial_nonviscous_force
Col< T > & modify_trial_nonviscous_force()
Definition Factory.hpp:1784
Factory::commit_temperature
void commit_temperature()
Definition Factory.hpp:1141
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:2018
Factory::set_incre_velocity
void set_incre_velocity(const Col< T > &)
Definition Factory.hpp:1622
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:1626
Factory::assemble_stiffness
void assemble_stiffness(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition Factory.hpp:1455
Factory::print
void print() const
Definition Factory.hpp:1464
Factory::clear_resistance
void clear_resistance()
Definition Factory.hpp:1236
Factory::initialize_auxiliary_resistance
void initialize_auxiliary_resistance()
Definition Factory.hpp:899
Factory::clear_load_factor
void clear_load_factor()
Definition Factory.hpp:1215
Factory::set_incre_acceleration
void set_incre_acceleration(const Col< T > &)
Definition Factory.hpp:1624
Factory::initialize
int initialize()
Definition Factory.hpp:776
Factory::modify_incre_load
Col< T > & modify_incre_load()
Definition Factory.hpp:1800
Factory::get_current_acceleration
const Col< T > & get_current_acceleration() const
Definition Factory.hpp:1744
Factory::update_incre_damping_force_by
void update_incre_damping_force_by(const Col< T > &)
Definition Factory.hpp:2133
Factory::get_pre_damping_force
const Col< T > & get_pre_damping_force() const
Definition Factory.hpp:1758
Factory::reset_displacement
void reset_displacement()
Definition Factory.hpp:1362
Factory::update_incre_temperature_by
void update_incre_temperature_by(const Col< T > &)
Definition Factory.hpp:2163
Factory::set_ninja
void set_ninja(const Col< T > &)
Definition Factory.hpp:927
Factory::modify_trial_damping_force
Col< T > & modify_trial_damping_force()
Definition Factory.hpp:1782
Factory::update_trial_temperature_by
void update_trial_temperature_by(const Col< T > &)
Definition Factory.hpp:2103
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:2113
Factory::get_eigenvector
const Mat< T > & get_eigenvector() const
Definition Factory.hpp:1029
Factory::get_trial_velocity
const Col< T > & get_trial_velocity() const
Definition Factory.hpp:1694
Factory::get_trial_resistance
const Col< T > & get_trial_resistance() const
Definition Factory.hpp:1684
Factory::update_trial_load_factor_by
void update_trial_load_factor_by(const Col< T > &)
Definition Factory.hpp:2053
Factory::get_ninja
const Col< T > & get_ninja() const
Definition Factory.hpp:957
Factory::modify_trial_temperature
Col< T > & modify_trial_temperature()
Definition Factory.hpp:1794
Factory::set_pre_velocity
void set_pre_velocity(const Col< T > &)
Definition Factory.hpp:1670
Factory::get_current_load
const Col< T > & get_current_load() const
Definition Factory.hpp:1728
Factory::set_trial_settlement
void set_trial_settlement(const Col< T > &)
Definition Factory.hpp:1586
Factory::set_incre_load_factor
void set_incre_load_factor(const Col< T > &)
Definition Factory.hpp:1606
Factory::set_trial_time
void set_trial_time(T)
Definition Factory.hpp:1580
Factory::modify_incre_resistance
Col< T > & modify_incre_resistance()
Definition Factory.hpp:1804
Factory::update_incre_load_by
void update_incre_load_by(const Col< T > &)
Definition Factory.hpp:2118
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:1752
Factory::commit_acceleration
void commit_acceleration()
Definition Factory.hpp:1135
Factory::get_analysis_type
AnalysisType get_analysis_type() const
Definition Factory.hpp:735
Factory::clear_nonviscous
void clear_nonviscous()
Definition Factory.hpp:1400
Factory::set_current_resistance
void set_current_resistance(const Col< T > &)
Definition Factory.hpp:1636
Factory::update_incre_displacement
void update_incre_displacement(const Col< T > &)
Definition Factory.hpp:1968
Factory::set_incre_displacement
void set_incre_displacement(const Col< T > &)
Definition Factory.hpp:1620
Factory::update_current_acceleration_by
void update_current_acceleration_by(const Col< T > &)
Definition Factory.hpp:2218
Factory::get_auxiliary_encoding
const uvec & get_auxiliary_encoding() const
Definition Factory.hpp:965
Factory::reset_auxiliary_resistance
void reset_auxiliary_resistance()
Definition Factory.hpp:1386
Factory::modify_pre_displacement
Col< T > & modify_pre_displacement()
Definition Factory.hpp:1860
Factory::commit_resistance
void commit_resistance()
Definition Factory.hpp:1099
Factory::get_incre_inertial_force
const Col< T > & get_incre_inertial_force() const
Definition Factory.hpp:1714
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:2078
Factory::initialize_damping
void initialize_damping()
Definition Factory.hpp:906
Factory::update_incre_velocity
void update_incre_velocity(const Col< T > &)
Definition Factory.hpp:1973
Factory::modify_incre_acceleration
Col< T > & modify_incre_acceleration()
Definition Factory.hpp:1816
Factory::initialize_geometry
void initialize_geometry()
Definition Factory.hpp:916
Factory::update_incre_displacement_by
void update_incre_displacement_by(const Col< T > &)
Definition Factory.hpp:2148
Factory::update_current_damping_force_by
void update_current_damping_force_by(const Col< T > &)
Definition Factory.hpp:2193
Factory::assemble_mass
void assemble_mass(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition Factory.hpp:1449
Factory::set_trial_velocity
void set_trial_velocity(const Col< T > &)
Definition Factory.hpp:1598
Factory::update_current_resistance
void update_current_resistance(const Col< T > &)
Definition Factory.hpp:2008
Factory::clear_inertial_force
void clear_inertial_force()
Definition Factory.hpp:1257
Factory::modify_ninja
Col< T > & modify_ninja()
Definition Factory.hpp:1554
Factory::set_pre_nonviscous_force
void set_pre_nonviscous_force(const Col< T > &)
Definition Factory.hpp:1664
Factory::update_trial_damping_force_by
void update_trial_damping_force_by(const Col< T > &)
Definition Factory.hpp:2073
Factory::get_mpc
unsigned get_mpc() const
Definition Factory.hpp:961
Factory::modify_eigenvalue
Col< T > & modify_eigenvalue()
Definition Factory.hpp:1576
Factory::get_current_settlement
const Col< T > & get_current_settlement() const
Definition Factory.hpp:1730
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:1081
Factory::get_damping_mutex
std::mutex & get_damping_mutex()
Definition Factory.hpp:1019
Factory::update_trial_velocity_by
void update_trial_velocity_by(const Col< T > &)
Definition Factory.hpp:2093
Factory::update_current_load_by
void update_current_load_by(const Col< T > &)
Definition Factory.hpp:2178
Factory::modify_trial_constraint_resistance
SpCol< T > & modify_trial_constraint_resistance()
Definition Factory.hpp:1572
Factory::get_damping
const shared_ptr< MetaMat< T > > & get_damping() const
Definition Factory.hpp:993
Factory::set_pre_settlement
void set_pre_settlement(const Col< T > &)
Definition Factory.hpp:1658
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:1117
Factory::update_current_time
void update_current_time(T)
Definition Factory.hpp:1988
Factory::initialize_resistance
void initialize_resistance()
Definition Factory.hpp:851
Factory::get_current_damping_force
const Col< T > & get_current_damping_force() const
Definition Factory.hpp:1734
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:2088
Factory::set_mass
void set_mass(const shared_ptr< MetaMat< T > > &)
Definition Factory.hpp:943
Factory::reset_velocity
void reset_velocity()
Definition Factory.hpp:1368
Factory::get_nonviscous
const shared_ptr< MetaMat< T > > & get_nonviscous() const
Definition Factory.hpp:995
Factory::get_trial_load_factor
const Col< T > & get_trial_load_factor() const
Definition Factory.hpp:1678
Factory::set_current_load
void set_current_load(const Col< T > &)
Definition Factory.hpp:1632
Factory::get_trial_load_mutex
std::mutex & get_trial_load_mutex()
Definition Factory.hpp:1011
Factory::initialize_stiffness
void initialize_stiffness()
Definition Factory.hpp:914
Factory::initialize_damping_force
void initialize_damping_force()
Definition Factory.hpp:857
Factory::get_current_time
T get_current_time() const
Definition Factory.hpp:1724
Factory::get_pre_settlement
const Col< T > & get_pre_settlement() const
Definition Factory.hpp:1754
Factory::update_trial_temperature
void update_trial_temperature(const Col< T > &)
Definition Factory.hpp:1923
Factory::commit_velocity
void commit_velocity()
Definition Factory.hpp:1129
Factory::set_pre_time
void set_pre_time(T)
Definition Factory.hpp:1652
Factory::get_complementary_energy
T get_complementary_energy()
Definition Factory.hpp:987
Factory::reset
void reset()
Definition Factory.hpp:1414
Factory::get_incre_displacement
const Col< T > & get_incre_displacement() const
Definition Factory.hpp:1716
Factory::set_current_damping_force
void set_current_damping_force(const Col< T > &)
Definition Factory.hpp:1638
Factory::modify_current_nonviscous_force
Col< T > & modify_current_nonviscous_force()
Definition Factory.hpp:1832
Factory::update_trial_acceleration
void update_trial_acceleration(const Col< T > &)
Definition Factory.hpp:1918
Factory::set_current_time
void set_current_time(T)
Definition Factory.hpp:1628
Factory::get_auxiliary_load
const Col< T > & get_auxiliary_load() const
Definition Factory.hpp:971
Factory::commit_pre_settlement
void commit_pre_settlement()
Definition Factory.hpp:1173
Factory::modify_pre_settlement
Col< T > & modify_pre_settlement()
Definition Factory.hpp:1850
Factory::get_mass
const shared_ptr< MetaMat< T > > & get_mass() const
Definition Factory.hpp:991
Factory::commit_status
void commit_status()
Definition Factory.hpp:1056
Factory::commit_pre_load_factor
void commit_pre_load_factor()
Definition Factory.hpp:1169
Factory::get_reference_dof
const suanpan::set< uword > & get_reference_dof() const
Definition Factory.hpp:770
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:1604
Factory::modify_damping
shared_ptr< MetaMat< T > > & modify_damping()
Definition Factory.hpp:1546
Factory::modify_pre_velocity
Col< T > & modify_pre_velocity()
Definition Factory.hpp:1862
Factory::get_reference_load_mutex
std::mutex & get_reference_load_mutex()
Definition Factory.hpp:1015
Factory::assemble_damping
void assemble_damping(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition Factory.hpp:1451
Factory::update_incre_nonviscous_force
void update_incre_nonviscous_force(const Col< T > &)
Definition Factory.hpp:1958
Factory::update_trial_inertial_force
void update_trial_inertial_force(const Col< T > &)
Definition Factory.hpp:1903
Factory::set_current_velocity
void set_current_velocity(const Col< T > &)
Definition Factory.hpp:1646
Factory::commit_displacement
void commit_displacement()
Definition Factory.hpp:1123
Factory::update_current_velocity_by
void update_current_velocity_by(const Col< T > &)
Definition Factory.hpp:2213
Factory::get_incre_damping_force
const Col< T > & get_incre_damping_force() const
Definition Factory.hpp:1710
Factory::update_trial_load_factor
void update_trial_load_factor(const Col< T > &)
Definition Factory.hpp:1873
Factory::reset_load_factor
void reset_load_factor()
Definition Factory.hpp:1320
Factory::clear_velocity
void clear_velocity()
Definition Factory.hpp:1271
Factory::update_current_load
void update_current_load(const Col< T > &)
Definition Factory.hpp:1998
Factory::update_incre_time
void update_incre_time(T)
Definition Factory.hpp:1928
Factory::update_incre_settlement_by
void update_incre_settlement_by(const Col< T > &)
Definition Factory.hpp:2123
Factory::get_reference_size
unsigned get_reference_size() const
Definition Factory.hpp:764
Factory::update_current_acceleration
void update_current_acceleration(const Col< T > &)
Definition Factory.hpp:2038
StorageScheme
StorageScheme
Definition Factory.hpp:48
Factory::commit_pre_temperature
void commit_pre_temperature()
Definition Factory.hpp:1189
Factory::commit_pre_status
void commit_pre_status()
Definition Factory.hpp:1152
Factory::update_current_time_by
void update_current_time_by(T)
Definition Factory.hpp:2168
Factory::modify_reference_dof
suanpan::set< uword > & modify_reference_dof()
Definition Factory.hpp:1558
Factory::set_trial_acceleration
void set_trial_acceleration(const Col< T > &)
Definition Factory.hpp:1600
Factory::update_trial_damping_force
void update_trial_damping_force(const Col< T > &)
Definition Factory.hpp:1893
Factory::get_incre_settlement
const Col< T > & get_incre_settlement() const
Definition Factory.hpp:1706
Factory::reset_inertial_force
void reset_inertial_force()
Definition Factory.hpp:1356
Factory::set_reference_dof
void set_reference_dof(const suanpan::set< uword > &)
Definition Factory.hpp:768
Factory::get_momentum
const Col< T > & get_momentum()
Definition Factory.hpp:989
Factory::update_current_displacement
void update_current_displacement(const Col< T > &)
Definition Factory.hpp:2028
Factory::clear_settlement
void clear_settlement()
Definition Factory.hpp:1229
Factory::set_pre_load
void set_pre_load(const Col< T > &)
Definition Factory.hpp:1656
Factory::get_auxiliary_stiffness_mutex
std::mutex & get_auxiliary_stiffness_mutex()
Definition Factory.hpp:1007
Factory::get_incre_time
T get_incre_time() const
Definition Factory.hpp:1700
Factory::commit_pre_damping_force
void commit_pre_damping_force()
Definition Factory.hpp:1177
Factory::modify_current_inertial_force
Col< T > & modify_current_inertial_force()
Definition Factory.hpp:1834
Factory::get_current_nonviscous_force
const Col< T > & get_current_nonviscous_force() const
Definition Factory.hpp:1736
Factory::get_strain_energy
T get_strain_energy()
Definition Factory.hpp:979
Factory::commit_pre_inertial_force
void commit_pre_inertial_force()
Definition Factory.hpp:1181
Factory::update_trial_settlement
void update_trial_settlement(const Col< T > &)
Definition Factory.hpp:1883
Factory::set_trial_inertial_force
void set_trial_inertial_force(const Col< T > &)
Definition Factory.hpp:1594
Factory::get_eigenvalue
const Col< T > & get_eigenvalue() const
Definition Factory.hpp:1027
Factory::commit_pre_displacement
void commit_pre_displacement()
Definition Factory.hpp:1183
Factory::get_geometry_mutex
std::mutex & get_geometry_mutex()
Definition Factory.hpp:1025
Factory::set_incre_nonviscous_force
void set_incre_nonviscous_force(const Col< T > &)
Definition Factory.hpp:1616
Factory::commit_pre_acceleration
void commit_pre_acceleration()
Definition Factory.hpp:1187
Factory::get_incre_velocity
const Col< T > & get_incre_velocity() const
Definition Factory.hpp:1718
Factory::modify_current_settlement
Col< T > & modify_current_settlement()
Definition Factory.hpp:1826
Factory::get_trial_time
T get_trial_time() const
Definition Factory.hpp:1676
Factory::update_current_temperature_by
void update_current_temperature_by(const Col< T > &)
Definition Factory.hpp:2223
Factory::set_geometry
void set_geometry(const shared_ptr< MetaMat< T > > &)
Definition Factory.hpp:951
Factory::set_incre_load
void set_incre_load(const Col< T > &)
Definition Factory.hpp:1608
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:1672
Factory::set_incre_inertial_force
void set_incre_inertial_force(const Col< T > &)
Definition Factory.hpp:1618
Factory::get_trial_nonviscous_force
const Col< T > & get_trial_nonviscous_force() const
Definition Factory.hpp:1688
Factory::get_kinetic_energy
T get_kinetic_energy()
Definition Factory.hpp:981
Factory::set_current_settlement
void set_current_settlement(const Col< T > &)
Definition Factory.hpp:1634
Factory::update_trial_settlement_by
void update_trial_settlement_by(const Col< T > &)
Definition Factory.hpp:2063
Factory::initialize_inertial_force
void initialize_inertial_force()
Definition Factory.hpp:869
Factory::set_pre_resistance
void set_pre_resistance(const Col< T > &)
Definition Factory.hpp:1660
Factory::commit_load
void commit_load()
Definition Factory.hpp:1087
Factory::update_current_nonviscous_force_by
void update_current_nonviscous_force_by(const Col< T > &)
Definition Factory.hpp:2198
Factory::update_trial_acceleration_by
void update_trial_acceleration_by(const Col< T > &)
Definition Factory.hpp:2098
Factory::get_pre_acceleration
const Col< T > & get_pre_acceleration() const
Definition Factory.hpp:1768
Factory::update_incre_acceleration_by
void update_incre_acceleration_by(const Col< T > &)
Definition Factory.hpp:2158
Factory::commit_pre_nonviscous_force
void commit_pre_nonviscous_force()
Definition Factory.hpp:1179
Factory::commit_pre_load
void commit_pre_load()
Definition Factory.hpp:1171
Factory::commit_pre_velocity
void commit_pre_velocity()
Definition Factory.hpp:1185
Factory::update_trial_resistance_by
void update_trial_resistance_by(const Col< T > &)
Definition Factory.hpp:2068
Factory::modify_current_resistance
Col< T > & modify_current_resistance()
Definition Factory.hpp:1828
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:1167
Factory::modify_geometry
shared_ptr< MetaMat< T > > & modify_geometry()
Definition Factory.hpp:1552
Factory::commit_auxiliary_resistance
void commit_auxiliary_resistance()
Definition Factory.hpp:1147
Factory::update_current_settlement
void update_current_settlement(const Col< T > &)
Definition Factory.hpp:2003
Factory::update_trial_load
void update_trial_load(const Col< T > &)
Definition Factory.hpp:1878
Factory::modify_pre_nonviscous_force
Col< T > & modify_pre_nonviscous_force()
Definition Factory.hpp:1856
Factory::update_incre_load
void update_incre_load(const Col< T > &)
Definition Factory.hpp:1938
Factory::update_trial_time
void update_trial_time(T)
Definition Factory.hpp:1868
Factory::clear_nonviscous_force
void clear_nonviscous_force()
Definition Factory.hpp:1250
Factory::get_stiffness
const shared_ptr< MetaMat< T > > & get_stiffness() const
Definition Factory.hpp:997
Factory::commit_settlement
void commit_settlement()
Definition Factory.hpp:1093
Factory::set_trial_nonviscous_force
void set_trial_nonviscous_force(const Col< T > &)
Definition Factory.hpp:1592
Factory::get_auxiliary_lambda
const Col< T > & get_auxiliary_lambda() const
Definition Factory.hpp:967
Factory::reset_load
void reset_load()
Definition Factory.hpp:1326
Factory::reset_damping_force
void reset_damping_force()
Definition Factory.hpp:1344
Factory::update_current_inertial_force_by
void update_current_inertial_force_by(const Col< T > &)
Definition Factory.hpp:2203
Factory::set_trial_temperature
void set_trial_temperature(const Col< T > &)
Definition Factory.hpp:1602
Factory::get_auxiliary_encoding_mutex
std::mutex & get_auxiliary_encoding_mutex()
Definition Factory.hpp:1001
Factory::modify_trial_load
Col< T > & modify_trial_load()
Definition Factory.hpp:1776
SolverType
SolverType
Definition Factory.hpp:57
Factory::assemble_damping_force
void assemble_damping_force(const Mat< T > &, const uvec &)
Definition Factory.hpp:1427
Factory::set_current_nonviscous_force
void set_current_nonviscous_force(const Col< T > &)
Definition Factory.hpp:1640
Factory::get_pre_displacement
const Col< T > & get_pre_displacement() const
Definition Factory.hpp:1764
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:1738
Factory::get_mass_mutex
std::mutex & get_mass_mutex()
Definition Factory.hpp:1017
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:1750
Factory::modify_current_acceleration
Col< T > & modify_current_acceleration()
Definition Factory.hpp:1840
Factory::get_trial_displacement
const Col< T > & get_trial_displacement() const
Definition Factory.hpp:1692
Factory::update_trial_velocity
void update_trial_velocity(const Col< T > &)
Definition Factory.hpp:1913
Factory::update_current_temperature
void update_current_temperature(const Col< T > &)
Definition Factory.hpp:2043
Factory::reset_temperature
void reset_temperature()
Definition Factory.hpp:1380
Factory::get_auxiliary_resistance_mutex
std::mutex & get_auxiliary_resistance_mutex()
Definition Factory.hpp:1003
Factory::set_current_acceleration
void set_current_acceleration(const Col< T > &)
Definition Factory.hpp:1648
Factory::get_nonviscous_energy
T get_nonviscous_energy()
Definition Factory.hpp:985
Factory::update_current_settlement_by
void update_current_settlement_by(const Col< T > &)
Definition Factory.hpp:2183
Factory::initialize_settlement
void initialize_settlement()
Definition Factory.hpp:845
Factory::clear_damping
void clear_damping()
Definition Factory.hpp:1398
Factory::get_incre_nonviscous_force
const Col< T > & get_incre_nonviscous_force() const
Definition Factory.hpp:1712
Factory::get_incre_load_factor
const Col< T > & get_incre_load_factor() const
Definition Factory.hpp:1702
Factory::clear_energy
void clear_energy()
Definition Factory.hpp:1047
Factory::get_reference_load
const SpMat< T > & get_reference_load() const
Definition Factory.hpp:963
Factory::initialize_displacement
void initialize_displacement()
Definition Factory.hpp:875
Factory::modify_auxiliary_load
Col< T > & modify_auxiliary_load()
Definition Factory.hpp:1568
Factory::reset_time
void reset_time()
Definition Factory.hpp:1315
Factory::get_current_displacement
const Col< T > & get_current_displacement() const
Definition Factory.hpp:1740
Factory::modify_current_velocity
Col< T > & modify_current_velocity()
Definition Factory.hpp:1838
Factory::get_size
unsigned get_size() const
Definition Factory.hpp:692
Factory::modify_current_time
T & modify_current_time()
Definition Factory.hpp:1820
Factory::reset_settlement
void reset_settlement()
Definition Factory.hpp:1332
Factory::clear_damping_force
void clear_damping_force()
Definition Factory.hpp:1243
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:1704
Factory::initialize_nonviscous_force
void initialize_nonviscous_force()
Definition Factory.hpp:863
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:1854
Factory::get_incre_acceleration
const Col< T > & get_incre_acceleration() const
Definition Factory.hpp:1720
Factory::get_pre_time
T get_pre_time() const
Definition Factory.hpp:1748
Factory::clear_geometry
void clear_geometry()
Definition Factory.hpp:1404
Factory::get_viscous_energy
T get_viscous_energy()
Definition Factory.hpp:983
Factory::get_trial_constraint_resistance_mutex
std::mutex & get_trial_constraint_resistance_mutex()
Definition Factory.hpp:1009
Factory::get_current_temperature
const Col< T > & get_current_temperature() const
Definition Factory.hpp:1746
Factory::update_incre_time_by
void update_incre_time_by(T)
Definition Factory.hpp:2108
Factory::assemble_nonviscous
void assemble_nonviscous(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition Factory.hpp:1453
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:1778
Factory::initialize_temperature
void initialize_temperature()
Definition Factory.hpp:893
Factory::set_current_displacement
void set_current_displacement(const Col< T > &)
Definition Factory.hpp:1644
Factory::update_reference_dof
void update_reference_dof(const uvec &)
Definition Factory.hpp:766
Factory::get_trial_inertial_force
const Col< T > & get_trial_inertial_force() const
Definition Factory.hpp:1690
Factory::set_current_inertial_force
void set_current_inertial_force(const Col< T > &)
Definition Factory.hpp:1642
Factory::modify_current_constraint_resistance
SpCol< T > & modify_current_constraint_resistance()
Definition Factory.hpp:1574
Factory::modify_incre_load_factor
Col< T > & modify_incre_load_factor()
Definition Factory.hpp:1798
Factory::set_trial_load
void set_trial_load(const Col< T > &)
Definition Factory.hpp:1584
Factory::modify_auxiliary_resistance
Col< T > & modify_auxiliary_resistance()
Definition Factory.hpp:1566
Factory::modify_pre_resistance
Col< T > & modify_pre_resistance()
Definition Factory.hpp:1852
Factory::modify_incre_temperature
Col< T > & modify_incre_temperature()
Definition Factory.hpp:1818
Factory::modify_pre_time
T & modify_pre_time()
Definition Factory.hpp:1844
Factory::update_incre_temperature
void update_incre_temperature(const Col< T > &)
Definition Factory.hpp:1983
Factory::modify_nonviscous
shared_ptr< MetaMat< T > > & modify_nonviscous()
Definition Factory.hpp:1548
Factory::update_current_velocity
void update_current_velocity(const Col< T > &)
Definition Factory.hpp:2033
Factory::set_error
void set_error(T)
Definition Factory.hpp:772
Factory::modify_incre_nonviscous_force
Col< T > & modify_incre_nonviscous_force()
Definition Factory.hpp:1808
Factory::assemble_geometry
void assemble_geometry(const Mat< T > &, const uvec &, const std::vector< MappingDOF > &)
Definition Factory.hpp:1457
Factory::get_trial_settlement
const Col< T > & get_trial_settlement() const
Definition Factory.hpp:1682
Factory::set_eigenvector
void set_eigenvector(const Mat< T > &)
Definition Factory.hpp:955
Factory::initialize_load_factor
void initialize_load_factor()
Definition Factory.hpp:829
Factory::modify_incre_inertial_force
Col< T > & modify_incre_inertial_force()
Definition Factory.hpp:1810
Factory::get_trial_load
const Col< T > & get_trial_load() const
Definition Factory.hpp:1680
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:1562
Factory::update_current_displacement_by
void update_current_displacement_by(const Col< T > &)
Definition Factory.hpp:2208
Factory::set_trial_resistance
void set_trial_resistance(const Col< T > &)
Definition Factory.hpp:1588
Factory::commit_nonviscous_force
void commit_nonviscous_force()
Definition Factory.hpp:1111
Factory::set_pre_load_factor
void set_pre_load_factor(const Col< T > &)
Definition Factory.hpp:1654
Factory::update_current_damping_force
void update_current_damping_force(const Col< T > &)
Definition Factory.hpp:2013
Factory::modify_current_damping_force
Col< T > & modify_current_damping_force()
Definition Factory.hpp:1830
Factory::update_current_load_factor
void update_current_load_factor(const Col< T > &)
Definition Factory.hpp:1993
Factory::commit_energy
void commit_energy()
Definition Factory.hpp:1031
Factory::commit_damping_force
void commit_damping_force()
Definition Factory.hpp:1105
Factory::get_error
T get_error() const
Definition Factory.hpp:774
Factory::update_trial_time_by
void update_trial_time_by(T)
Definition Factory.hpp:2048
Factory::update_incre_acceleration
void update_incre_acceleration(const Col< T > &)
Definition Factory.hpp:1978
Factory::get_auxiliary_stiffness
const SpMat< T > & get_auxiliary_stiffness() const
Definition Factory.hpp:973
Factory::assemble_inertial_force
void assemble_inertial_force(const Mat< T > &, const uvec &)
Definition Factory.hpp:1437
Factory::clear_status
void clear_status()
Definition Factory.hpp:1191
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:2153
Factory::get_current_load_factor
const Col< T > & get_current_load_factor() const
Definition Factory.hpp:1726
Factory::commit_time
void commit_time()
Definition Factory.hpp:1076
Factory::clear_mass
void clear_mass()
Definition Factory.hpp:1396
Factory::get_pre_inertial_force
const Col< T > & get_pre_inertial_force() const
Definition Factory.hpp:1762
Factory::commit_pre_resistance
void commit_pre_resistance()
Definition Factory.hpp:1175
Factory::update_trial_nonviscous_force
void update_trial_nonviscous_force(const Col< T > &)
Definition Factory.hpp:1898
Factory::reset_resistance
void reset_resistance()
Definition Factory.hpp:1338
Factory::modify_pre_temperature
Col< T > & modify_pre_temperature()
Definition Factory.hpp:1866
Factory::get_auxiliary_load_mutex
std::mutex & get_auxiliary_load_mutex()
Definition Factory.hpp:1005
Factory::get_trial_acceleration
const Col< T > & get_trial_acceleration() const
Definition Factory.hpp:1696
Factory::assemble_resistance
void assemble_resistance(const Mat< T > &, const uvec &)
Definition Factory.hpp:1422
Factory::set_incre_damping_force
void set_incre_damping_force(const Col< T > &)
Definition Factory.hpp:1614
Factory::modify_incre_displacement
Col< T > & modify_incre_displacement()
Definition Factory.hpp:1812
Factory::modify_pre_load
Col< T > & modify_pre_load()
Definition Factory.hpp:1848
Factory::get_trial_constraint_resistance
const SpCol< T > & get_trial_constraint_resistance() const
Definition Factory.hpp:975
Factory::update_incre_damping_force
void update_incre_damping_force(const Col< T > &)
Definition Factory.hpp:1953
Factory::get_pre_velocity
const Col< T > & get_pre_velocity() const
Definition Factory.hpp:1766
Factory::get_current_resistance
const Col< T > & get_current_resistance() const
Definition Factory.hpp:1732
Factory::assemble_nonviscous_force
void assemble_nonviscous_force(const Mat< T > &, const uvec &)
Definition Factory.hpp:1432
Factory::initialize_velocity
void initialize_velocity()
Definition Factory.hpp:881
Factory::get_stiffness_mutex
std::mutex & get_stiffness_mutex()
Definition Factory.hpp:1023
Factory::modify_pre_acceleration
Col< T > & modify_pre_acceleration()
Definition Factory.hpp:1864
Factory::update_incre_inertial_force_by
void update_incre_inertial_force_by(const Col< T > &)
Definition Factory.hpp:2143
Factory::get_current_velocity
const Col< T > & get_current_velocity() const
Definition Factory.hpp:1742
Factory::update_incre_load_factor
void update_incre_load_factor(const Col< T > &)
Definition Factory.hpp:1933
Factory::modify_auxiliary_stiffness
SpMat< T > & modify_auxiliary_stiffness()
Definition Factory.hpp:1570
Factory::set_incre_resistance
void set_incre_resistance(const Col< T > &)
Definition Factory.hpp:1612
Factory::initialize_nonviscous
void initialize_nonviscous()
Definition Factory.hpp:908
Factory::modify_trial_velocity
Col< T > & modify_trial_velocity()
Definition Factory.hpp:1790
Factory::modify_trial_displacement
Col< T > & modify_trial_displacement()
Definition Factory.hpp:1788
Factory::get_pre_temperature
const Col< T > & get_pre_temperature() const
Definition Factory.hpp:1770
Factory::modify_trial_acceleration
Col< T > & modify_trial_acceleration()
Definition Factory.hpp:1792
Factory::clear_load
void clear_load()
Definition Factory.hpp:1222
Factory::get_incre_temperature
const Col< T > & get_incre_temperature() const
Definition Factory.hpp:1722
Factory::modify_pre_load_factor
Col< T > & modify_pre_load_factor()
Definition Factory.hpp:1846
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:1774
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:1908
Factory::get_incre_resistance
const Col< T > & get_incre_resistance() const
Definition Factory.hpp:1708
Factory::modify_trial_resistance
Col< T > & modify_trial_resistance()
Definition Factory.hpp:1780
Factory::get_sushi
const Col< T > & get_sushi() const
Definition Factory.hpp:959
Factory::get_auxiliary_resistance
const Col< T > & get_auxiliary_resistance() const
Definition Factory.hpp:969
Factory::get_trial_damping_force
const Col< T > & get_trial_damping_force() const
Definition Factory.hpp:1686
Factory::modify_eigenvector
Mat< T > & modify_eigenvector()
Definition Factory.hpp:1578
Factory::update_current_resistance_by
void update_current_resistance_by(const Col< T > &)
Definition Factory.hpp:2188
Factory::set_pre_temperature
void set_pre_temperature(const Col< T > &)
Definition Factory.hpp:1674
Factory::update_trial_load_by
void update_trial_load_by(const Col< T > &)
Definition Factory.hpp:2058
Factory::modify_auxiliary_lambda
Col< T > & modify_auxiliary_lambda()
Definition Factory.hpp:1564
Factory::get_current_constraint_resistance
const SpCol< T > & get_current_constraint_resistance() const
Definition Factory.hpp:977
Factory::clear_auxiliary_resistance
void clear_auxiliary_resistance()
Definition Factory.hpp:1292
Factory::get_pre_nonviscous_force
const Col< T > & get_pre_nonviscous_force() const
Definition Factory.hpp:1760
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:2128
Factory::update_sushi_by
void update_sushi_by(const Col< T > &)
Definition Factory.hpp:931
Factory::set_incre_settlement
void set_incre_settlement(const Col< T > &)
Definition Factory.hpp:1610
Factory::modify_pre_inertial_force
Col< T > & modify_pre_inertial_force()
Definition Factory.hpp:1858
Factory::set_sushi
void set_sushi(const Col< T > &)
Definition Factory.hpp:929
Factory::modify_mass
shared_ptr< MetaMat< T > > & modify_mass()
Definition Factory.hpp:1544
Factory::update_incre_settlement
void update_incre_settlement(const Col< T > &)
Definition Factory.hpp:1943
Factory::set_pre_displacement
void set_pre_displacement(const Col< T > &)
Definition Factory.hpp:1668
Factory::get_nonviscous_mutex
std::mutex & get_nonviscous_mutex()
Definition Factory.hpp:1021
Factory::set_current_load_factor
void set_current_load_factor(const Col< T > &)
Definition Factory.hpp:1630
Factory::set_trial_displacement
void set_trial_displacement(const Col< T > &)
Definition Factory.hpp:1596
Factory::update_trial_resistance
void update_trial_resistance(const Col< T > &)
Definition Factory.hpp:1888
Factory::modify_current_load_factor
Col< T > & modify_current_load_factor()
Definition Factory.hpp:1822
Factory::clear_eigen
void clear_eigen()
Definition Factory.hpp:1391
Factory::clear_auxiliary
void clear_auxiliary()
Definition Factory.hpp:1406
Factory::set_reference_load
void set_reference_load(const SpMat< T > &)
Definition Factory.hpp:941
Factory::modify_incre_time
T & modify_incre_time()
Definition Factory.hpp:1796
Factory::update_incre_resistance
void update_incre_resistance(const Col< T > &)
Definition Factory.hpp:1948
Factory::modify_reference_load
SpMat< T > & modify_reference_load()
Definition Factory.hpp:1560
Factory::modify_incre_damping_force
Col< T > & modify_incre_damping_force()
Definition Factory.hpp:1806
Factory::modify_incre_settlement
Col< T > & modify_incre_settlement()
Definition Factory.hpp:1802
Factory::update_current_load_factor_by
void update_current_load_factor_by(const Col< T > &)
Definition Factory.hpp:2173
Factory::set_trial_load_factor
void set_trial_load_factor(const Col< T > &)
Definition Factory.hpp:1582
Factory::initialize_eigen
void initialize_eigen()
Definition Factory.hpp:922
Factory::update_incre_inertial_force
void update_incre_inertial_force(const Col< T > &)
Definition Factory.hpp:1963
Factory::clear_time
void clear_time()
Definition Factory.hpp:1213
Factory::set_stiffness
void set_stiffness(const shared_ptr< MetaMat< T > > &)
Definition Factory.hpp:949
Factory::clear_displacement
void clear_displacement()
Definition Factory.hpp:1264
Factory::get_geometry
const shared_ptr< MetaMat< T > > & get_geometry() const
Definition Factory.hpp:999
Factory::modify_current_load
Col< T > & modify_current_load()
Definition Factory.hpp:1824
Factory::reset_status
void reset_status()
Definition Factory.hpp:1297
Factory::modify_current_temperature
Col< T > & modify_current_temperature()
Definition Factory.hpp:1842
Factory::update_current_inertial_force
void update_current_inertial_force(const Col< T > &)
Definition Factory.hpp:2023
Factory::get_trial_temperature
const Col< T > & get_trial_temperature() const
Definition Factory.hpp:1698
Factory::set_trial_damping_force
void set_trial_damping_force(const Col< T > &)
Definition Factory.hpp:1590
Factory::get_trial_settlement_mutex
std::mutex & get_trial_settlement_mutex()
Definition Factory.hpp:1013
Factory::initialize_mass
void initialize_mass()
Definition Factory.hpp:904
Factory::modify_sushi
Col< T > & modify_sushi()
Definition Factory.hpp:1556
Factory::set_pre_damping_force
void set_pre_damping_force(const Col< T > &)
Definition Factory.hpp:1662
Factory::clear_temperature
void clear_temperature()
Definition Factory.hpp:1285
Factory::modify_current_displacement
Col< T > & modify_current_displacement()
Definition Factory.hpp:1836
Factory::initialize_acceleration
void initialize_acceleration()
Definition Factory.hpp:887
Factory::update_trial_inertial_force_by
void update_trial_inertial_force_by(const Col< T > &)
Definition Factory.hpp:2083
Factory::set_current_temperature
void set_current_temperature(const Col< T > &)
Definition Factory.hpp:1650
Factory::modify_incre_velocity
Col< T > & modify_incre_velocity()
Definition Factory.hpp:1814
Factory::set_damping
void set_damping(const shared_ptr< MetaMat< T > > &)
Definition Factory.hpp:945
Factory::reset_acceleration
void reset_acceleration()
Definition Factory.hpp:1374
Factory::reset_nonviscous_force
void reset_nonviscous_force()
Definition Factory.hpp:1350
Factory::get_pre_resistance
const Col< T > & get_pre_resistance() const
Definition Factory.hpp:1756
Factory::clear_stiffness
void clear_stiffness()
Definition Factory.hpp:1402
Factory::update_incre_nonviscous_force_by
void update_incre_nonviscous_force_by(const Col< T > &)
Definition Factory.hpp:2138
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:369