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