46 constrainedOptimisationMethod,
78 rho_.setSize(cValues_.size() + 1, raa0_);
81 oldObjectiveValue_ = objectiveValue_;
82 oldCValues_ = cValues_;
86 const scalarField x(designVars_().getVars(), activeDesignVars_);
88 (designVars_().lowerBounds()(), activeDesignVars_);
90 (designVars_().upperBounds()(), activeDesignVars_);
93 (objectiveDerivatives_, activeDesignVars_);
98 /globalSum(
x.size())*globalSum(
mag(activeObjDerivs)*span);
101 forAll(constraintDerivatives_, i)
105 constraintDerivatives_[i], activeDesignVars_
109 /globalSum(
x.size())*globalSum(
mag(activeDerivs)*span);
116 if (dynamicRhoInitialisation_)
118 Info<<
"-----------------------------------------" <<
endl;
119 Info<<
"Solving sub problems for initializing rho" <<
endl;
120 Info<<
"-----------------------------------------" <<
endl;
131 designVars_().storeDesignVariables();
132 x0_.
map(designVars_().getVars(), activeDesignVars_);
134 Info<<
"Initial pseudo update of the design variables" <<
endl;
139 designVars_().update(correction_);
145 while (!converged() && iter++ < 10)
147 Info<<
nl <<
"Dynamic rho initialisation iteration " << iter
149 designVars_().resetDesignVariables();
152 designVars_().update(correction_);
155 Info<<
"-----------------------------------------" <<
endl;
156 Info<<
"Dynamic rho initialisation converged in " << iter
157 <<
" iterations " <<
endl;
158 Info<<
"-----------------------------------------" <<
endl;
165 designVars_().resetDesignVariables();
170 rho_ *= dynamicRhoMult_;
175 rho_ =
max(rho_, scalar(1.
e-6));
178 <<
"Computed r values " << rho_ <<
endl;
185 const scalarField x(designVars_().getVars(), activeDesignVars_);
186 const scalarField xMin(designVars_().lowerBoundsRef(), activeDesignVars_);
187 const scalarField xMax(designVars_().upperBoundsRef(), activeDesignVars_);
196 (
x[i] - x0_[i])*(x0_[i] - x00_[i]) < scalar(0)
197 ? asymDecr_ : asymIncr_
199 lower_[i] =
x[i] -
gamma*(x0_[i] - lower_[i]);
200 upper_[i] =
x[i] +
gamma*(upper_[i] - x0_[i]);
211 lower_ =
x - sInit_*span;
212 upper_ =
x + sInit_*span;
216 a_ =
max(a_,
x - move_*span);
217 b_ =
min(
xMax, upper_ - 0.1*(upper_ -
x));
218 b_ =
min(b_,
x + move_*span);
224 const label m(cValues_.size());
228 alpha_.setSize(m,
Zero);
229 c_.setSize(m, coeffsDict(typeName).getOrDefault<scalar>(
"c", 100));
230 d_.setSize(m, coeffsDict(typeName).getOrDefault<scalar>(
"d", 1));
231 deltaLamda_.setSize(m,
Zero);
232 deltaY_.setSize(m,
Zero);
233 deltaS_.setSize(m,
Zero);
234 deltaMu_.setSize(m,
Zero);
243 xNew_ = 0.5*(a_ + b_);
244 ksi_ =
max(scalar(1), 1./(xNew_ - a_));
245 Eta_ =
max(scalar(1), 1./(b_ - xNew_));
248 y_.setSize(m, scalar(1));
249 lamda_.setSize(m, scalar(1));
250 s_.setSize(m, scalar(1));
251 mu_.setSize(m,
Zero);
252 mu_ =
max(scalar(1), 0.5*c_);
263 x0_.map(designVars_().getVars(), activeDesignVars_);
276 designVars_().lowerBoundsRef(), activeDesignVars_
280 designVars_().upperBoundsRef(), activeDesignVars_
288 1.001*
max(derivs, scalar(0))
289 + 0.001*
max(-derivs, scalar(0))
290 + r/(upperBounds - lowerBounds)
303 p(derivs, r,
scalarField(designVars_().getVars(), activeDesignVars_));
316 designVars_().lowerBoundsRef(), activeDesignVars_
320 designVars_().upperBoundsRef(), activeDesignVars_
328 0.001*
max(derivs, scalar(0))
329 + 1.001*
max(-derivs, scalar(0))
330 + r/(upperBounds - lowerBounds)
343 q(derivs, r,
scalarField(designVars_().getVars(), activeDesignVars_));
358 constraintDerivatives_[i], activeDesignVars_
362 res[i] = globalSum(pI/(upper_ - vars) + qI/(vars - lower_));
371 const scalarField vars(designVars_().getVars(), activeDesignVars_);
380 const scalarField activeObjDerivs(objectiveDerivatives_, activeDesignVars_);
383 forAll(constraintDerivatives_, cI)
387 constraintDerivatives_[cI], activeDesignVars_
389 res += lamda_[cI]*
p(activeDerivs, rho_[cI + 1]);
398 const scalarField activeObjDerivs(objectiveDerivatives_, activeDesignVars_);
399 tmp<scalarField> tres(q(activeObjDerivs, rho_[0]));
401 forAll(constraintDerivatives_, cI)
405 constraintDerivatives_[cI], activeDesignVars_
407 res += lamda_[cI]*q(activeDerivs, rho_[cI + 1]);
442 p(dfdx,
rho, xInit)*(1./(upper_ -
x) - 1./(upper_ - xInit))
443 + q(dfdx,
rho, xInit)*(1./(
x - lower_) - 1./(xInit - lower_))
480 field = defaultField;
491 const label
n(xNew_.size());
492 const label m(cValues_.size());
493 const scalarField x(designVars_().getVars(), activeDesignVars_);
496 tmp<scalarField> tpL(pLamda());
498 tmp<scalarField> tqL(qLamda());
508 scalar(2)*pL/
pow3(upper_ - xNew_)
509 + scalar(2)*qL/
pow3(xNew_ - lower_)
517 for (label i = 0; i < m; ++i)
521 constraintDerivatives_[i], activeDesignVars_
523 tmp<scalarField> tp =
p(activeDerivs, rho_[i + 1]);
524 tmp<scalarField> tq = q(activeDerivs, rho_[i + 1]);
535 pL/
sqr(upper_ - xNew_) - qL/
sqr(xNew_ - lower_)
541 c_ + d_*y_ - lamda_ - eps_/y_
543 scalar deltaZTilda = alpha0_ -
sum(lamda_*alpha_) - eps_/z_;
562 scalar zRatio(z_/zeta_);
566 for (label i = 0; i < m; ++i)
569 for (label j = 0; j < m; ++j)
571 for (label l = 0; l <
n; ++l)
574 lhs[i][j] += DxInv[l]*
G[i][l]*
G[j][l];
578 for (label l = 0; l <
n; ++l)
581 rhs[i] -= DxInv[l]*
G[i][l]*deltaXTilda[l];
587 reduce(lhs, sumOp<scalarSquareMatrix>());
592 rhs += deltaLamdaYTilda + alpha_*deltaZTilda*zRatio;
593 for (label i = 0; i < m; ++i)
596 for (label j = 0; j < m; ++j)
599 lhs[i][j] += alpha_[i]*alpha_[j]*zRatio;
602 lhs[i][i] += DLamdaY[i];
604 solve(deltaLamda_, lhs, rhs);
605 deltaZ_ = (
sum(alpha_*deltaLamda_) - deltaZTilda)*zRatio;
611 deltaX_ = - DxInv*(
G.Tmul(deltaLamda_) + deltaXTilda);
614 deltaY_ = DYInv*(deltaLamda_ - deltaYTilda);
617 deltaS_ = (-s_*deltaLamda_ + eps_)/lamda_ - s_;
620 deltaZeta_ = -zeta_/z_*deltaZ_ - zeta_ + eps_/z_;
623 deltaMu_ = (-mu_*deltaY_ + eps_)/y_ - mu_;
626 deltaEta_ = (Eta_*deltaX_ + eps_)/(b_ - xNew_) - Eta_;
629 deltaKsi_ = (-ksi_*deltaX_ + eps_)/(xNew_ - a_) - ksi_;
635 const label
n(xNew_.size());
636 const label m(cValues_.size());
640 for (label i = 0; i <
n; ++i)
644 xNew_[i] + step*deltaX_[i] - a_[i] - 0.01*(xNew_[i] - a_[i])
648 step = -0.99*(xNew_[i] - a_[i])/deltaX_[i];
653 -xNew_[i] - step*deltaX_[i] + b_[i] - 0.01*(b_[i] - xNew_[i])
657 step = 0.99*(b_[i] - xNew_[i])/deltaX_[i];
660 adjustStep(step, ksi_[i], deltaKsi_[i]);
661 adjustStep(step, Eta_[i], deltaEta_[i]);
664 for (label i = 0; i < m; ++i)
666 adjustStep(step, y_[i], deltaY_[i]);
667 adjustStep(step, lamda_[i], deltaLamda_[i]);
668 adjustStep(step, mu_[i], deltaMu_[i]);
669 adjustStep(step, s_[i], deltaS_[i]);
672 adjustStep(step, z_, deltaZ_);
673 adjustStep(step, zeta_, deltaZeta_);
679 reduce(step, minOp<scalar>());
684 Info<<
"Step before line search is " << step <<
endl;
688 scalar normResOld =
sqrt(globalSum(
magSqr(computeResiduals())));
689 scalar maxRes(GREAT);
691 for (label i = 0; i < maxLineSearchIters_ ; ++i)
694 updateSolution(step);
698 scalar normResNew =
sqrt(globalSum(
magSqr(resNew)));
701 if (normResNew < normResOld)
704 <<
"Initial residual = " << normResOld <<
", " 705 <<
"Final residual = " << normResNew <<
", " 706 <<
"No of LineSearch Iterations = " << i + 1
713 updateSolution(-step);
717 if (i == maxLineSearchIters_ - 1)
720 Info<<
"Line search could not find a step that reduced" 721 <<
" residuals while satisfying the constraints" <<
nl 722 <<
"Increasing eps to " << eps_ <<
endl;
729 Info<<
"Step after line search is " << step <<
nl <<
endl;
743 if (0.99*value + step*
update < scalar(0))
745 step = -0.99*value/
update;
752 xNew_ += step*deltaX_;
755 lamda_ += step*deltaLamda_;
756 ksi_ += step*deltaKsi_;
757 Eta_ += step*deltaEta_;
758 mu_ += step*deltaMu_;
759 zeta_ += step*deltaZeta_;
766 const label
n(xNew_.size());
767 const label m(cValues_.size());
775 (pLamda()/
sqr(upper_ - xNew_) - qLamda()/
sqr(xNew_ - lower_));
776 for (label i = 0; i <
n; ++i)
778 res[iRes++] = dPsidx[i] - ksi_[i] + Eta_[i];
782 for (label i = 0; i < m; ++i)
784 res[iRes++] = c_[i] + d_[i]*y_[i] - lamda_[i] - mu_[i];
788 res[iRes++] = alpha0_ - zeta_ -
sum(lamda_*alpha_);
792 for (label i = 0; i < m; ++i)
794 res[iRes++] = gb[i] - alpha_[i]*z_ - y_[i] + s_[i];
798 for (label i = 0; i <
n; ++i)
800 res[iRes++] = ksi_[i]*(xNew_[i] - a_[i]) - eps_;
804 for (label i = 0; i <
n; ++i)
806 res[iRes++] = Eta_[i]*(b_[i] - xNew_[i]) - eps_;
810 for (label i = 0; i < m; ++i)
812 res[iRes++] = mu_[i]*y_[i] - eps_;
816 res[iRes++] = z_*zeta_ - eps_;
819 for (label i = 0; i < m; ++i)
821 res[iRes++] = lamda_[i]*s_[i] - eps_;
836 || (continuousNormalisation_ && counter_ < lastNormalisationStep_)
839 scalarField activeSens(objectiveDerivatives_, activeDesignVars_);
840 Jnorm_.reset(
new scalar(
Foam::sqrt(globalSum(
sqr(activeSens)))));
843 forAll(constraintDerivatives_, cI)
846 (constraintDerivatives_[cI], activeDesignVars_);
849 Info<<
"Computed normalisation factors " <<
nl 850 <<
"J: " << Jnorm_() <<
nl 851 <<
"C: " << Cnorm_() <<
endl;
855 objectiveValue_ /= Jnorm_() + SMALL;
856 objectiveDerivatives_ /= Jnorm_() + SMALL;
859 cValues_ *= cw_/(Cnorm_() + SMALL);
860 forAll(constraintDerivatives_, cI)
862 constraintDerivatives_[cI] *= cw_/(Cnorm_()[cI] + SMALL);
873 const dictionary&
dict,
874 autoPtr<designVariables>& designVars,
875 const label nConstraints,
879 constrainedOptimisationMethod(
mesh,
dict, designVars, nConstraints,
type),
880 updateMethod(
mesh,
dict, designVars, nConstraints,
type),
881 x0_(getOrDefaultScalarField(
"x0", activeDesignVars_.size())),
882 x00_(getOrDefaultScalarField(
"x00", activeDesignVars_.size())),
883 xNew_(activeDesignVars_.size()),
884 oldObjectiveValue_(getOrDefault<scalar>(
"J0",
Zero)),
885 oldCValues_(getOrDefaultScalarField(
"C0", nConstraints_)),
887 z_(coeffsDict(
type).getOrDefault<scalar>(
"z", 1.)),
888 alpha0_(coeffsDict(
type).getOrDefault<scalar>(
"alpha0", 1.)),
893 lower_(xNew_.size(), -GREAT),
894 upper_(xNew_.size(), GREAT),
898 boundRho_(coeffsDict(
type).getOrDefault<bool>(
"boundRho", false)),
899 correctDVs_(coeffsDict(
type).getOrDefault<bool>(
"correct", true)),
904 zeta_(coeffsDict(
type).getOrDefault<scalar>(
"zeta", 1.)),
908 deltaX_(xNew_.size(),
Zero),
913 deltaEta_(xNew_.size(),
Zero),
914 deltaKsi_(xNew_.size(),
Zero),
916 maxNewtonIters_(coeffsDict(
type).getOrDefault<label>(
"maxIters", 6000)),
919 coeffsDict(
type).getOrDefault<label>(
"maxLineSearchIters", 10)
921 initializeEverySubproblem_
922 (coeffsDict(
type).getOrDefault<bool>(
"initializeEverySubproblem", false)),
923 asymDecr_(coeffsDict(
type).getOrDefault<scalar>(
"asymptoteDecrease", 0.7)),
924 asymIncr_(coeffsDict(
type).getOrDefault<scalar>(
"asymptoteIncrease", 1.2)),
925 sInit_(coeffsDict(
type).getOrDefault<scalar>(
"sInit", 0.5)),
926 move_(coeffsDict(
type).getOrDefault<scalar>(
"move", 0.5)),
927 raa0_(coeffsDict(
type).getOrDefault<scalar>(
"raa0", 1.
e-05)),
928 maxInitRhoMult_(coeffsDict(
type).getOrDefault<scalar>(
"maxInitRhoMult", 0.1)),
929 maxRhoMult_(coeffsDict(
type).getOrDefault<scalar>(
"maxRhoMult", 10)),
930 variableRho_(coeffsDict(
type).getOrDefault<bool>(
"variableRho", false)),
931 dynamicRhoInitialisation_
932 (coeffsDict(
type).getOrDefault<bool>(
"dynamicRhoInitialisation", false)),
934 (coeffsDict(
type).getOrDefault<scalar>(
"dynamicRhoMult", 0.1)),
935 normalise_(coeffsDict(
type).getOrDefault<bool>(
"normalise", false)),
936 continuousNormalisation_
937 (coeffsDict(
type).getOrDefault<bool>(
"continuousNormalisation", false)),
940 cw_(coeffsDict(
type).getOrDefault<scalar>(
"constraintWeight", 1)),
941 lastNormalisationStep_
943 coeffsDict(
type).getOrDefault<label>(
"lastNormalisationStep", 20)
947 if (!designVars().lowerBounds() || !designVars().upperBounds())
950 <<
"Lower and upper design variable bounds must be set for MMA" 1009 if (initializeEverySubproblem_)
1014 scalar resMax(
gMax(
mag(computeResiduals())));
1019 <<
"Newton iter " << iter <<
nl <<
endl;
1022 if (resMax < 0.9*eps_)
1028 computeNewtonDirection();
1033 resMax = lineSearch();
1035 <<
"max residual = " << resMax <<
", " 1036 <<
"eps = " << eps_ <<
nl <<
endl;
1038 mesh_.time().printExecutionTime(
Info);
1039 }
while (iter++ < maxNewtonIters_ && (eps_ > 1.
e-07 || resMax > 0.9*eps_));
1041 Info<<
"Solved the MMA Newton problem in " << iter <<
" iterations " 1045 const scalarField& oldVars = designVars_().getVars();
1046 forAll(activeDesignVars_, avI)
1048 const label vI(activeDesignVars_[avI]);
1049 correction_[vI] = xNew_[avI] - oldVars[vI];
1058 label m(cValues_.size());
1065 const scalarField activeObjDerivs(objectiveDerivatives_, activeDesignVars_);
1066 vals[0] = objectiveValue_;
1067 approx[0] = fTilda(x0_, xNew_, oldObjectiveValue_, activeObjDerivs, rho_[0]);
1070 forAll(constraintDerivatives_, i)
1074 constraintDerivatives_[i], activeDesignVars_
1076 vals[i + 1] = cValues_[i];
1078 fTilda(x0_, xNew_, oldCValues_[i], activeDerivs, rho_[i + 1]);
1086 return valsAndApproxs_;
1096 const scalarField xMin(designVars_().lowerBounds()(), activeDesignVars_);
1097 const scalarField xMax(designVars_().upperBounds()(), activeDesignVars_);
1099 scalar d = globalSum
1101 (upper_ - lower_)*
sqr(xNew_ - x0_)
1102 /(upper_ - xNew_)/(xNew_ - lower_)/(
xMax -
xMin)
1108 const scalar
delta = (vals[i] - approx[i])/d;
1111 rho_[i] =
min(1.1*(rho_[i] +
delta), maxRhoMult_*rho_[i]);
1115 <<
"Updated rho values to " << rho_ <<
endl;
1127 variableRho_ = varRho;
1133 updateValuesAndApproximations();
1137 bool isConverged(
true);
1141 <<
nl <<
"MMA, objective/constraint " << i <<
nl 1142 <<
"Approximation " << approx[i]
1143 <<
" | old value " << vals[i] <<
nl <<
endl;
1144 isConverged = isConverged && (approx[i] - vals[i] > 0.);
1153 x0_.writeEntry(
"x0",
os);
1154 x00_.writeEntry(
"x00",
os);
1155 lower_.writeEntry(
"lower",
os);
1156 upper_.writeEntry(
"upper",
os);
tmp< scalarField > pLamda()
p and q functions, using the dual lamda
scalarField ksi_
Lagrange multipliers for the lower limits constraints.
void size(const label n)
Older name for setAddressableSize.
void setVariableRho(bool varRho=true)
Set variable rho.
dimensioned< Type > sum(const DimensionedField< Type, GeoMesh > &f1)
void solveSubproblem()
Solve subproblem using a Newton optimiser.
void computeCorrection()
Compute design variables correction.
dimensioned< typename typeOfMag< Type >::type > mag(const dimensioned< Type > &dt)
void setOrDefaultScalarField(scalarField &field, const word &name, const label size, const scalarField &defaultField)
Read in scalarField from self (potentially in binary), or allocate field with the size of the active ...
tmp< scalarField > b()
The rhs of the contraint approximations.
error FatalError
Error stream (stdout output on all processes), with additional 'FOAM FATAL ERROR' header text and sta...
A list of keyword definitions, which are a keyword followed by a number of values (eg...
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
tmp< scalarField > qLamda()
const dimensionedScalar G
Newtonian constant of gravitation.
label max(const labelHashSet &set, label maxValue=labelMin)
Find the max value in labelHashSet, optionally limited by second argument.
dimensionedSymmTensor sqr(const dimensionedVector &dv)
constexpr char nl
The newline '\n' character (0x0a)
void computeNewtonDirection()
Compute direction for the Newton problem.
void updateValuesAndApproximations()
Compute objective/constraint values and their approximations.
void updateSolution(const scalar step)
Update the current solution using the known direction and the given step length.
dimensionedScalar sqrt(const dimensionedScalar &ds)
Ostream & endl(Ostream &os)
Add newline and flush stream.
virtual bool writeData(Ostream &os) const
Write useful quantities to files.
Ostream & writeEntry(const keyType &key, const T &value)
Write a keyword/value entry.
tmp< scalarField > p(const scalarField &derivs, const scalar r, const scalarField &x)
p and q functions, used to approximate the objective and contraints
bool converged()
Checks convergence of GCMMA.
Macros for easy insertion into run-time selection tables.
scalarField b_
Upper design variables constraints.
#define forAll(list, i)
Loop across all elements in list.
scalarField lower_
Lower design variables asymptotes.
fileName::Type type(const fileName &name, const bool followLink=true)
Return the file type: DIRECTORY or FILE, normally following symbolic links.
tmp< scalarField > q(const scalarField &derivs, const scalar r, const scalarField &x)
const labelList & activeDesignVars_
Map to active design variables.
void normalise()
Normalise the objective and constraints if necessary.
const dimensionedScalar e
Elementary charge.
void setSize(const label n)
Alias for resize()
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for expressions::valueTypeCode::INVALID.
tmp< scalarField > getOrDefaultScalarField(const word &name, const label size, const scalar value=Zero)
Read in scalarField from self (potentially in binary), or allocate field with the size of the active ...
void updateRho()
Update rho value if needed.
const dimensionedScalar b
Wien displacement law constant: default SI units: [m.K].
A class for handling words, derived from Foam::string.
Field< scalar > scalarField
Specialisation of Field<T> for scalar.
const scalarField & getRho() const
Get rho value if needed.
tmp< scalarField > gConstr(const scalarField &vars)
g of all constraint functions
static tmp< T > New(Args &&... args)
Construct tmp with forwarding arguments.
void adjustStep(scalar &step, const scalar value, const scalar update)
Adjust step to satisfy cireteria.
static void listCombineAllGather(List< T > &values, const CombineOp &cop, const int tag=UPstream::msgType(), const label comm=UPstream::worldComm)
Same as Pstream::listCombineReduce.
label min(const labelHashSet &set, label minValue=labelMax)
Find the min value in labelHashSet, optionally limited by second argument.
scalarField x00_
The twice previous design variables. Used to compute new bounds.
errorManip< error > abort(error &err)
SolverPerformance< Type > solve(faMatrix< Type > &, const dictionary &solverControls)
Solve returning the solution statistics given convergence tolerance.
#define DebugInfo
Report an information message using Foam::Info.
void map(const UList< Type > &mapF, const labelUList &mapAddressing)
1 to 1 map from the given field
int debug
Static debugging option.
Type gMax(const FieldField< Field, Type > &f)
OBJstream os(runTime.globalPath()/outputName)
defineTypeNameAndDebug(combustionModel, 0)
dimensionedScalar pow3(const dimensionedScalar &ds)
scalarField a_
Lower design variables constraints.
tmp< scalarField > computeResiduals()
Compute and return residuals based on the current solution.
scalarField xNew_
The set of design variables being updated during the subproblem.
A list of pointers to objects of type <T>, with allocation/deallocation management of the pointers...
void updateSizes()
Update sizes of fields related to the active design variables.
scalar lineSearch()
Perform line search and return max residual corresponding to the updated solution.
const PtrList< scalarField > & getValuesAndApproximations() const
Get objective/constraint values and their approximations.
void zeroUpdates()
Zero the updates computed in the previous optimisation cycle.
messageStream Info
Information stream (stdout output on master, null elsewhere)
void initializeRho()
Initialize rho constants in the (p, q) functions.
scalarField upper_
Upper design variables asymptotes.
scalarField Eta_
Lagrange multipliers for the upper limits constraints.
A class for managing temporary objects.
void updateBounds()
Update the bounds associated with the design variables.
SquareMatrix< scalar > scalarSquareMatrix
virtual bool writeData(Ostream &os) const
Write continuation data under uniform.
void initialize()
Allocate fields related to constraints.
void reduce(T &value, const BinaryOp &bop, const int tag=UPstream::msgType(), const label comm=UPstream::worldComm)
Reduce inplace (cf. MPI Allreduce) using linear/tree communication schedule.
dimensioned< typename typeOfMag< Type >::type > magSqr(const dimensioned< Type > &dt)
void storeOldValues()
Store old objcective and constraint values.
scalar fTilda(const scalarField &xInit, const scalarField &x, const scalar f, const scalarField &dfdx, const scalar rho)
Computation of the approximate function.
scalarField x0_
The previous design variables. Used to compute new bounds.
addToRunTimeSelectionTable(functionObject, pointHistory, dictionary)
RectangularMatrix< scalar > scalarRectangularMatrix
static constexpr const zero Zero
Global zero (0)