1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
// Copyright (C) 2006, 2007 Damien Hocking, KBC Advanced Technologies
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors: Damien Hocking KBC 2006-03-20
// (included his original contribution into Ipopt package on 2006-03-25)
// Andreas Waechter IBM 2006-03-25
// (minor changes and corrections)
// Scott Turnberg CMU 2006-05-12
// (major revision)
// (incorporated by AW on 2006-11-11 into Ipopt package)
#ifndef __IPMUMPSSOLVERINTERFACE_HPP__
#define __IPMUMPSSOLVERINTERFACE_HPP__
#include "IpSparseSymLinearSolverInterface.hpp"
namespace Ipopt
{
/** Interface to the linear solver Mumps, derived from
* SparseSymLinearSolverInterface.
*/
class MumpsSolverInterface: public SparseSymLinearSolverInterface
{
public:
/** @name Constructor/Destructor */
///@{
/** Constructor */
MumpsSolverInterface();
/** Destructor */
virtual ~MumpsSolverInterface();
///@}
bool InitializeImpl(
const OptionsList& options,
const std::string& prefix
);
/** @name Methods for requesting solution of the linear system. */
///@{
virtual ESymSolverStatus InitializeStructure(
Index dim,
Index nonzeros,
const Index* airn,
const Index* ajcn
);
virtual Number* GetValuesArrayPtr();
virtual ESymSolverStatus MultiSolve(
bool new_matrix,
const Index* airn,
const Index* ajcn,
Index nrhs,
Number* rhs_vals,
bool check_NegEVals,
Index numberOfNegEVals
);
virtual Index NumberOfNegEVals() const;
///@}
//* @name Options of Linear solver */
///@{
virtual bool IncreaseQuality();
virtual bool ProvidesInertia() const
{
return true;
}
EMatrixFormat MatrixFormat() const
{
return Triplet_Format;
}
///@}
static void RegisterOptions(
SmartPtr<RegisteredOptions> roptions
);
/// give name of MUMPS with version info
/// @since 3.14.0
static std::string GetName();
virtual bool ProvidesDegeneracyDetection() const;
virtual ESymSolverStatus DetermineDependentRows(
const Index* ia,
const Index* ja,
std::list<Index>& c_deps
);
private:
/**@name Default Compiler Generated Methods
* (Hidden to avoid implicit creation/calling).
* These methods are not implemented and
* we do not want the compiler to implement
* them for us, so we declare them private
* and do not define them. This ensures that
* they will not be implicitly created/called. */
///@{
/** Copy Constructor */
MumpsSolverInterface(
const MumpsSolverInterface&
);
/** Default Assignment Operator */
void operator=(
const MumpsSolverInterface&
);
///@}
/** @name Information about the matrix */
///@{
/** Primary MUMP data structure */
void* mumps_ptr_;
///@}
/** @name Information about most recent factorization/solve */
///@{
/** Number of negative eigenvalues */
Index negevals_;
///@}
/** @name Initialization flags */
///@{
/** Flag indicating if internal data is initialized.
* For initialization, this object needs to have seen a matrix.
*/
bool initialized_;
/** Flag indicating if the matrix has to be refactorized because
* the pivot tolerance has been changed.
*/
bool pivtol_changed_;
/** Flag that is true if we just requested the values of the
* matrix again (SYMSOLVER_CALL_AGAIN) and have to factorize
* again.
*/
bool refactorize_;
///@}
/** @name Solver specific data/options */
///@{
/** Pivot tolerance */
Number pivtol_;
/** Maximal pivot tolerance */
Number pivtolmax_;
/** Percent increase in memory */
Index mem_percent_;
/** Permutation and scaling method in MUMPS */
Index mumps_permuting_scaling_;
/** Pivot order in MUMPS. */
Index mumps_pivot_order_;
/** Scaling in MUMPS */
Index mumps_scaling_;
/** Threshold in MUMPS to state that a constraint is linearly dependent */
Number mumps_dep_tol_;
/** Flag indicating whether the TNLP with identical structure has
* already been solved before.
*/
bool warm_start_same_structure_;
///@}
/** Flag indicating if symbolic factorization has already been called */
bool have_symbolic_factorization_;
/** @name Internal functions */
///@{
/** Call MUMPS (job=1) to perform symbolic manipulations, and reserve
* memory.
*/
ESymSolverStatus SymbolicFactorization();
/** Call MUMPS (job=2) to factorize the Matrix.
* It is assumed that the first nonzeros_ element of a_ contain the values
* of the matrix to be factorized.
*/
ESymSolverStatus Factorization(
bool check_NegEVals,
Index numberOfNegEVals
);
/** Call MUMPS (job=3) to do the solve. */
ESymSolverStatus Solve(
Index nrhs,
Number* rhs_vals
);
///@}
};
} // namespace Ipopt
#endif