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 
53 namespace ROL {
54 
55 namespace StringList {
56 
58 inline 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 
68 inline 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 
80 inline 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 
94 inline 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 
111 template<class ParameterType>
112 void 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 
131 inline 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
ROL::setParameter
void setParameter(ROL::ParameterList &parlist, const std::vector< std::string > &location, const std::vector< std::string >::iterator iter, ParameterType value)
Definition: ROL_ParameterListConverters.hpp:112
ROL_Types.hpp
Contains definitions of custom data types in ROL.
ROL::removeStringFormat
std::string removeStringFormat(std::string s)
Definition: ROL_Types.hpp:247
ROL::value
ROL::Objective_SimOpt value
ROL::StringList::join
std::vector< std::string > join(const std::string &s1, const std::string &s2)
Helper function for making vectors of strings.
Definition: ROL_ParameterListConverters.hpp:58
ROL::tierParameterList
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...
Definition: ROL_ParameterListConverters.hpp:131
Generated by   doxygen 1.8.5