Coverage for /usr/share/miniconda3/envs/dolfin/lib/python3.8/site-packages/block/algebraic/trilinos/MLPrec.py: 0%

1from __future__ import division 

2 

3##### 

4# Original author: Kent Andre Mardal <kent-and@simula.no> 

5##### 

6 

7from builtins import str 

8from builtins import range 

9from block.block_base import block_base 

10 

11class ML(block_base): 

12 def __init__(self, A, parameters=None, pdes=1, nullspace=None): 

13 from PyTrilinos.ML import MultiLevelPreconditioner 

14 from dolfin import info 

15 from time import time 

16 T = time() 

17 # create the ML preconditioner 

18 MLList = { 

19 #"max levels" : 30, 

20# "ML print final list" : -1,  

21 #"ML output" : 10, 

22# "coarse: type" : "Amesos-KLU", 

23 "smoother: type" : "ML symmetric Gauss-Seidel" , 

24 "smoother: sweeps" : 2, 

25# "smoother: damping factor" : 0.8,  

26 #"cycle applications" : 2, 

27 "prec type" : "MGV", 

28# "aggregation: type" : "METIS" , 

29# "aggregation: damping factor": 1.6,  

30# "aggregation: smoothing sweeps" : 3,  

31 

32 "PDE equations" : pdes, 

33# "ML validate parameter list": True, 

34# "repartition: enable": 1, 

35 } 

36 

37 if parameters: MLList.update(parameters) 

38 self.A = A # Prevent matrix being deleted 

39 self.ml_prec = MultiLevelPreconditioner(A.down_cast().mat(), 0) 

40 if nullspace: 

41 # Convert to MultiVector if necessary 

42 from PyTrilinos import Epetra 

43 if not isinstance(nullspace, Epetra.MultiVector): 

44 n = len(nullspace) 

45 mv = Epetra.MultiVector(nullspace[0].down_cast().vec().Map(), n, False) 

46 for i in range(n): 

47 mv[i] = Epetra.FEVector(nullspace[i].down_cast().vec()) 

48 nullspace = mv 

49 self.ml_prec.SetParameterListAndNullSpace(MLList, nullspace) 

50 else: 

51 self.ml_prec.SetParameterList(MLList) 

52 self.ml_agg = self.ml_prec.GetML_Aggregate() 

53 err = self.ml_prec.ComputePreconditioner() 

54 if err: 

55 raise RuntimeError('ComputePreconditioner returned %d'%err) 

56 info('constructed ML preconditioner in %.2f s'%(time()-T)) 

57 

58 def matvec(self, b): 

59 from dolfin import GenericVector 

60 if not isinstance(b, GenericVector): 

61 return NotImplemented 

62 # apply the ML preconditioner 

63 x = self.A.create_vec(dim=1) 

64 if len(x) != len(b): 

65 raise RuntimeError( 

66 'incompatible dimensions for ML matvec, %d != %d'%(len(x),len(b))) 

67 

68 err = self.ml_prec.ApplyInverse(b.down_cast().vec(), x.down_cast().vec()) 

69 if err: 

70 raise RuntimeError('ApplyInverse returned %d'%err) 

71 return x 

72 

73 def down_cast(self): 

74 return self.ml_prec 

75 

76 def __str__(self): 

77 return '<%s prec of %s>'%(self.__class__.__name__, str(self.A))