ROL
ROL_ParameterListConverters.hpp
Go to the documentation of this file.
1// @HEADER
2// ************************************************************************
3//
4// Rapid Optimization Library (ROL) Package
5// Copyright (2014) Sandia Corporation
6//
7// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8// license for use of this work by or on behalf of the U.S. Government.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact lead developers:
38// Drew Kouri (dpkouri@sandia.gov) and
39// Denis Ridzal (dridzal@sandia.gov)
40//
41// ************************************************************************
42// @HEADER
43
44
45#ifndef ROL_PARAMETER_LIST_CONVERTERS_H
46#define ROL_PARAMETER_LIST_CONVERTERS_H
47
48#include <map>
49#include "ROL_Types.hpp"
50#include "ROL_ParameterList.hpp"
51
52
53namespace ROL {
54
55namespace StringList {
56
58inline std::vector<std::string> join( const std::string &s1,
59 const std::string &s2 ) {
60 std::vector<std::string> v;
61 v.push_back(s1);
62 v.push_back(s2);
63
64 return v;
65}
66
68inline std::vector<std::string> join( const std::string &s1,
69 const std::string &s2,
70 const std::string &s3 ) {
71 std::vector<std::string> v;
72 v.push_back(s1);
73 v.push_back(s2);
74 v.push_back(s3);
75
76 return v;
77}
78
80inline std::vector<std::string> join( const std::string &s1,
81 const std::string &s2,
82 const std::string &s3,
83 const std::string &s4 ) {
84 std::vector<std::string> v;
85 v.push_back(s1);
86 v.push_back(s2);
87 v.push_back(s3);
88 v.push_back(s4);
89
90 return v;
91}
92
94inline std::vector<std::string> join( const std::string &s1,
95 const std::string &s2,
96 const std::string &s3,
97 const std::string &s4,
98 const std::string &s5 ) {
99 std::vector<std::string> v;
100 v.push_back(s1);
101 v.push_back(s2);
102 v.push_back(s3);
103 v.push_back(s4);
104 v.push_back(s5);
105
106 return v;
107}
108
109} // namespace StringList
110
111template<class ParameterType>
112void setParameter( ROL::ParameterList &parlist,
113 const std::vector<std::string> &location,
114 const std::vector<std::string>::iterator iter,
115 ParameterType value ) {
116
117 if( iter == location.end()-1 ) { // Key name
118 parlist.set(*iter,value);
119 }
120 else { // sublist
121 ROL::ParameterList &sublist = parlist.sublist(*iter);
122 setParameter(sublist,location,iter+1,value);
123 }
124
125
126}
127
128
129
131inline void tierParameterList( ROL::ParameterList &outList,
132 const ROL::ParameterList &inList ) {
133
134 using StringList::join;
135
136 typedef std::string Str;
137 typedef std::vector<Str> Vec;
138 typedef std::map<Str,Vec> Map;
139 typedef ParameterList::ConstIterator IterPL;
140 typedef typename Vec::iterator IterVec;
141 typedef typename Map::iterator IterMap;
142
143 Map dict;
144
145 // Original flat list name heirarchical list name
146 dict["Use Inexact Gradient"] = join("General","Inexact Gradient");
147 dict["Use Inexact Objective Function"] = join("General","Inexact Objective Function");
148 dict["Use Inexact Hessian-Times-A-Vector"] = join("General","Inexact Hessian-Times-A-Vector");
149 dict["Use Projected Gradient Criticality Measure"] = join("General","Projected Gradient Criticality Measure");
150 dict["Scale for Epsilon Active Sets"] = join("General","Scale for Epsilon Active Sets");
151
152 dict["Absolute Krylov Tolerance"] = join("General","Krylov","Absolute Tolerance");
153 dict["Relative Krylov Tolerance"] = join("General","Krylov","Relative Tolerance");
154 dict["Maximum Number of Krylov Iterations"] = join("General","Krylov","Iteration Limit");
155 dict["Krylov Type"] = join("General","Krylov","Type");
156
157 dict["Barzilai-Borwein"] = join("General","Secant","Barzilai-Borwein");
158 dict["Maximum Secant Storage"] = join("General","Secant","Maximum Storage");
159 dict["Secant Type"] = join("General","Secant","Type");
160 dict["Use Secant Hessian-Times-A-Vector"] = join("General","Secant","Use as Hessian");
161 dict["Use Secant Preconditioning"] = join("General","Secant","Use as Preconditioner");
162
163 dict["Gradient Tolerance"] = join("Status Test","Gradient Tolerance");
164 dict["Maximum Number of Iterations"] = join("Status Test","Iteration Limit");
165 dict["Step Tolerance"] = join("Status Test","Step Tolerance");
166
167 dict["Accept Last Alpha"] = join("Step","Line Search","Accept Last Alpha");
168 dict["Accept Linesearch Minimizer"] = join("Step","Line Search","Accept Linesearch Minimizer");
169 dict["Maximum Number of Function Evaluations"] = join("Step","Line Search","Function Evaluation Limit");
170 dict["Initial Linesearch Parameter"] = join("Step","Line Search","Initial Step Size");
171 dict["Sufficient Decrease Parameter"] = join("Step","Line Search","Sufficient Decrease Tolerance");
172 dict["User Defined Linesearch Parameter"] = join("Step","Line Search","User Defined Initial Step Size");
173
174 dict["Curvature Conditions Parameter"] = join("Step","Line Search","Curvature Condition","General Parameter");
175 dict["Curvature Conditions Parameter: Generalized Wolfe"] = join("Step","Line Search","Curvature Condition","Generalized Wolfe Parameter");
176 dict["Linesearch Curvature Condition"] = join("Step","Line Search","Curvature Condition","Type");
177
178 dict["Nonlinear CG Type"] = join("Step","Line Search","Descent Method","Nonlinear CG Type");
179 dict["Descent Type"] = join("Step","Line Search","Descent Method","Type");
180
181 dict["Backtracking Rate"] = join("Step","Line Search","Line-Search Method","Backtracking Rate");
182 dict["Bracketing Tolerance"] = join("Step","Line Search","Line-Search Method","Bracketing Tolerance");
183 dict["Linesearch Type"] = join("Step","Line Search","Line-Search Method","Type");
184
185 dict["Initial Trust-Region Radius"] = join("Step","Trust Region","Initial Radius");
186 dict["Maximum Trust-Region Radius"] = join("Step","Trust Region","Maximum Radius");
187 dict["Radius Growing Threshold"] = join("Step","Trust Region","Radius Growing Threshold");
188 dict["Radius Growing Rate"] = join("Step","Trust Region","Radius Growing Rate");
189 dict["Radius Shrinking Threshold"] = join("Step","Trust Region","Radius Shrinking Threshold");
190 dict["Trust-Region Safeguard"] = join("Step","Trust Region","Safeguard Size");
191 dict["Trust-Region Subproblem Solver Type"] = join("Step","Trust Region","Subproblem Solver");
192 dict["Step Acceptance Parameter"] = join("Step","Trust Region","Step Acceptance Threshold");
193
194 dict["Gradient Update Relative Tolerance"] = join("Step","Trust Region","Gradient","Relative Tolerance");
195 dict["Gradient Update Tolerance Scaling"] = join("Step","Trust Region","Gradient","Tolerance Scaling");
196 dict["Value Update Exponent"] = join("Step","Trust Region","Inexact","Value","Exponent");
197 dict["Value Update Forcing Sequence Initial Value"] = join("Step","Trust Region","Inexact","Value","Forcing Sequence Initial Value");
198 dict["Value Update Forcing Sequence Reduction Factor"] = join("Step","Trust Region","Inexact","Value","Forcing Sequence Reduction Factor");
199 dict["Value Update Forcing Sequence Update Frequency"] = join("Step","Trust Region","Inexact","Value","Forcing Sequence Update Frequency");
200 dict["Value Update Tolerance Scaling"] = join("Step","Trust Region","Inexact","Value","Tolerance Scaling");
201
202
203 // Add duplicate entries with unformatted keys
204 for(IterMap itmap = dict.begin(); itmap != dict.end(); ++itmap) {
205 Str key = itmap->first;
206 Vec value = itmap->second;
207 dict[removeStringFormat(key)] = value;
208 }
209
210
211 // Iterate over parameter list
212 for(IterPL itpl = inList.begin(); itpl != inList.end(); ++itpl) {
213
214 // Get name of old key
215 Str key( inList.name(itpl) );
216
217 // Look up location/name of new key
218 Vec location = dict[removeStringFormat(key)];
219
220 // Skip if not found in map
221 if(location.size() != 0) {
222
223 IterVec itvec = location.begin();
224
225 if( inList.isType<bool>(key) ) {
226 bool value = inList.get<bool>( key );
227 setParameter( outList, location, itvec, value );
228 }
229 else if( inList.isType<int>(key) ) {
230 int value = inList.get<int>( key );
231 setParameter( outList, location, itvec, value );
232 }
233 else if( inList.isType<double>(key) ) {
234 double value = inList.get<double>( key );
235 setParameter( outList, location, itvec, value );
236 }
237 else if( inList.isType<std::string>(key) ) {
238 std::string value = inList.get<std::string>( key );
239 setParameter( outList, location, itvec, value );
240 }
241 else {
242 ROL_TEST_FOR_EXCEPTION( true, std::invalid_argument,
243 ">>>Error: Unhandled parameter type." );
244 }
245 }
246
247 }
248}
249
250} // namespace ROL
251
252#endif
Contains definitions of custom data types in ROL.
std::vector< std::string > join(const std::string &s1, const std::string &s2)
Helper function for making vectors of strings.
void setParameter(ROL::ParameterList &parlist, const std::vector< std::string > &location, const std::vector< std::string >::iterator iter, ParameterType value)
ROL::Objective_SerialSimOpt Objective_SimOpt value(const V &u, const V &z, Real &tol) override
void tierParameterList(ROL::ParameterList &outList, const ROL::ParameterList &inList)
Produce a heirarchical parameter list using the new names from a flat list of the old names.
std::string removeStringFormat(std::string s)