 |
Mesh Oriented datABase
(version 5.5.1)
An array-based unstructured mesh library
|
|
Mesh Oriented datABase
(version 5.5.1)
An array-based unstructured mesh library
|
1 #ifndef GET_FILE_OPTIONS_H
2 #define GET_FILE_OPTIONS_H
3
4 #include "moab/Core.hpp"
5
6 #include <iostream>
7
8 namespace moab
9 {
10 namespace point_locator
11 {
12 namespace io
13 {
14
15 template < typename String = std::string,
16 typename String_vector = std::vector< std::string >,
17 typename Char_vector = std::vector< const char* > >
18 class File_options
19 {
20 public:
21 File_options()
22 : meshFiles(), interpTag(), gNormTag(), ssNormTag(), readOpts(), outFile(), writeOpts(), dbgFile(),
23 ssTagNames(), ssTagValues(), help( true )
24 {
25 }
26 String_vector meshFiles;
27 String interpTag;
28 String gNormTag;
29 String ssNormTag;
30 String readOpts;
31 String outFile;
32 String writeOpts;
33 String dbgFile;
34 Char_vector ssTagNames;
35 Char_vector ssTagValues;
36 bool help;
37 };
38
39 // Check first character for a '-'.
40 // Return true if one is found. False otherwise.
41 bool check_for_flag( const char* str )
42 {
43 if( str[0] == '-' )
44 return true;
45 else
46 return false;
47 }
48
49 // New get_file_options() function with added possibilities for mbcoupler_test.
50 ErrorCode get_file_options( int argc,
51 char** argv,
52 std::vector< std::string >& meshFiles,
53 std::string& interpTag,
54 std::string& gNormTag,
55 std::string& ssNormTag,
56 std::vector< const char* >& ssTagNames,
57 std::vector< const char* >& ssTagValues,
58 std::string& readOpts,
59 std::string& outFile,
60 std::string& writeOpts,
61 std::string& dbgFile,
62 bool& help )
63 {
64 // Initialize some of the outputs to null values indicating not present
65 // in the argument list.
66 gNormTag = "";
67 ssNormTag = "";
68 readOpts = "PARALLEL=READ_PART;PARTITION=PARALLEL_PARTITION;PARTITION_DISTRIBUTE;"
69 "PARALLEL_RESOLVE_SHARED_ENTS;PARALLEL_GHOSTS=3.0.1;CPUTIME";
70 outFile = "";
71 writeOpts = "PARALLEL=WRITE_PART;CPUTIME";
72 dbgFile = "";
73 std::string defaultDbgFile = argv[0]; // The executable name will be the default debug output file.
74
75 // These will indicate if we've gotten our required parameters at the end of parsing.
76 bool haveMeshes = false;
77 bool haveInterpTag = false;
78
79 // Loop over the values in argv pulling out an parsing each one
80 int npos = 1;
81
82 if( argc > 1 && argv[1] == std::string( "-h" ) )
83 {
84 help = true;
85 return MB_SUCCESS;
86 }
87
88 while( npos < argc )
89 {
90 if( argv[npos] == std::string( "-meshes" ) )
91 {
92 // Parse out the mesh filenames
93 npos++;
94 int numFiles = 2;
95 meshFiles.resize( numFiles );
96 for( int i = 0; i < numFiles; i++ )
97 {
98 if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
99 meshFiles[i] = argv[npos++];
100 else
101 {
102 std::cerr << " ERROR - missing correct number of mesh filenames" << std::endl;
103 return MB_FAILURE;
104 }
105 }
106
107 haveMeshes = true;
108 }
109 else if( argv[npos] == std::string( "-itag" ) )
110 {
111 // Parse out the interpolation tag
112 npos++;
113 if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
114 interpTag = argv[npos++];
115 else
116 {
117 std::cerr << " ERROR - missing <interp_tag>" << std::endl;
118 return MB_FAILURE;
119 }
120
121 haveInterpTag = true;
122 }
123 else if( argv[npos] == std::string( "-gnorm" ) )
124 {
125 // Parse out the global normalization tag
126 npos++;
127 if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
128 gNormTag = argv[npos++];
129 else
130 {
131 std::cerr << " ERROR - missing <gnorm_tag>" << std::endl;
132 return MB_FAILURE;
133 }
134 }
135 else if( argv[npos] == std::string( "-ssnorm" ) )
136 {
137 // Parse out the subset normalization tag and selection criteria
138 npos++;
139 if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
140 ssNormTag = argv[npos++];
141 else
142 {
143 std::cerr << " ERROR - missing <ssnorm_tag>" << std::endl;
144 return MB_FAILURE;
145 }
146
147 if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
148 {
149 char* opts = argv[npos++];
150 char sep1[1] = { ';' };
151 char sep2[1] = { '=' };
152 bool end_vals_seen = false;
153 std::vector< char* > tmpTagOpts;
154
155 // first get the options
156 for( char* i = strtok( opts, sep1 ); i; i = strtok( 0, sep1 ) )
157 {
158 tmpTagOpts.push_back( i );
159 }
160
161 // parse out the name and val or just name.
162 for( unsigned int j = 0; j < tmpTagOpts.size(); j++ )
163 {
164 char* e = strtok( tmpTagOpts[j], sep2 );
165 ssTagNames.push_back( e );
166 e = strtok( 0, sep2 );
167 if( e != NULL )
168 {
169 // We have a value
170 if( end_vals_seen )
171 {
172 // ERROR we should not have a value after none are seen
173 std::cerr << " ERROR - new value seen after end of values "
174 "in <ssnorm_selection>"
175 << std::endl;
176 return MB_FAILURE;
177 }
178 // Otherwise get the value string from e and convert it to an int
179 int* valp = new int;
180 *valp = atoi( e );
181 ssTagValues.push_back( (const char*)valp );
182 }
183 else
184 {
185 // Otherwise there is no '=' so push a null on the list
186 end_vals_seen = true;
187 ssTagValues.push_back( (const char*)0 );
188 }
189 }
190 }
191 else
192 {
193 std::cerr << " ERROR - missing <ssnorm_selection>" << std::endl;
194 return MB_FAILURE;
195 }
196 }
197 else if( argv[npos] == std::string( "-ropts" ) )
198 {
199 // Parse out the mesh file read options
200 npos++;
201 if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
202 readOpts = argv[npos++];
203 else
204 {
205 std::cerr << " ERROR - missing <roptions>" << std::endl;
206 return MB_FAILURE;
207 }
208 }
209 else if( argv[npos] == std::string( "-outfile" ) )
210 {
211 // Parse out the output file name
212 npos++;
213 if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
214 outFile = argv[npos++];
215 else
216 {
217 std::cerr << " ERROR - missing <out_file>" << std::endl;
218 return MB_FAILURE;
219 }
220 }
221 else if( argv[npos] == std::string( "-wopts" ) )
222 {
223 // Parse out the output file write options
224 npos++;
225 if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
226 writeOpts = argv[npos++];
227 else
228 {
229 std::cerr << " ERROR - missing <woptions>" << std::endl;
230 return MB_FAILURE;
231 }
232 }
233 else if( argv[npos] == std::string( "-dbgout" ) )
234 {
235 // Parse out the debug output file name.
236 // If no name then use the default.
237 npos++;
238 if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
239 dbgFile = argv[npos++];
240 else
241 dbgFile = defaultDbgFile;
242 }
243 else
244 {
245 // Unrecognized parameter. Skip it and move along.
246 std::cerr << " ERROR - Unrecognized parameter:" << argv[npos] << std::endl;
247 std::cerr << " Skipping..." << std::endl;
248 npos++;
249 }
250 }
251
252 if( !haveMeshes )
253 {
254 meshFiles.resize( 2 );
255 meshFiles[0] = std::string( TestDir + "/64bricks_1khex.h5m" );
256 meshFiles[1] = std::string( TestDir + "/64bricks_12ktet.h5m" );
257 std::cout << "Mesh files not entered; using default files " << meshFiles[0] << " and " << meshFiles[1]
258 << std::endl;
259 }
260
261 if( !haveInterpTag )
262 {
263 interpTag = "vertex_field";
264 std::cout << "Interpolation field name not given, using default of " << interpTag << std::endl;
265 }
266
267 #ifdef MOAB_HAVE_HDF5
268 if( 1 == argc )
269 {
270 std::cout << "No arguments given; using output file dum.h5m." << std::endl;
271 outFile = "dum.h5m";
272 }
273 #endif
274
275 return MB_SUCCESS;
276 }
277
278 // "generic" get_file_options
279 template < typename Options >
280 ErrorCode get_file_options( int argc, char** argv, Options& o )
281 {
282 return get_file_options( argc, argv, o.meshFiles, o.interpTag, o.gNormTag, o.ssNormTag, o.ssTagNames,
283 o.ssTagValues, o.readOpts, o.outFile, o.writeOpts, o.dbgFile, o.help );
284 }
285
286 } // namespace io
287 } // namespace point_locator
288 } // namespace moab
289
290 #endif // GET_FILE_OPTIONS_H
1.9.1.