Solving Larger Models in COMSOL Multiphysics®
                                
                                    Durée:                                    1:04:25                                
                            
                            
                        Watch this archived webinar for an introduction to high-performance computing with COMSOL Multiphysics®. Both algorithmic and hardware aspects of multicore and cluster computing are discussed.
You will also learn about the significant performance improvements for the domain decomposition and algebraic multigrid solver technology in COMSOL Multiphysics® available as of version 5.6. These solver technologies have been extended with new algorithms for both CFD and acoustics.
Browse upcoming live webinars here.
Chapter Selection
                                    
                                                                                                            
                                        
                                            
                                            Introduction (0:00)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Outline (0:23)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Solvers (2:58)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Predicting Solver Memory Requirements (4:26)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Five Test Models (5:48)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            DOF Limits (6:40)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Matrix Characteristics (6:59)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            How Many DOFs in My Model? (8:18)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Different Elements and Orders (8:51)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Understanding Paralellism (11:22)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            A CPU with Multiple Cores (12:28)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Benefit of Multicore (14:15)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Serial and Parallel Work (16:17)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Helical Static Mixer (17:44)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Increasing Size (19:48)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Significant Memory and CPU Requirements (20:38)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Out of Memory (21:17)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Submodeling (24:14)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Coarsening of the Discretization (25:07)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Direct Solvers Can Go “Out of Core” (27:59)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Temporary Files (28:32)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Linear System Solvers (28:43)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Complexity of Direct Methods (29:44)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Direct and Iterative Solvers (30:20)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Let’s Compare Direct with Iterative (31:12)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Reducing Memory Usage (33:30)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Disable Reuse (34:11)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Reduce Number of Cores (34:18)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Assembly Settings Affecting Memory (34:28)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Ways to Get More Memory (35:09)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            An Introduction to Clusters (37:13)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Using a Cluster with COMSOL Multiphysics® (37:36)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Passing Data Between Nodes of Cluster Can Get Very Complicated (38:38)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Distributed Computing with COMSOL Multiphysics® (40:51)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Ethernet Vs. Infiniband (41:04)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Example 1: Stationary CFD Using a Cluster (41:43)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Benchmark: Airflow Over an Ahmed Body (43:20)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Multigrid CPU Time (43:41)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Multigrid Memory (44:22)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            DD Vs. MG CPU Time (44:45)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            DD Vs. MG Memory (45:45)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Example 2: Stationary Semiconductor Models Using a Cluster (46:56)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Benchmark: bipolar_transistor_3d (2M DOF) (48:23)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Benchmark: bipolar_transistor_3d (49:31)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Speedup and Memory Gain for bipolar_transistor_3d (50:17)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Parameter Variation (52:46)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Only Storing Parts of the Solution (53:24)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Probing and Saving on File (54:12)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Summary (55:03)
                                        
                                                                                                                                                                                        
                                        
                                            
                                            Q&A (57:11)
                                        
                                                                                                                
                                
                            