YAC: src/mci/config_yaml.c Source File

68struct field_couple_buffer {

69 struct {

70 char const * comp_name;

71 char const * grid_name;

72 int lag;

73 } src;

74 struct {

75 char const * comp_name;

76 struct {

77 char const ** name;

78 size_t count;

79 } grid;

80 int lag;

81 } tgt;

82 char const * coupling_period;

83 enum yac_reduction_type time_reduction;

84 struct yac_interp_stack_config * interp_stack;

85 struct {

86 char const * name;

87 enum yac_weight_file_on_existing on_existing;

88 } weight_file;

89 int mapping_on_source;

90 double scale_factor, scale_summand;

91

  struct field_couple_field_names {
    char const * src, * tgt;
  } * field_names;

95 size_t num_field_names;

96

97 char const ** src_mask_names;

98 size_t num_src_mask_names;

99 char const * tgt_mask_name;

100

101 char const * yaxt_exchanger_name;

102

103 struct yac_collection_selection * collection_selection;

104

105 int use_raw_exchange;

106};

108enum yaml_base_key_types {

114 DEBUG,

115};

117enum yaml_couple_key_types {

118 SOURCE_NAME,

119 SOURCE_COMPONENT,

120 SOURCE_GRID,

121 TARGET_NAMES,

122 TARGET_COMPONENT,

124 FIELD,

129 WEIGHT_FILE_DATA,

130 WEIGHT_FILE_NAME,

131 WEIGHT_FILE_ON_EXISTING,

136 SOURCE_MASK_NAME,

137 SOURCE_MASK_NAMES,

138 TARGET_MASK_NAME,

139 YAXT_EXCHANGER_NAME,

140 COLLECTION_SELECTION,

141 USE_RAW_EXCHANGE,

142};

144enum yaml_debug_key_types {

149 APPLY_COORD_CHECK,

150 COORDS_MISMATCH_FATAL

151};

153enum yaml_debug_sync_loc_key_types {

154 SYNC_LOC_DEF_COMP,

155 SYNC_LOC_SYNC_DEF,

156 SYNC_LOC_ENDDEF,

157 SYNC_LOC_COUNT, // has to be the last entry

158};

160enum yaml_comp_grid_names_key_types {

161 COMP_NAME,

162 GRID_NAMES,

163};

165enum yaml_weight_file_data_key_types {

166 WEIGHT_FILE_DATA_NAME,

167 WEIGHT_FILE_DATA_ON_EXISTING,

168};

170struct debug_config_file_buffer {

  struct debug_config_file {
    char const * name;
    enum yac_text_filetype type;
    int include_definitions;
  } config_file[SYNC_LOC_COUNT];

176 char const * sync_loc_ref[SYNC_LOC_COUNT];

177};

179enum yaml_debug_output_grid_key_types{

180 OUTPUT_GRID_GRID_NAME,

181 OUTPUT_GRID_FILE_NAME

182};

186DEF_NAME_TYPE_PAIRS(

187 yaml_base_keys,

188 DEF_NAME_TYPE_PAIR(start_date, START_DATE),

189 DEF_NAME_TYPE_PAIR(start_datetime, START_DATE),

190 DEF_NAME_TYPE_PAIR(end_date, END_DATE),

191 DEF_NAME_TYPE_PAIR(end_datetime, END_DATE),

192 DEF_NAME_TYPE_PAIR(calendar, CALENDAR),

193 DEF_NAME_TYPE_PAIR(timestep_unit, TIMESTEP_UNIT),

194 DEF_NAME_TYPE_PAIR(coupling, COUPLING),

195 DEF_NAME_TYPE_PAIR(debug, DEBUG))

196

197DEF_NAME_TYPE_PAIRS(

198 yaml_couple_keys,

199 DEF_NAME_TYPE_PAIR(source, SOURCE_NAME),

200 DEF_NAME_TYPE_PAIR(src_component, SOURCE_COMPONENT),

201 DEF_NAME_TYPE_PAIR(src_grid, SOURCE_GRID),

202 DEF_NAME_TYPE_PAIR(target, TARGET_NAMES),

203 DEF_NAME_TYPE_PAIR(tgt_component, TARGET_COMPONENT),

204 DEF_NAME_TYPE_PAIR(tgt_grid, TARGET_GRID),

205 DEF_NAME_TYPE_PAIR(field, FIELD),

206 DEF_NAME_TYPE_PAIR(coupling_period, COUPLING_PERIOD),

207 DEF_NAME_TYPE_PAIR(time_reduction, TIME_REDUCTION),

208 DEF_NAME_TYPE_PAIR(src_lag, SOURCE_LAG),

209 DEF_NAME_TYPE_PAIR(tgt_lag, TARGET_LAG),

210 DEF_NAME_TYPE_PAIR(weight_file, WEIGHT_FILE_DATA),

211 DEF_NAME_TYPE_PAIR(weight_file_name, WEIGHT_FILE_NAME),

212 DEF_NAME_TYPE_PAIR(weight_file_on_existing, WEIGHT_FILE_ON_EXISTING),

213 DEF_NAME_TYPE_PAIR(mapping_side, MAPPING_SIDE),

214 DEF_NAME_TYPE_PAIR(scale_factor, SCALE_FACTOR),

215 DEF_NAME_TYPE_PAIR(scale_summand, SCALE_SUMMAND),

216 DEF_NAME_TYPE_PAIR(interpolation, INTERPOLATION),

217 DEF_NAME_TYPE_PAIR(src_mask_name, SOURCE_MASK_NAME),

218 DEF_NAME_TYPE_PAIR(src_mask_names, SOURCE_MASK_NAMES),

219 DEF_NAME_TYPE_PAIR(tgt_mask_name, TARGET_MASK_NAME),

220 DEF_NAME_TYPE_PAIR(yaxt_exchanger, YAXT_EXCHANGER_NAME),

221 DEF_NAME_TYPE_PAIR(yaxt_exchanger_name, YAXT_EXCHANGER_NAME),

222 DEF_NAME_TYPE_PAIR(collection_selection, COLLECTION_SELECTION),

223 DEF_NAME_TYPE_PAIR(use_raw_exchange, USE_RAW_EXCHANGE))

224

225DEF_NAME_TYPE_PAIRS(

226 yaml_debug_sync_loc_keys,

227 DEF_NAME_TYPE_PAIR(def_comp, SYNC_LOC_DEF_COMP),

228 DEF_NAME_TYPE_PAIR(DEF_COMP, SYNC_LOC_DEF_COMP),

229 DEF_NAME_TYPE_PAIR(def_comps, SYNC_LOC_DEF_COMP),

230 DEF_NAME_TYPE_PAIR(DEF_COMPS, SYNC_LOC_DEF_COMP),

231 DEF_NAME_TYPE_PAIR(sync_def, SYNC_LOC_SYNC_DEF),

232 DEF_NAME_TYPE_PAIR(SYNC_DEF, SYNC_LOC_SYNC_DEF),

233 DEF_NAME_TYPE_PAIR(enddef, SYNC_LOC_ENDDEF),

234 DEF_NAME_TYPE_PAIR(ENDDEF, SYNC_LOC_ENDDEF))

235

236DEF_NAME_TYPE_PAIRS(

237 yaml_debug_output_grid_keys,

238 DEF_NAME_TYPE_PAIR(grid_name, OUTPUT_GRID_GRID_NAME),

239 DEF_NAME_TYPE_PAIR(file_name, OUTPUT_GRID_FILE_NAME))

240

241DEF_NAME_TYPE_PAIRS(

242 bool_names,

243 DEF_NAME_TYPE_PAIR(true, true),

244 DEF_NAME_TYPE_PAIR(TRUE, true),

245 DEF_NAME_TYPE_PAIR(yes, true),

246 DEF_NAME_TYPE_PAIR(YES, true),

247 DEF_NAME_TYPE_PAIR(false, false),

248 DEF_NAME_TYPE_PAIR(FALSE, false),

249 DEF_NAME_TYPE_PAIR(no, false),

250 DEF_NAME_TYPE_PAIR(NO, false))

251

252DEF_NAME_TYPE_PAIRS(

253 timestep_units,

254 DEF_NAME_TYPE_PAIR(millisecond, C_MILLISECOND),

255 DEF_NAME_TYPE_PAIR(second, C_SECOND),

256 DEF_NAME_TYPE_PAIR(minute, C_MINUTE),

257 DEF_NAME_TYPE_PAIR(hour, C_HOUR),

258 DEF_NAME_TYPE_PAIR(day, C_DAY),

259 DEF_NAME_TYPE_PAIR(month, C_MONTH),

260 DEF_NAME_TYPE_PAIR(year, C_YEAR),

261 DEF_NAME_TYPE_PAIR(ISO_format, C_ISO_FORMAT))

262

263DEF_NAME_TYPE_PAIRS(

264 time_operations,

265 DEF_NAME_TYPE_PAIR(accumulate, TIME_ACCUMULATE),

266 DEF_NAME_TYPE_PAIR(average, TIME_AVERAGE),

267 DEF_NAME_TYPE_PAIR(minimum, TIME_MINIMUM),

268 DEF_NAME_TYPE_PAIR(maximum, TIME_MAXIMUM),

269 DEF_NAME_TYPE_PAIR(none, TIME_NONE))

270

271DEF_NAME_TYPE_PAIRS(

272 calendar_types,

273 DEF_NAME_TYPE_PAIR(proleptic-gregorian, PROLEPTIC_GREGORIAN),

274 DEF_NAME_TYPE_PAIR(360d, YEAR_OF_360_DAYS),

275 DEF_NAME_TYPE_PAIR(365d, YEAR_OF_365_DAYS))

276

277DEF_NAME_TYPE_PAIRS(

278 mapping_sides,

279 DEF_NAME_TYPE_PAIR(source, 1),

280 DEF_NAME_TYPE_PAIR(target, 0))

281

282DEF_NAME_TYPE_PAIRS(

283 yaml_debug_keys,

284 DEF_NAME_TYPE_PAIR(global_config, GLOBAL_CONFIG),

285 DEF_NAME_TYPE_PAIR(output_grids, OUTPUT_GRIDS),

286 DEF_NAME_TYPE_PAIR(missing_definition_is_fatal, MISSING_DEF),

287 DEF_NAME_TYPE_PAIR(apply_coordinate_check, APPLY_COORD_CHECK),

288 DEF_NAME_TYPE_PAIR(coordinates_mismatch_is_fatal, COORDS_MISMATCH_FATAL))

289

290DEF_NAME_TYPE_PAIRS(

291 config_filetypes,

292 DEF_NAME_TYPE_PAIR(yaml, YAC_TEXT_FILETYPE_YAML),

293 DEF_NAME_TYPE_PAIR(YAML, YAC_TEXT_FILETYPE_YAML),

294 DEF_NAME_TYPE_PAIR(json, YAC_TEXT_FILETYPE_JSON),

295 DEF_NAME_TYPE_PAIR(JSON, YAC_TEXT_FILETYPE_JSON))

296

297DEF_NAME_TYPE_PAIRS(

298 role_types,

299 DEF_NAME_TYPE_PAIR(target, TARGET),

300 DEF_NAME_TYPE_PAIR(source, SOURCE),

301 DEF_NAME_TYPE_PAIR(nothing, NOTHING))

302

303DEF_NAME_TYPE_PAIRS(

304 yaml_comp_grid_names_keys,

305 DEF_NAME_TYPE_PAIR(component, COMP_NAME),

306 DEF_NAME_TYPE_PAIR(grid, GRID_NAMES))

307

308DEF_NAME_TYPE_PAIRS(

309 yaml_weight_file_data_keys,

310 DEF_NAME_TYPE_PAIR(name, WEIGHT_FILE_DATA_NAME),

311 DEF_NAME_TYPE_PAIR(on_existing, WEIGHT_FILE_DATA_ON_EXISTING))

312

313DEF_NAME_TYPE_PAIRS(

314 weight_file_on_existing_types,

315 DEF_NAME_TYPE_PAIR(error, YAC_WEIGHT_FILE_ERROR),

316 DEF_NAME_TYPE_PAIR(keep, YAC_WEIGHT_FILE_KEEP),

317 DEF_NAME_TYPE_PAIR(overwrite, YAC_WEIGHT_FILE_OVERWRITE))

318

319// definition of some assert macros

320#define YAML_ASSERT(CHECK, MSG) \

321 YAC_ASSERT_F( \

322 CHECK, MSG "in YAML configuration file \"%s\"", yaml_filename)

323#define YAML_ASSERT_F(CHECK, MSG, ...) \

324 YAC_ASSERT_F( \

325 CHECK, MSG "in YAML configuration file \"%s\"", __VA_ARGS__, yaml_filename)

326#define YAML_UNREACHABLE_DEFAULT(MSG) \

327 YAC_UNREACHABLE_DEFAULT_F( \

328 MSG "in YAML configuration file \"%s\"", yaml_filename)

329#define YAML_UNREACHABLE_DEFAULT_F(MSG, ...) \

330 YAC_UNREACHABLE_DEFAULT_F( \

331 MSG "in YAML configuration file \"%s\"", __VA_ARGS__, yaml_filename)

332

333static char const * yaml_parse_string_value(

334 fy_node_t value_node, char const * name, char const * yaml_filename) {

335

336 YAML_ASSERT_F(

337 value_node && fy_node_is_scalar(value_node),

338 "unsupported node type for \"%s\" (the node is expected to be scalar)",

339 name);

340

341 return fy_node_get_scalar0(value_node);

342}

344static calendarType yaml_parse_calendar_value(

345 fy_node_t value_node, char const * key_name, char const * yaml_filename) {

346

347 char const * calendar_name =

348 yaml_parse_string_value(value_node, key_name, yaml_filename);

349

350 int calendar_type =

351 yac_name_type_pair_get_type(

352 calendar_types, calendar_types_size, calendar_name);

353

354 YAML_ASSERT_F(

355 calendar_type != INT_MAX,

356 "\"%s\" is not a valid calendar name", calendar_name);

357

358 return (calendarType)calendar_type;

359}

361static char const * yaml_parse_timestep_value(

362 fy_node_t value_node, char const * key_name, char const * yaml_filename,

363 enum yac_time_unit_type time_unit) {

364

365 YAML_ASSERT(

366 time_unit != TIME_UNIT_UNDEFINED, "time unit is not yet defined");

367 YAML_ASSERT_F(

368 value_node && fy_node_is_scalar(value_node),

369 "unsupported node type for \"%s\" (the node is expected to be scalar)",

370 key_name);

371 char const * timestep =

372 yaml_parse_string_value(value_node, key_name, yaml_filename);

373 char const * timestep_iso =

374 yac_time_to_ISO(timestep, time_unit);

375

376 YAML_ASSERT_F(

377 timestep_iso, "valid to convert timestep \"%s\" to ISO 8601 format",

378 timestep);

379

380 return xstrdup(timestep_iso);

381}

383static enum yac_time_unit_type yaml_parse_timestep_unit_value(

384 fy_node_t value_node, char const * key_name, char const * yaml_filename) {

385

386 char const * timestep_unit_str =

387 yaml_parse_string_value(value_node, key_name, yaml_filename);

388

389 int timestep_unit =

390 yac_name_type_pair_get_type(

391 timestep_units, timestep_units_size, timestep_unit_str);

392

393 YAML_ASSERT_F(

394 timestep_unit != INT_MAX,

395 "\"%s\" is not a valid time step unit", timestep_unit_str);

396

397 return (enum yac_time_unit_type)timestep_unit;

398}

400static enum yac_reduction_type yaml_parse_time_reduction_value(

401 fy_node_t value_node, char const * key_name, char const * yaml_filename) {

402

403 char const * time_reduction_str =

404 yaml_parse_string_value(value_node, key_name, yaml_filename);

405

406 int time_reduction =

407 yac_name_type_pair_get_type(

408 time_operations, time_operations_size, time_reduction_str);

409

410 YAML_ASSERT_F(

411 time_reduction != INT_MAX,

412 "\"%s\" is not a valid time reduction type in", time_reduction_str);

413

414 return (enum yac_reduction_type)time_reduction;

415}

417static int yaml_parse_integer_value(

418 fy_node_t value_node, char const * key_name, char const * yaml_filename) {

419

420 char const * integer_str =

421 yaml_parse_string_value(value_node, key_name, yaml_filename);

422

423 char * endptr;

424 long int long_value = strtol(integer_str, &endptr, 10);

425

426 YAML_ASSERT_F(

427 (endptr != integer_str) && (*endptr == '\0') &&

428 (long_value >= INT_MIN) && (long_value <= INT_MAX),

429 "\"%s\" is not a valid integer value", integer_str);

430

431 return (int)long_value;

432}

434static size_t yaml_parse_size_t_value(

435 fy_node_t value_node, char const * key_name, char const * yaml_filename) {

436

437 char const * size_t_str =

438 yaml_parse_string_value(value_node, key_name, yaml_filename);

439

440 errno = 0;

441 char *endptr = NULL;

442 uintmax_t temp = strtoumax(size_t_str, &endptr, 10);

443

444 YAML_ASSERT_F(

445 (errno == 0) && (endptr != size_t_str) && (*endptr == '\0') &&

446 (temp <= SIZE_MAX),

447 "\"%s\" is not a valid size_t value", size_t_str);

448

449 return (size_t)temp;

450}

452static double yaml_parse_double_value(

453 fy_node_t value_node, char const * key_name, char const * yaml_filename) {

454

455 char const * double_str =

456 yaml_parse_string_value(value_node, key_name, yaml_filename);

457

458 char * endptr;

459 double dble_value = strtod(double_str, &endptr);

460

461 YAML_ASSERT_F(

462 (endptr != double_str) && (*endptr == '\0'),

463 "\"%s\" is not a valid double value for \"%s\"", double_str, key_name);

464

465 return dble_value;

466}

468static int yaml_parse_enum_value(

469 struct yac_name_type_pair const * valid_values, size_t num_valid_values,

470 fy_node_t value_node, char const * key_name, char const * yaml_filename) {

471

472 char const * value_str =

473 yaml_parse_string_value(value_node, key_name, yaml_filename);

474

475 int value =

476 yac_name_type_pair_get_type(

477 valid_values, num_valid_values, value_str);

478

479 YAML_ASSERT_F(

480 value != INT_MAX,

481 "\"%s\" is not a valid enum value for \"%s\" ", value_str, key_name);

482

483 return value;

484}

495static void yaml_parse_base_interp_method_node(

496 char const ** interpolation_type_str, fy_node_t * parameter_node,

497 fy_node_t interp_method_node, char const * yaml_filename) {

498

499 fy_node_t interpolation_name_node;

500

501 // determine type of interpolation node

502 switch(fy_node_get_type(interp_method_node)) {

503 YAML_UNREACHABLE_DEFAULT(

504 "unsupported interpolation method node type "

505 "(interpolation methods are expected to be defined as either scalar "

506 "or maps)");

507

508 // interpolation node only contains the name and not parameters

509 case (FYNT_SCALAR):

510 interpolation_name_node = interp_method_node;

511 *parameter_node = NULL;

512 break;

513

514 // interpolation node contains name and parameters

515 case (FYNT_MAPPING):

516

517 YAML_ASSERT(

518 fy_node_mapping_item_count(interp_method_node) == 1,

519 "base interpolation method node is only allowed to have one pair ");

520

521 fy_node_pair_t base_interp_method_pair =

522 fy_node_mapping_get_by_index(interp_method_node, 0);

523

524 interpolation_name_node = fy_node_pair_key(base_interp_method_pair);

525

526 fy_node_t base_interp_method_value_node =

527 fy_node_pair_value(base_interp_method_pair);

528

529 YAML_ASSERT_F(

530 fy_node_is_mapping(base_interp_method_value_node),

531 "unsupported base interpolation method value node type "

532 "for interpolation method \"%s\" "

533 "(interpolation method parameters are expected to be "

534 "defined as maps)",

535 yaml_parse_string_value(

536 interpolation_name_node, "interpolation method name", yaml_filename));

537

538 *parameter_node = base_interp_method_value_node;

539 break;

540 }

541

542 *interpolation_type_str =

543 yaml_parse_string_value(

544 interpolation_name_node, "interpolation method name", yaml_filename);

545}

547static void yaml_set_interp_method_config_param_from_node(

548 struct yac_param * param,

549 fy_node_t value_node,

550 char const * interpolation_name,

551 char const * yaml_filename) {

552

553 char const * param_name = yac_param_get_name(param);

554 enum yac_param_type type =

555 yac_param_get_type(param);

556

557 // if no node is provided, keep the default value for all param types

558 if (fy_node_is_null(value_node)) return;

559

560 switch (type) {

561 YAML_UNREACHABLE_DEFAULT_F(

562 "unsupported parameter type for parameter \"%s\" of interpolation "

563 "method \"%s\"",

564 param_name, interpolation_name);

565 // case (YAC_PARAM_TYPE_EMPTY):

566 // YAML_ASSERT_F(

567 // fy_node_is_null(value_node),

568 // "invalid null parameter value for parameter \"%s\" of interpolation "

569 // "method \"%s\"",

570 // param_name, interpolation_name);

571 // break;

572 case (YAC_PARAM_TYPE_SCALAR): {

573 YAML_ASSERT_F(

574 fy_node_is_scalar(value_node),

575 "invalid scalar parameter value for parameter \"%s\" of interpolation "

576 "method \"%s\"",

577 param_name, interpolation_name);

578

579 int ierr =

580 yac_param_set_scalar(param, fy_node_get_scalar0(value_node));

581 YAML_ASSERT_F(

582 ierr == 0,

583 "failed to set parameter \"%s\" of interpolation method \"%s\": %s",

584 param_name, interpolation_name,

585 yac_param_get_last_error());

586 break;

587 }

588 case (YAC_PARAM_TYPE_STRUCT): {

589 YAML_ASSERT_F(

590 fy_node_is_scalar(value_node) || fy_node_is_mapping(value_node),

591 "invalid parameter value for parameter \"%s\" of interpolation "

592 "method \"%s\" (expected scalar sub-parameter name or map)",

593 param_name, interpolation_name);

594

595 if (fy_node_is_scalar(value_node)) {

596

597 // scalar value is the name of a sub-parameter to activate with defaults

598 char const * sub_parameter_name =

599 yaml_parse_string_value(

600 value_node, "interpolation method parameter name", yaml_filename);

601

602 struct yac_param * sub_param = NULL;

603 int ierr =

604 yac_param_get_sub_by_name(

605 param, sub_parameter_name, &sub_param);

606 YAML_ASSERT_F(

607 ierr == 0,

608 "\"%s\" is not a valid sub-parameter of \"%s\" for interpolation "

609 "method \"%s\": %s",

610 sub_parameter_name, param_name, interpolation_name,

611 yac_param_get_last_error());

612

613 } else {

614

615 void * iter = NULL;

616 fy_node_pair_t parameter_pair;

617 while ((parameter_pair = fy_node_mapping_iterate(value_node, &iter))) {

618

619 char const * sub_parameter_name =

620 yaml_parse_string_value(

621 fy_node_pair_key(parameter_pair),

622 "interpolation method parameter name", yaml_filename);

623

624 struct yac_param * sub_param = NULL;

625 int ierr =

626 yac_param_get_sub_by_name(

627 param, sub_parameter_name, &sub_param);

628 YAML_ASSERT_F(

629 ierr == 0,

630 "\"%s\" is not a valid sub-parameter of \"%s\" for interpolation "

631 "method \"%s\": %s",

632 sub_parameter_name, param_name, interpolation_name,

633 yac_param_get_last_error());

634

635 yaml_set_interp_method_config_param_from_node(

636 sub_param, fy_node_pair_value(parameter_pair),

637 interpolation_name, yaml_filename);

638 }

639 }

640 break;

641 }

642 case (YAC_PARAM_TYPE_LIST): {

643 YAML_ASSERT_F(

644 fy_node_is_scalar(value_node) || fy_node_is_sequence(value_node),

645 "invalid parameter value for parameter \"%s\" of "

646 "interpolation method \"%s\" (expected scalar or sequence)",

647 param_name, interpolation_name);

648

649 size_t count = fy_node_is_scalar(value_node)?1:

650 (size_t)fy_node_sequence_item_count(value_node);

651 for (size_t i = 0; i < count; ++i) {

652 struct yac_param * sub_param = NULL;

653 int ierr = yac_param_append(param, &sub_param);

654 YAML_ASSERT_F(

655 ierr == 0,

656 "failed to append to parameter \"%s\" of interpolation method "

657 "\"%s\": %s",

658 param_name, interpolation_name,

659 yac_param_get_last_error());

660

661 yaml_set_interp_method_config_param_from_node(

662 sub_param,

663 fy_node_is_scalar(value_node)?value_node:

664 fy_node_sequence_get_by_index(value_node, (int)i),

665 interpolation_name, yaml_filename);

666 }

667 break;

668 }

669 }

670}

672static void yaml_parse_interp_method(

673 struct yac_interp_stack_config * interp_stack,

674 fy_node_t interp_method_node, char const * yaml_filename) {

675

676 char const * interpolation_type_str;

677 fy_node_t parameter_node;

678

679 // get name of interpolations

680 yaml_parse_base_interp_method_node(

681 &interpolation_type_str, &parameter_node,

682 interp_method_node, yaml_filename);

683

684 // generate interpolation method configuration with default values based

685 // on the interpolation name

686 struct yac_interp_method_config * method_config =

687 yac_interp_method_config_default_from_name_new(interpolation_type_str);

688

689 // get the root parameter of the interpolation method configuration and set

690 // the user-provided parameter values from the YAML node

691 struct yac_param * root_param =

692 yac_interp_method_config_get_param(method_config);

693 yaml_set_interp_method_config_param_from_node(

694 root_param, parameter_node, interpolation_type_str, yaml_filename);

695

696

697 // add the interpolation method configuration to the interpolation stack

698 yac_interp_stack_config_add(interp_stack, method_config);

699}

701static void yaml_parse_interp_stack_value(

702 struct yac_interp_stack_config * interp_stack,

703 fy_node_t interp_stack_node, char const * yaml_filename) {

704

705 YAML_ASSERT(

706 fy_node_is_sequence(interp_stack_node),

707 "unsupported interpolation stack node type"

708 "(interpolation stacks are expected to be defined as a sequence)");

709

710 // parse couplings

711 void * iter = NULL;

712 fy_node_t interp_stack_item;

713 while ((interp_stack_item =

714 fy_node_sequence_iterate(interp_stack_node, &iter)))

715 yaml_parse_interp_method(

716 interp_stack, interp_stack_item, yaml_filename);

717}

719static struct field_couple_field_names yaml_parse_field_name(

720 fy_node_t field_node, const char * yaml_filename) {

721

722 struct field_couple_field_names field_name;

723

724 switch(fy_node_get_type(field_node)) {

725

726 YAML_UNREACHABLE_DEFAULT(

727 "unsupported field name node type "

728 "(field name is either scalars or a map)");

729

730 // the node contains one name for both source and target field

731 case (FYNT_SCALAR): {

732

733 field_name.src =

734 ((field_name.tgt =

735 yaml_parse_string_value(field_node, "field name", yaml_filename)));

736

737 break;

738 }

739

740 // the node contains different names for the source and target field

741 case (FYNT_MAPPING): {

742

743 field_name.src =

744 fy_node_mapping_lookup_scalar0_by_simple_key(

745 field_node, "src", (size_t)-1);

746 field_name.tgt =

747 fy_node_mapping_lookup_scalar0_by_simple_key(

748 field_node, "tgt", (size_t)-1);

749

750 YAML_ASSERT(

751 field_name.src && field_name.tgt &&

752 (fy_node_mapping_item_count(field_node) == 2),

753 "invalid field name mapping node "

754 "(field name mapping node has to contain two maps "

755 "with the keys \"src\" and \"tgt\")")

756

757 break;

758 }

759 }

760

761 return field_name;

762}

764static void yaml_parse_size_t_sequence(

765 size_t ** values, size_t * num_values,

766 fy_node_t values_node, char const * sequence_name,

767 const char * yaml_filename) {

768

769 YAML_ASSERT_F(

770 (*values == NULL) && (*num_values == 0),

771 "values have already been set for sequence \"%s\"",

772 sequence_name);

773

774 // handle sequence node

775 if (fy_node_is_sequence(values_node)) {

776

777 *num_values = (size_t)fy_node_sequence_item_count(values_node);

778 *values = xmalloc(*num_values * sizeof(**values));

779

780 for (size_t value_idx = 0; value_idx < *num_values; ++value_idx)

781 (*values)[value_idx] =

782 yaml_parse_size_t_value(

783 fy_node_sequence_get_by_index(values_node, value_idx),

784 sequence_name, yaml_filename);

785 } else {

786 // single scalar node

787 *num_values = 1;

788 *values = xmalloc(sizeof(**values));

789 **values=

790 yaml_parse_size_t_value(values_node, sequence_name, yaml_filename);

791 }

792}

794static void yaml_parse_collection_selection_sequence(

795 struct yac_collection_selection ** collection_selection,

796 fy_node_t values_node, char const * sequence_name,

797 const char * yaml_filename) {

798

799 YAML_ASSERT_F(

800 *collection_selection == NULL,

801 "values have already been set for sequence \"%s\"",

802 sequence_name);

803

804 size_t collection_size = 0;

805 size_t * indices = NULL;

806

807 yaml_parse_size_t_sequence(

808 &indices, &collection_size, values_node, sequence_name, yaml_filename);

809

810 *collection_selection =

811 yac_collection_selection_new(collection_size, indices);

812

813 free(indices);

814}

816static void yaml_parse_string_sequence(

817 char const *** values, size_t * num_values,

818 fy_node_t values_node, char const * sequence_name,

819 const char * yaml_filename) {

820

821 YAML_ASSERT_F(

822 (*values == NULL) && (*num_values == 0),

823 "values have already been set for sequence \"%s\"",

824 sequence_name);

825

826 // if the field node contains multiple fields

827 if (fy_node_is_sequence(values_node)) {

828

829 *num_values = (size_t)fy_node_sequence_item_count(values_node);

830 *values = xmalloc(*num_values * sizeof(**values));

831 for (size_t value_idx = 0; value_idx < *num_values; ++value_idx)

832 (*values)[value_idx] =

833 yaml_parse_string_value(

834 fy_node_sequence_get_by_index(values_node, value_idx),

835 sequence_name, yaml_filename);

836 } else {

837 *num_values = 1;

838 *values = xmalloc(sizeof(**values));

839 **values =

840 yaml_parse_string_value(

841 values_node, sequence_name, yaml_filename);

842 }

843}

845static void yaml_parse_field_names(

846 struct field_couple_field_names ** field_names,

847 size_t * num_field_names, fy_node_t fields_node,

848 const char * yaml_filename) {

849

850 // if the field node contains multiple fields

851 if (fy_node_is_sequence(fields_node)) {

852

853 size_t start_idx = *num_field_names;

854 *num_field_names += (size_t)fy_node_sequence_item_count(fields_node);

855 *field_names =

856 xrealloc(*field_names, *num_field_names * sizeof(**field_names));

857 for (size_t i = start_idx; i < *num_field_names; ++i)

858 (*field_names)[i] =

859 yaml_parse_field_name(

860 fy_node_sequence_get_by_index(fields_node, i), yaml_filename);

861 } else {

862 ++*num_field_names;

863 *field_names =

864 xrealloc(*field_names, *num_field_names * sizeof(**field_names));

865 (*field_names)[*num_field_names-1] =

866 yaml_parse_field_name(fields_node, yaml_filename);

867 }

868}

870static void yaml_parse_comp_grid_names(

871 char const ** comp_name, char const *** grid_names, size_t * num_grid_names,

872 fy_node_t values_node, char const * type_name, const char * yaml_filename,

873 int allow_multiple_grids) {

874

875 YAML_ASSERT_F(

876 *comp_name == NULL, "%s component name already set", type_name);

877 YAML_ASSERT_F(

878 (*grid_names == NULL) && (*num_grid_names == 0),

879 "%s grid names already set", type_name);

880

881 YAML_ASSERT(

882 fy_node_is_mapping(values_node),

883 "unsupported component/grid names node type (has to be a map)");

884

885 // parse component/grid names

886 void * iter = NULL;

887 fy_node_pair_t pair;

888 while((pair = fy_node_mapping_iterate(values_node, &iter))) {

889

890 enum yaml_comp_grid_names_key_types comp_grid_names_key_type =

891 (enum yaml_comp_grid_names_key_types)

892 yaml_parse_enum_value(

893 yaml_comp_grid_names_keys, yaml_comp_grid_names_keys_size,

894 fy_node_pair_key(pair),

895 "component/grid names parameter name", yaml_filename);

896 char const * comp_grid_names_key_name =

897 yac_name_type_pair_get_name(

898 yaml_comp_grid_names_keys, yaml_comp_grid_names_keys_size,

899 comp_grid_names_key_type);

900

901 fy_node_t name_node = fy_node_pair_value(pair);

902

903 switch(comp_grid_names_key_type) {

904 YAML_UNREACHABLE_DEFAULT("invalid component/grid name key type");

905 case(COMP_NAME):

906 *comp_name =

907 yaml_parse_string_value(

908 name_node, comp_grid_names_key_name, yaml_filename);

909 break;

910 case(GRID_NAMES):

911 if (allow_multiple_grids) {

912 yaml_parse_string_sequence(

913 grid_names, num_grid_names,

914 name_node, comp_grid_names_key_name, yaml_filename);

915 } else {

916 *num_grid_names = 1;

917 *grid_names = xmalloc(sizeof(**grid_names));

918 **grid_names =

919 yaml_parse_string_value(

920 name_node, comp_grid_names_key_name, yaml_filename);

921 }

922 break;

923 }

924 }

925}

927static void yaml_parse_weight_file_data(

928 char const ** weight_file_name,

929 enum yac_weight_file_on_existing * on_existing,

930 fy_node_t values_node, char const * type_name, const char * yaml_filename) {

931

932 YAML_ASSERT_F(

933 *weight_file_name == NULL, "%s weight file name already set", type_name);

934 YAML_ASSERT_F(

935 *on_existing == YAC_WEIGHT_FILE_UNDEFINED,

936 "%s \"on existing\" already set ", type_name);

937

938 YAML_ASSERT(

939 fy_node_is_mapping(values_node),

940 "unsupported weight file data node type (has to be a map)");

941

942 // parse component/grid names

943 void * iter = NULL;

944 fy_node_pair_t pair;

945 while((pair = fy_node_mapping_iterate(values_node, &iter))) {

946

947 enum yaml_weight_file_data_key_types weight_file_data_key_type =

948 (enum yaml_weight_file_data_key_types)

949 yaml_parse_enum_value(

950 yaml_weight_file_data_keys, yaml_weight_file_data_keys_size,

951 fy_node_pair_key(pair),

952 "weight file data parameter name", yaml_filename);

953 char const * weight_file_data_key_name =

954 yac_name_type_pair_get_name(

955 yaml_weight_file_data_keys, yaml_weight_file_data_keys_size,

956 weight_file_data_key_type);

957

958 fy_node_t weight_file_data_node = fy_node_pair_value(pair);

959

960 switch(weight_file_data_key_type) {

961 YAML_UNREACHABLE_DEFAULT("invalid weight file data key type");

962 case(WEIGHT_FILE_DATA_NAME):

963 *weight_file_name =

964 yaml_parse_string_value(

965 weight_file_data_node, weight_file_data_key_name, yaml_filename);

966 break;

967 case(WEIGHT_FILE_DATA_ON_EXISTING):

968 *on_existing =

969 (enum yac_weight_file_on_existing)

970 yaml_parse_enum_value(

971 weight_file_on_existing_types,

972 weight_file_on_existing_types_size,

973 weight_file_data_node, weight_file_data_key_name,

974 yaml_filename);

975 break;

976 }

977 }

978}

980static void yaml_parse_couple_map_pair(

981 struct field_couple_buffer * field_buffer,

982 fy_node_pair_t couple_pair, const char * yaml_filename,

983 enum yac_time_unit_type time_unit) {

984

985 enum yaml_couple_key_types couple_key_type =

986 (enum yaml_couple_key_types)

987 yaml_parse_enum_value(

988 yaml_couple_keys, yaml_couple_keys_size,

989 fy_node_pair_key(couple_pair),

990 "couple configuration parameter name", yaml_filename);

991 char const * couple_key_name =

992 yac_name_type_pair_get_name(

993 yaml_couple_keys, yaml_couple_keys_size, couple_key_type);

994

995 fy_node_t value_node = fy_node_pair_value(couple_pair);

996

997 switch (couple_key_type) {

998 YAML_UNREACHABLE_DEFAULT("invalid couple key type");

999 case (SOURCE_NAME): {

1000 char const ** src_grid_names = NULL;

1001 size_t num_src_grid_names = 0;

1002 int const allow_multiple_grids = 0;

1003 yaml_parse_comp_grid_names(

1004 &(field_buffer->src.comp_name),

1005 &src_grid_names,

1006 &num_src_grid_names,

1007 value_node, couple_key_name, yaml_filename, allow_multiple_grids);

1008 field_buffer->src.grid_name = src_grid_names[0];

1009 free((void*)src_grid_names);

1010 break;

1011 }

1012 case (SOURCE_COMPONENT):

1013 field_buffer->src.comp_name =

1014 yaml_parse_string_value(value_node, couple_key_name, yaml_filename);

1015 break;

1016 case (SOURCE_GRID):

1017 YAML_ASSERT_F(

1018 field_buffer->src.grid_name == NULL,

1019 "%s has already been set", couple_key_name);

1020 field_buffer->src.grid_name =

1021 yaml_parse_string_value(value_node, couple_key_name, yaml_filename);

1022 break;

1023 case (TARGET_NAMES): {

1024 int const allow_multiple_grids = 1;

1025 yaml_parse_comp_grid_names(

1026 &(field_buffer->tgt.comp_name),

1027 &(field_buffer->tgt.grid.name),

1028 &(field_buffer->tgt.grid.count),

1029 value_node, couple_key_name, yaml_filename, allow_multiple_grids);

1030 break;

1031 }

1032 case (TARGET_COMPONENT):

1033 field_buffer->tgt.comp_name =

1034 yaml_parse_string_value(value_node, couple_key_name, yaml_filename);

1035 break;

1036 case (TARGET_GRID):

1037 yaml_parse_string_sequence(

1038 &field_buffer->tgt.grid.name, &field_buffer->tgt.grid.count,

1039 value_node, couple_key_name, yaml_filename);

1040 break;

1041 case (FIELD):

1042 yaml_parse_field_names(

1043 &(field_buffer->field_names),

1044 &(field_buffer->num_field_names),

1045 value_node, yaml_filename);

1046 break;

1047 case (COUPLING_PERIOD):

1048 field_buffer->coupling_period =

1049 yaml_parse_timestep_value(

1050 value_node, couple_key_name, yaml_filename, time_unit);

1051 break;

1052 case (TIME_REDUCTION):

1053 field_buffer->time_reduction =

1054 yaml_parse_time_reduction_value(

1055 value_node, couple_key_name, yaml_filename);

1056 break;

1057 case (SOURCE_LAG):

1058 field_buffer->src.lag =

1059 yaml_parse_integer_value(

1060 value_node, couple_key_name, yaml_filename);

1061 break;

1062 case (TARGET_LAG):

1063 field_buffer->tgt.lag =

1064 yaml_parse_integer_value(

1065 value_node, couple_key_name, yaml_filename);

1066 break;

1067 case (WEIGHT_FILE_NAME):

1068 field_buffer->weight_file.name =

1069 yaml_parse_string_value(

1070 value_node, couple_key_name, yaml_filename);

1071 break;

1072 case (WEIGHT_FILE_ON_EXISTING):

1073 field_buffer->weight_file.on_existing =

1074 (enum yac_weight_file_on_existing)

1075 yaml_parse_enum_value(

1076 weight_file_on_existing_types,

1077 weight_file_on_existing_types_size,

1078 value_node, couple_key_name, yaml_filename);

1079 break;

1080 case (WEIGHT_FILE_DATA):

1081 yaml_parse_weight_file_data(

1082 &(field_buffer->weight_file.name),

1083 &(field_buffer->weight_file.on_existing),

1084 value_node, couple_key_name, yaml_filename);

1085 break;

1086 case (MAPPING_SIDE):

1087 field_buffer->mapping_on_source =

1088 yaml_parse_enum_value(

1089 mapping_sides, mapping_sides_size,

1090 value_node, couple_key_name, yaml_filename);

1091 break;

1092 case (SCALE_FACTOR):

1093 field_buffer->scale_factor =

1094 yaml_parse_double_value(

1095 value_node, couple_key_name, yaml_filename);

1096 break;

1097 case (SCALE_SUMMAND):

1098 field_buffer->scale_summand =

1099 yaml_parse_double_value(

1100 value_node, couple_key_name, yaml_filename);

1101 break;

1102 case (INTERPOLATION):

1103 yaml_parse_interp_stack_value(

1104 field_buffer->interp_stack, value_node, yaml_filename);

1105 break;

1106 case (SOURCE_MASK_NAME):

1107 case (SOURCE_MASK_NAMES):

1108 yaml_parse_string_sequence(

1109 &(field_buffer->src_mask_names),

1110 &(field_buffer->num_src_mask_names),

1111 value_node, couple_key_name, yaml_filename);

1112 break;

1113 case (TARGET_MASK_NAME):

1114 field_buffer->tgt_mask_name =

1115 yaml_parse_string_value(

1116 value_node, couple_key_name, yaml_filename);

1117 break;

1118 case (YAXT_EXCHANGER_NAME):

1119 field_buffer->yaxt_exchanger_name =

1120 yaml_parse_string_value(

1121 value_node, couple_key_name, yaml_filename);

1122 break;

1123 case (COLLECTION_SELECTION):

1124 yaml_parse_collection_selection_sequence(

1125 &field_buffer->collection_selection,

1126 value_node, couple_key_name, yaml_filename);

1127 break;

1128 case (USE_RAW_EXCHANGE):

1129 field_buffer->use_raw_exchange =

1130 yaml_parse_enum_value(

1131 bool_names, bool_names_size,

1132 value_node, couple_key_name, yaml_filename);

1133 break;

1134 }

1135}

1137static void yaml_parse_couple(

1138 struct yac_couple_config * couple_config, fy_node_t couple_node,

1139 char const * yaml_filename, enum yac_time_unit_type time_unit) {

1140

1141 YAML_ASSERT(

1142 fy_node_is_mapping(couple_node),

1143 "unsupported couple node type "

1144 "(couples are expected to be defined as a mapping)");

1145

1146 // initialise field configuration buffer with default values

1147 struct field_couple_buffer field_buffer = {

1148 .src.comp_name = NULL,

1149 .src.grid_name = NULL,

1150 .tgt.comp_name = NULL,

1151 .tgt.grid.name = NULL,

1152 .tgt.grid.count = 0,

1153 .field_names = NULL,

1154 .num_field_names = 0,

1155 .coupling_period = NULL,

1156 .time_reduction = TIME_NONE,

1157 .interp_stack = yac_interp_stack_config_new(),

1158 .src.lag = 0,

1159 .tgt.lag = 0,

1160 .weight_file.name = NULL,

1161 .weight_file.on_existing = YAC_WEIGHT_FILE_UNDEFINED,

1162 .mapping_on_source = 1,

1163 .scale_factor = 1.0,

1164 .scale_summand = 0.0,

1165 .src_mask_names = NULL,

1166 .num_src_mask_names = 0,

1167 .tgt_mask_name = NULL,

1168 .yaxt_exchanger_name = NULL,

1169 .collection_selection = NULL,

1170 .use_raw_exchange = 0};

1171

1172 // parse couple

1173 void * iter = NULL;

1174 fy_node_pair_t pair;

1175 while ((pair = fy_node_mapping_iterate(couple_node, &iter)))

1176 yaml_parse_couple_map_pair(

1177 &field_buffer, pair, yaml_filename, time_unit);

1178

1179 YAML_ASSERT(

1180 field_buffer.src.comp_name, "missing source component name");

1181 YAML_ASSERT_F(

1182 field_buffer.src.grid_name != NULL,

1183 "missing source grid name (component \"%s\")",

1184 field_buffer.src.comp_name);

1185 YAML_ASSERT_F(

1186 field_buffer.src.grid_name[0] != '\0',

1187 "invalid source grid name (component \"%s\")",

1188 field_buffer.src.comp_name);

1189 YAML_ASSERT(

1190 field_buffer.tgt.comp_name,

1191 "missing target component name");

1192 YAML_ASSERT_F(

1193 field_buffer.tgt.grid.count > 0,

1194 "missing target grid name (component \"%s\")",

1195 field_buffer.tgt.comp_name);

1196 for (size_t i = 0; i < field_buffer.tgt.grid.count; ++i)

1197 YAML_ASSERT_F(

1198 (field_buffer.tgt.grid.name[i] != NULL) &&

1199 (field_buffer.tgt.grid.name[i][0] != '\0'),

1200 "invalid target grid name (component \"%s\" grid idx %zu)",

1201 field_buffer.tgt.comp_name, i);

1202 YAML_ASSERT_F(

1203 field_buffer.num_field_names > 0,

1204 "missing field names "

1205 "(source component \"%s\" source grid \"%s\" "

1206 "target component \"%s\" target grid \"%s\")",

1207 field_buffer.src.comp_name, field_buffer.src.grid_name,

1208 field_buffer.tgt.comp_name, field_buffer.tgt.grid.name[0]);

1209 YAML_ASSERT_F(

1210 field_buffer.coupling_period,

1211 "missing coupling period "

1212 "(source component \"%s\" source grid \"%s\" "

1213 "target component \"%s\" target grid \"%s\")",

1214 field_buffer.src.comp_name, field_buffer.src.grid_name,

1215 field_buffer.tgt.comp_name, field_buffer.tgt.grid.name[0]);

1216

1217 for (size_t i = 0; i < field_buffer.num_field_names; ++i)

1218 for (size_t k = 0; k < field_buffer.tgt.grid.count; ++k)

1219 yac_couple_config_def_couple(

1220 couple_config,

1221 field_buffer.src.comp_name,

1222 field_buffer.src.grid_name,

1223 field_buffer.field_names[i].src,

1224 field_buffer.tgt.comp_name,

1225 field_buffer.tgt.grid.name[k],

1226 field_buffer.field_names[i].tgt,

1227 field_buffer.coupling_period,

1228 field_buffer.time_reduction,

1229 field_buffer.interp_stack,

1230 field_buffer.src.lag,

1231 field_buffer.tgt.lag,

1232 field_buffer.weight_file.name,

1233 (field_buffer.weight_file.on_existing == YAC_WEIGHT_FILE_UNDEFINED)?

1234 YAC_WEIGHT_FILE_ON_EXISTING_DEFAULT_VALUE:

1235 field_buffer.weight_file.on_existing,

1236 field_buffer.mapping_on_source,

1237 field_buffer.scale_factor,

1238 field_buffer.scale_summand,

1239 field_buffer.num_src_mask_names,

1240 field_buffer.src_mask_names,

1241 field_buffer.tgt_mask_name,

1242 field_buffer.yaxt_exchanger_name,

1243 field_buffer.collection_selection,

1244 field_buffer.use_raw_exchange);

1245

1246 // cleanup

1247 yac_collection_selection_delete(field_buffer.collection_selection);

1248 free((void*)field_buffer.tgt.grid.name);

1249 free((void*)field_buffer.field_names);

1250 free((void*)field_buffer.coupling_period);

1251 yac_interp_stack_config_delete(field_buffer.interp_stack);

1252 free((void*)field_buffer.src_mask_names);

1253}

1255static void yaml_parse_coupling(

1256 struct yac_couple_config * couple_config,

1257 fy_node_t coupling_node, char const * yaml_filename,

1258 enum yac_time_unit_type time_unit) {

1259

1260 // check if the coupling node is empty -> nothing to be read

1261 if (!coupling_node) return;

1262

1263 YAML_ASSERT(

1264 fy_node_is_sequence(coupling_node),

1265 "unsupported coupling node type "

1266 "(couplings are expected to be defined as a sequence)");

1267

1268 // parse couplings

1269 void * iter = NULL;

1270 fy_node_t couple_node;

1271 while ((couple_node = fy_node_sequence_iterate(coupling_node, &iter)))

1272 yaml_parse_couple(couple_config, couple_node, yaml_filename, time_unit);

1273}

1275static struct debug_config_file yaml_parse_config_file_value(

1276 fy_node_t config_file_node, char const * file_type_name,

1277 const char * yaml_filename) {

1278

1279 struct debug_config_file config_file =

1280 {.name = NULL, .type = YAC_TEXT_FILETYPE_YAML, .include_definitions = 0};

1281

1282 char * str_buffer = xmalloc(strlen(file_type_name) + 32);

1283

1284 switch(fy_node_get_type(config_file_node)) {

1285

1286 YAML_UNREACHABLE_DEFAULT_F(

1287 "unsupported config file node type "

1288 "(%s is either scalar or a map)", file_type_name);

1289

1290 // the node contains only the filename

1291 case (FYNT_SCALAR): {

1292

1293 config_file.name =

1294 yaml_parse_string_value(

1295 config_file_node,

1296 strcat(strcpy(str_buffer, file_type_name), " name"),

1297 yaml_filename);

1298

1299 break;

1300 }

1301

1302 // the node contains the name and the type

1303 case (FYNT_MAPPING): {

1304

1305 fy_node_t filename_node =

1306 fy_node_mapping_lookup_by_string(

1307 config_file_node, "filename", (size_t)-1);

1308 fy_node_t filetype_node =

1309 fy_node_mapping_lookup_by_string(

1310 config_file_node, "filetype", (size_t)-1);

1311 fy_node_t include_definitions_node =

1312 fy_node_mapping_lookup_by_string(

1313 config_file_node, "include_definitions", (size_t)-1);

1314

1315 YAML_ASSERT_F(

1316 filename_node,

1317 "invalid %s mapping node "

1318 "(global config file mapping node has to include a map "

1319 "with the keys \"filename\")", file_type_name)

1320

1321 config_file.name =

1322 yaml_parse_string_value(

1323 filename_node, strcat(strcpy(str_buffer, file_type_name), " name"),

1324 yaml_filename);

1325 config_file.type =

1326 (filetype_node)?

1327 (enum yac_text_filetype)

1328 yaml_parse_enum_value(

1329 config_filetypes, config_filetypes_size,

1330 filetype_node, strcat(strcpy(str_buffer, file_type_name), " type"),

1331 yaml_filename):YAC_TEXT_FILETYPE_YAML;

1332 config_file.include_definitions =

1333 (include_definitions_node)?

1334 yaml_parse_enum_value(

1335 bool_names, bool_names_size,

1336 include_definitions_node,

1337 strcat(strcpy(str_buffer, file_type_name), " include definitions"),

1338 yaml_filename):0;

1339 break;

1340 }

1341 }

1342

1343 YAML_ASSERT_F(

1344 config_file.name, "missing filename for %s", file_type_name);

1345

1346 free(str_buffer);

1347

1348 return config_file;

1349}

1351static void yaml_parse_debug_config_file_map_pair(

1352 struct debug_config_file_buffer * config_file_buffer,

1353 fy_node_pair_t config_file_pair, char const * config_file_type_name,

1354 const char * yaml_filename) {

1355

1356 enum yaml_debug_sync_loc_key_types

1357 debug_sync_loc_key_type =

1358 (enum yaml_debug_sync_loc_key_types)

1359 yaml_parse_enum_value(

1360 yaml_debug_sync_loc_keys,

1361 yaml_debug_sync_loc_keys_size,

1362 fy_node_pair_key(config_file_pair),

1363 "config synchronisation location parameter name",

1364 yaml_filename);

1365 char const * debug_sync_loc_key_name =

1366 yac_name_type_pair_get_name(

1367 yaml_debug_sync_loc_keys, yaml_debug_sync_loc_keys_size,

1368 debug_sync_loc_key_type);

1369

1370 fy_node_t value_node = fy_node_pair_value(config_file_pair);

1371

1372 char config_file_type_name_sync[

1373 strlen(config_file_type_name) + strlen(debug_sync_loc_key_name) + 8];

1374 sprintf(

1375 config_file_type_name_sync, "%s (%s)",

1376 config_file_type_name, debug_sync_loc_key_name);

1377

1378 config_file_buffer->config_file[debug_sync_loc_key_type] =

1379 yaml_parse_config_file_value(

1380 value_node, config_file_type_name_sync, yaml_filename);

1381}

1383static struct debug_config_file_buffer yaml_parse_debug_config_file_buffer(

1384 fy_node_t config_file_node, char const * config_file_type_name,

1385 char const * yaml_filename) {

1386

1387 YAML_ASSERT_F(

1388 fy_node_is_mapping(config_file_node),

1389 "unsupported %s node type "

1390 "(%s is expected to be defined as a mapping)",

1391 config_file_type_name, config_file_type_name);

1392

1393 struct debug_config_file_buffer config_file_buffer;

1394 config_file_buffer.sync_loc_ref[SYNC_LOC_DEF_COMP] =

1395 YAC_INSTANCE_CONFIG_OUTPUT_REF_COMP;

1396 config_file_buffer.sync_loc_ref[SYNC_LOC_SYNC_DEF] =

1397 YAC_INSTANCE_CONFIG_OUTPUT_REF_SYNC;

1398 config_file_buffer.sync_loc_ref[SYNC_LOC_ENDDEF] =

1399 YAC_INSTANCE_CONFIG_OUTPUT_REF_ENDDEF;

1400 for (int i = 0; i < SYNC_LOC_COUNT; ++i) {

1401 config_file_buffer.config_file[i].name = NULL;

1402 config_file_buffer.config_file[i].type = YAC_TEXT_FILETYPE_YAML;

1403 config_file_buffer.config_file[i].include_definitions = 0;

1404 YAML_ASSERT_F(

1405 config_file_buffer.sync_loc_ref[i] != NULL,

1406 "invalid unsupported synchronisation location (%d) for %s",

1407 i, config_file_type_name);

1408 }

1409

1410 // parse couplings

1411 void * iter = NULL;

1412 fy_node_pair_t pair;

1413 while ((pair = fy_node_mapping_iterate(config_file_node, &iter)))

1414 yaml_parse_debug_config_file_map_pair(

1415 &config_file_buffer, pair, config_file_type_name, yaml_filename);

1416

1417 return config_file_buffer;

1418}

1420static void yaml_parse_debug_global_config(

1421 struct yac_couple_config * couple_config, fy_node_t global_config_node,

1422 char const * yaml_filename) {

1423

1424 char const * config_file_type_name = "debug global config file";

1425

1426 YAML_ASSERT_F(

1427 fy_node_is_mapping(global_config_node),

1428 "unsupported %s node type "

1429 "(%s is expected to be defined as a mapping)",

1430 config_file_type_name, config_file_type_name);

1431

1432 struct debug_config_file_buffer global_config_buffer =

1433 yaml_parse_debug_config_file_buffer(

1434 global_config_node, config_file_type_name, yaml_filename);

1435

1436 for (int i = 0; i < SYNC_LOC_COUNT; ++i)

1437 if (global_config_buffer.config_file[i].name != NULL)

1438 yac_couple_config_set_config_output_filename(

1439 couple_config, global_config_buffer.config_file[i].name,

1440 global_config_buffer.config_file[i].type,

1441 global_config_buffer.sync_loc_ref[i],

1442 global_config_buffer.config_file[i].include_definitions);

1443}

1445static void yaml_parse_output_grid_pair(

1446 char const ** grid_name, char const ** file_name,

1447 fy_node_pair_t output_grid_pair, char const * yaml_filename) {

1448

1449 enum yaml_debug_output_grid_key_types output_grid_key_type =

1450 (enum yaml_debug_output_grid_key_types)

1451 yaml_parse_enum_value(

1452 yaml_debug_output_grid_keys, yaml_debug_output_grid_keys_size,

1453 fy_node_pair_key(output_grid_pair),

1454 "output grid parameter name", yaml_filename);

1455 char const * debug_output_key_name =

1456 yac_name_type_pair_get_name(

1457 yaml_debug_output_grid_keys, yaml_debug_output_grid_keys_size,

1458 output_grid_key_type);

1459

1460 fy_node_t value_node = fy_node_pair_value(output_grid_pair);

1461

1462 switch(output_grid_key_type) {

1463 YAML_UNREACHABLE_DEFAULT("invalid output grid key type");

1464 case(OUTPUT_GRID_GRID_NAME): {

1465 *grid_name =

1466 yaml_parse_string_value(value_node, debug_output_key_name, yaml_filename);

1467 break;

1468 }

1469 case(OUTPUT_GRID_FILE_NAME): {

1470 *file_name =

1471 yaml_parse_string_value(value_node, debug_output_key_name, yaml_filename);

1472 break;

1473 }

1474 };

1475}

1477static void yaml_parse_output_grid(

1478 struct yac_couple_config * couple_config, fy_node_t output_grid_node,

1479 char const * yaml_filename) {

1480

1481 YAML_ASSERT(

1482 fy_node_is_mapping(output_grid_node),

1483 "unsupported output grid node type "

1484 "(output grids are expected to be defined as a mapping)");

1485

1486 char const * grid_name = NULL;

1487 char const * file_name = NULL;

1488

1489 // parse output grid

1490 void * iter = NULL;

1491 fy_node_pair_t pair;

1492 while ((pair = fy_node_mapping_iterate(output_grid_node, &iter)))

1493 yaml_parse_output_grid_pair(&grid_name, &file_name, pair, yaml_filename);

1494

1495 YAML_ASSERT_F(

1496 grid_name && file_name,

1497 "output grid mapping has to contain both \"grid_name\" and \"file_name\" "

1498 "parameters (grid name: \"%s\", file name: \"%s\")",

1499 (grid_name)?grid_name:"<missing>", (file_name)?file_name:"<missing>");

1500

1501 yac_couple_config_add_grid(couple_config, grid_name);

1502 yac_couple_config_set_grid_output_filename(

1503 couple_config, grid_name, file_name);

1504}

1510static void yaml_parse_all_output_grids(

1511 struct yac_couple_config * couple_config, fy_node_t output_grids_node,

1512 char const * yaml_filename) {

1513

1514 YAML_ASSERT(

1515 fy_node_mapping_item_count(output_grids_node) == 1,

1516 "debug output grids mapping is only allowed to have one pair ");

1517

1518 fy_node_pair_t output_grids_pair =

1519 fy_node_mapping_get_by_index(output_grids_node, 0);

1520

1521 YAML_ASSERT_F(

1522 !strcmp(

1523 OUTPUT_GRIDS_FILE_NAME_STR,

1524 yaml_parse_string_value(

1525 fy_node_pair_key(output_grids_pair),

1526 "output grid parameter name", yaml_filename)),

1527 "unsupported output grid parameter name \"%s\" "

1528 "(only \"%s\" is supported if debug output grids is defined as a "

1529 "mapping, because it applies to all grids) ",

1530 yaml_parse_string_value(

1531 fy_node_pair_key(output_grids_pair),

1532 "output grid parameter name", yaml_filename),

1533 OUTPUT_GRIDS_FILE_NAME_STR);

1534

1535 yac_couple_config_set_all_grids_output_filename(

1536 couple_config,

1537 yaml_parse_string_value(

1538 fy_node_pair_value(output_grids_pair),

1539 OUTPUT_GRIDS_FILE_NAME_STR, yaml_filename));

1540}

1542static void yaml_parse_debug_output_grids(

1543 struct yac_couple_config * couple_config, fy_node_t output_grids_node,

1544 char const * yaml_filename) {

1545

1546 YAML_ASSERT(

1547 fy_node_is_sequence(output_grids_node) ||

1548 fy_node_is_mapping(output_grids_node),

1549 "unsupported debug output grids node type "

1550 "(debug output grids is expected to be defined as a mapping or as a "

1551 "sequence of mappings)");

1552

1553 // a mapping applies to all grids

1554 if (fy_node_is_mapping(output_grids_node)) {

1555 yaml_parse_all_output_grids(

1556 couple_config, output_grids_node, yaml_filename);

1557 return;

1558 }

1559

1560 // parse output grids

1561 void * iter = NULL;

1562 fy_node_t output_grid_node;

1563 while ((output_grid_node =

1564 fy_node_sequence_iterate(output_grids_node, &iter)))

1565 yaml_parse_output_grid(

1566 couple_config, output_grid_node, yaml_filename);

1567}

1569static void yaml_parse_debug_map_pair(

1570 struct yac_couple_config * couple_config, fy_node_pair_t debug_pair,

1571 const char * yaml_filename) {

1572

1573 enum yaml_debug_key_types debug_key_type =

1574 (enum yaml_debug_key_types)

1575 yaml_parse_enum_value(

1576 yaml_debug_keys, yaml_debug_keys_size,

1577 fy_node_pair_key(debug_pair),

1578 "debug configuration parameter name", yaml_filename);

1579

1580 fy_node_t value_node = fy_node_pair_value(debug_pair);

1581

1582 switch (debug_key_type) {

1583 YAML_UNREACHABLE_DEFAULT("invalid debug_key_type");

1584 case(GLOBAL_CONFIG):

1585 yaml_parse_debug_global_config(

1586 couple_config, value_node, yaml_filename);

1587 break;

1588 case(OUTPUT_GRIDS):

1589 yaml_parse_debug_output_grids(

1590 couple_config, value_node, yaml_filename);

1591 break;

1592 case(MISSING_DEF):

1593 yac_couple_config_set_missing_definition_is_fatal(

1594 couple_config,

1595 yaml_parse_enum_value(

1596 bool_names, bool_names_size, value_node,

1597 "\"missing definition is fatal\" bool value", yaml_filename));

1598 break;

1599 case(APPLY_COORD_CHECK):

1600 yac_couple_config_set_apply_coordinate_check(

1601 couple_config,

1602 yaml_parse_enum_value(

1603 bool_names, bool_names_size, value_node,

1604 "\"apply coordinate check\" bool value", yaml_filename));

1605 break;

1606 case(COORDS_MISMATCH_FATAL):

1607 yac_couple_config_set_coordinates_mismatch_is_fatal(

1608 couple_config,

1609 yaml_parse_enum_value(

1610 bool_names, bool_names_size, value_node,

1611 "\"coordinates mismatch is fatal\" bool value",

1612 yaml_filename));

1613 break;

1614 };

1615}

1617static void yaml_parse_debug(

1618 struct yac_couple_config * couple_config,

1619 fy_node_t debug_node, char const * yaml_filename) {

1620

1621 // check if the debug node is empty -> nothing to be read

1622 if (!debug_node) return;

1623

1624 YAML_ASSERT(

1625 fy_node_is_mapping(debug_node),

1626 "unsupported debug node type "

1627 "(debug is expected to be defined as a mapping)");

1628

1629 // parse couplings

1630 void * iter = NULL;

1631 fy_node_pair_t pair;

1632 while ((pair = fy_node_mapping_iterate(debug_node, &iter)))

1633 yaml_parse_debug_map_pair(couple_config, pair, yaml_filename);

1634}

1639static size_t yaml_edit_distance(char const * a, char const * b) {

1640

1641 size_t len_a = strlen(a);

1642 size_t len_b = strlen(b);

1643

1644 size_t * prev_row = xmalloc((len_b + 1) * sizeof(*prev_row));

1645 size_t * curr_row = xmalloc((len_b + 1) * sizeof(*curr_row));

1646

1647 for (size_t j = 0; j <= len_b; ++j) prev_row[j] = j;

1648

1649 for (size_t i = 1; i <= len_a; ++i) {

1650 curr_row[0] = i;

1651 for (size_t j = 1; j <= len_b; ++j) {

1652 size_t substitution_cost = prev_row[j-1] + (a[i-1] != b[j-1]);

1653 size_t deletion_cost = prev_row[j] + 1;

1654 size_t insertion_cost = curr_row[j-1] + 1;

1655 size_t cost = MIN(substitution_cost, MIN(deletion_cost, insertion_cost));

1656 curr_row[j] = cost;

1657 }

1658 size_t * tmp = prev_row;

1659 prev_row = curr_row;

1660 curr_row = tmp;

1661 }

1662

1663 size_t distance = prev_row[len_b];

1664

1665 free(prev_row);

1666 free(curr_row);

1667

1668 return distance;

1669}

1675static void yaml_check_base_key_typo(

1676 char const * unknown_key, char const * yaml_filename) {

1677

1678 char const * closest_key_name = NULL;

1679 size_t closest_distance = SIZE_MAX;

1680

1681 for (size_t i = 0; i < yaml_base_keys_size; ++i) {

1682 size_t distance =

1683 yaml_edit_distance(unknown_key, yaml_base_keys[i].name);

1684 if (distance < closest_distance) {

1685 closest_distance = distance;

1686 closest_key_name = yaml_base_keys[i].name;

1687 }

1688 }

1689

1690 // tolerate a larger edit distance for longer keys, but always require an

1691 // exact match for very short ones

1692 size_t key_len = strlen(unknown_key);

1693 size_t max_typo_distance = MIN(key_len / 4 + 1, (size_t)2);

1694

1695 YAML_ASSERT_F(

1696 (closest_key_name == NULL) || (closest_distance > max_typo_distance),

1697 "unknown root key \"%s\" (did you mean \"%s\"?) ",

1698 unknown_key, closest_key_name);

1699}

1701static void yaml_parse_base_map_pair(

1702 struct yac_couple_config * couple_config, fy_node_pair_t base_pair,

1703 const char * yaml_filename, enum yac_time_unit_type * time_unit,

1704 char const ** start_datetime, char const ** end_datetime) {

1705

1706 fy_node_t key_node = fy_node_pair_key(base_pair);

1707

1708 YAML_ASSERT(

1709 fy_node_is_scalar(key_node),

1710 "unsupported key node type "

1711 "(key nodes are expected to be scalar nodes)");

1712

1713 char const * base_key_name = fy_node_get_scalar0(key_node);

1714 int base_key_type =

1715 yac_name_type_pair_get_type(

1716 yaml_base_keys, yaml_base_keys_size, base_key_name);

1717

1718 fy_node_t value_node = fy_node_pair_value(base_pair);

1719

1720 switch (base_key_type) {

1721 case (START_DATE):

1722 *start_datetime =

1723 yaml_parse_string_value(

1724 value_node, base_key_name, yaml_filename);

1725 break;

1726 case (END_DATE):

1727 *end_datetime =

1728 yaml_parse_string_value(

1729 value_node, base_key_name, yaml_filename);

1730 break;

1731 case (CALENDAR):

1732 yac_instance_def_calendar(

1733 (int)yaml_parse_calendar_value(

1734 value_node, base_key_name, yaml_filename),

1735 "YAML coupling configuration file");

1736 break;

1737 case (TIMESTEP_UNIT): {

1738 enum yac_time_unit_type time_unit_ =

1739 yaml_parse_timestep_unit_value(

1740 value_node, base_key_name, yaml_filename);

1741 YAML_ASSERT(

1742 (*time_unit == TIME_UNIT_UNDEFINED) || (*time_unit == time_unit_),

1743 "inconsistent redefinition of time unit")

1744 *time_unit = time_unit_;

1745 break;

1746 }

1747 case (COUPLING):

1748 YAML_ASSERT(

1749 (*time_unit != TIME_UNIT_UNDEFINED),

1750 "time unit has to be defined before the couplings")

1751 yaml_parse_coupling(

1752 couple_config, value_node, yaml_filename, *time_unit);

1753 break;

1754 case (DEBUG):

1755 yaml_parse_debug(

1756 couple_config, value_node, yaml_filename);

1757 break;

1758 default:

1759 // Unknown root key is silently ignored by design, so that other tools

1760 // sharing the same YAML file can define their own additional root keys;

1761 // however, a root key that is a close (but not exact) match of a valid

1762 // root key is most likely a typo and is therefore reported as a

1763 // fatal error.

1764 yaml_check_base_key_typo(base_key_name, yaml_filename);

1765 break;

1766 }

1767}

1769static void yaml_parse_document(

1770 struct yac_couple_config * couple_config, fy_document_t document,

1771 const char * yaml_filename) {

1772

1773 // get root node of document

1774 fy_node_t root_node = fy_document_root(document);

1775

1776 // if the configuration file is empty

1777 if (!root_node) return;

1778

1779 YAML_ASSERT(

1780 fy_node_is_mapping(root_node),

1781 "unsupported root node type (root node is expected to be a mapping node)");

1782

1783 char const * start_datetime = NULL;

1784 char const * end_datetime = NULL;

1785

1786 // parse base root mappings

1787 enum yac_time_unit_type time_unit = TIME_UNIT_UNDEFINED;

1788 void * iter = NULL;

1789 fy_node_pair_t pair;

1790 while ((pair = fy_node_mapping_iterate(root_node, &iter)))

1791 yaml_parse_base_map_pair(

1792 couple_config, pair, yaml_filename, &time_unit,

1793 &start_datetime, &end_datetime);

1794

1795 if ((start_datetime != NULL) || (end_datetime != NULL)) {

1796

1797 YAC_ASSERT(

1798 yac_cget_calendar() != YAC_CALENDAR_NOT_SET,

1799 "cannot set start/end datetime because calendar has not yet been set");

1800

1801 yac_couple_config_set_datetime(

1802 couple_config, start_datetime, end_datetime);

1803 }

1804}

1806void yac_yaml_read_coupling(

1807 struct yac_couple_config * couple_config, const char * yaml_filename,

1808 int parse_flags) {

1809

1810 // check whether the yaml configuration file exists

1811 YAC_ASSERT_F(

1812 yac_file_exists(yaml_filename),

1813 "YAML configuration file could not be found \"%s\"", yaml_filename);

1814

1815 // open yaml configuration file

1816 FILE * config_file = xfopen(yaml_filename, "r");

1817 YAC_ASSERT_F(

1818 config_file, "could not open YAML configuration file \"%s\"", yaml_filename);

1819

1820 // parse yaml configuration file into document

1821 struct fy_parse_cfg parse_config =

1822 {.search_path = ".",

1823 .userdata = NULL,

1824 .diag = NULL};

1825 parse_config.flags =

1826 (enum fy_parse_cfg_flags)parse_flags;

1827

1828 fy_document_t document =

1829 fy_document_build_from_fp(&parse_config, config_file);

1830 YAC_ASSERT_F(

1831 document, "could not parse YAML configuration file \"%s\"", yaml_filename);

1832

1833 // resolve anchors and merge keys

1834 YAML_ASSERT(

1835 !fy_document_resolve(document),

1836 "could not resolve anchors and merge keys");

1837

1838 // parse document into couple configuration

1839 yaml_parse_document(couple_config, document, yaml_filename);

1840

1841 // cleanup

1842 fy_document_destroy(document);

1843 xfclose(config_file);

1844

1845 return;

1846}

1849 yac_yaml_parse_interp_stack_config_string(

1850 char const * str_interp_stack_config, int parse_flags) {

1851 char const * yaml_filename =

1852 "user-provided interp stack config string";

1853

1854 YAML_ASSERT(

1855 str_interp_stack_config != NULL, "interpolation stack string is NULL");

1856

1857 // parse string into document

1858 struct fy_parse_cfg parse_config =

1859 {.search_path = ".",

1860 .userdata = NULL,

1861 .diag = NULL};

1862 parse_config.flags =

1863 (enum fy_parse_cfg_flags)parse_flags;

1864

1865 fy_document_t document =

1866 fy_document_build_from_string(

1867 &parse_config, str_interp_stack_config, (size_t)-1);

1868 YAML_ASSERT(document, "failed parsing");

1869

1870 // resolve anchors and merge keys

1871 YAML_ASSERT(

1872 !fy_document_resolve(document),

1873 "could not resolve anchors and merge keys");

1874

1875 fy_node_t interp_stack_config_node = fy_document_root(document);

1876 YAML_ASSERT(interp_stack_config_node, "invalid root node");

1877

1878 struct yac_interp_stack_config * interp_stack_config =

1879 yac_interp_stack_config_new();

1880

1881 yaml_parse_interp_stack_value(

1882 interp_stack_config, interp_stack_config_node,

1883 yaml_filename);

1884

1885 // cleanup

1886 fy_document_destroy(document);

1887

1888 return interp_stack_config;

1889}

1891static fy_node_t yac_yaml_create_scalar(

1892 fy_document_t document, char const * value) {

1893

1894 // return NULL if value is empty

1895 if (!value) return (fy_node_t)NULL;

1896

1897 fy_node_t scalar_node =

1898 fy_node_create_scalar_copy(document, value, strlen(value));

1899 YAC_ASSERT(scalar_node, "failed to create scalar node");

1900

1901 return scalar_node;

1902}

1904static fy_node_t yac_yaml_create_scalar_int(

1905 fy_document_t document, int value) {

1906

1907 char str_value[16];

1908 int value_size = snprintf(str_value, sizeof(str_value), "%d", value);

1909 YAC_ASSERT_F(

1910 (value_size >= 0) && ((size_t)value_size < sizeof(str_value)),

1911 "could not write \"%d\" to string buffer of size %zu",

1912 value, sizeof(str_value));

1913

1914 return yac_yaml_create_scalar(document, str_value);

1915}

1917static fy_node_t yac_yaml_create_scalar_size_t(

1918 fy_document_t document, size_t value) {

1919

1920 char str_value[32];

1921 int value_size = snprintf(str_value, sizeof(str_value), "%zu", value);

1922 YAC_ASSERT_F(

1923 (value_size >= 0) && ((size_t)value_size < sizeof(str_value)),

1924 "could not write \"%zu\" to string buffer of size %zu",

1925 value, sizeof(str_value));

1926

1927 return yac_yaml_create_scalar(document, str_value);

1928}

1930static fy_node_t yac_yaml_create_scalar_dble(

1931 fy_document_t document, double value) {

1932

1933 char str_value[32];

1934 int value_size = snprintf(str_value, sizeof(str_value), "%g", value);

1935 YAC_ASSERT_F(

1936 (value_size >= 0) && ((size_t)value_size < sizeof(str_value)),

1937 "could not write \"%g\" to string buffer of size %zu",

1938 value, sizeof(str_value));

1939

1940 return yac_yaml_create_scalar(document, str_value);

1941}

1943static fy_node_t yac_yaml_create_sequence_scalar(

1944 fy_document_t document, char const * const * values, size_t num_values) {

1945

1946 // return NULL if sequence is empty

1947 if (num_values == 0) return (fy_node_t)NULL;

1948

1949 YAC_ASSERT(values, "no values provided");

1950

1951 // create sequence node

1952 fy_node_t sequence_node = fy_node_create_sequence(document);

1953 YAC_ASSERT(sequence_node, "failed to create sequence node");

1954

1955 for (size_t value_idx = 0; value_idx < num_values; ++value_idx) {

1956 char const * value = values[value_idx];

1957 YAC_ASSERT_F(value, "invalid value at idx %zu", value_idx);

1958 int appending_failed =

1959 fy_node_sequence_append(

1960 sequence_node, yac_yaml_create_scalar(document, value));

1961 YAC_ASSERT(!appending_failed, "failed to append interpolation node");

1962 }

1963

1964 return sequence_node;

1965}

1967static fy_node_t yac_yaml_create_sequence_scalar_size_t(

1968 fy_document_t document, size_t const * values, size_t num_values) {

1969

1970 // return NULL if sequence is empty

1971 if (num_values == 0) return (fy_node_t)NULL;

1972

1973 YAC_ASSERT(values, "no values provided");

1974

1975 // create sequence node

1976 fy_node_t sequence_node = fy_node_create_sequence(document);

1977 YAC_ASSERT(sequence_node, "failed to create sequence node");

1978

1979 char str_value[32]; // enough for any size_t

1980 for (size_t value_idx = 0; value_idx < num_values; ++value_idx) {

1981 int value_size =

1982 snprintf(str_value, sizeof(str_value), "%zu", values[value_idx]);

1983 YAC_ASSERT_F(

1984 (value_size >= 0) && ((size_t)value_size < sizeof(str_value)),

1985 "could not write \"%zu\" to string buffer of size %zu",

1986 values[value_idx], sizeof(str_value));

1987 fy_node_t scalar_node = yac_yaml_create_scalar(document, str_value);

1988 YAC_ASSERT_F(scalar_node, "failed to create scalar at idx %zu", value_idx);

1989 int appending_failed = fy_node_sequence_append(sequence_node, scalar_node);

1990 YAC_ASSERT(!appending_failed, "failed to append sequence element");

1991 }

1992

1993 return sequence_node;

1994}

1997static void yac_yaml_map_append(

1998 fy_node_t map, char const * key, fy_node_t value) {

1999

2000 // if the value node is empty, return

2001 if (!value) return;

2002

2003 YAC_ASSERT(key, "NULL key is not supported");

2004

2005 fy_document_t document = fy_node_document(map);

2006 YAC_ASSERT(document, "failed to get document from node");

2007

2008 // set key and value for root node

2009 int appending_failed =

2010 fy_node_mapping_append(

2011 map, yac_yaml_create_scalar(document, key), value);

2012 YAC_ASSERT(!appending_failed, "failed to append mapping node pair");

2013}

2015static void yac_yaml_map_append_scalar(

2016 fy_node_t map, char const * key, char const * value) {

2017

2018 fy_document_t document = fy_node_document(map);

2019 YAC_ASSERT(document, "failed to get document from node");

2020

2021 yac_yaml_map_append(map, key, yac_yaml_create_scalar(document, value));

2022}

2024static void yac_yaml_map_append_scalar_int(

2025 fy_node_t map, char const * key, int value) {

2026

2027 fy_document_t document = fy_node_document(map);

2028 YAC_ASSERT(document, "failed to get document from node");

2029

2030 yac_yaml_map_append(

2031 map, key, yac_yaml_create_scalar_int(document, value));

2032}

2034static void yac_yaml_map_append_scalar_size_t(

2035 fy_node_t map, char const * key, size_t value) {

2036

2037 fy_document_t document = fy_node_document(map);

2038 YAC_ASSERT(document, "failed to get document from node");

2039

2040 yac_yaml_map_append(

2041 map, key, yac_yaml_create_scalar_size_t(document, value));

2042}

2044static void yac_yaml_map_append_scalar_dble(

2045 fy_node_t map, char const * key, double value) {

2046

2047 fy_document_t document = fy_node_document(map);

2048 YAC_ASSERT(document, "failed to get document from node");

2049

2050 yac_yaml_map_append(

2051 map, key, yac_yaml_create_scalar_dble(document, value));

2052}

2054static fy_node_t yac_yaml_create_field_name_node(

2055 fy_document_t document, struct yac_couple_config * couple_config,

2056 size_t couple_idx, size_t field_couple_idx) {

2057

2058 const char * src_field_name;

2059 const char * tgt_field_name;

2060 yac_couple_config_get_field_names(

2061 couple_config, couple_idx, field_couple_idx,

2062 &src_field_name, &tgt_field_name);

2063

2064 // if both names are identical

2065 if (!strcmp(src_field_name, tgt_field_name))

2066 return yac_yaml_create_scalar(document, src_field_name);

2067

2068 // create field name node

2069 fy_node_t field_name_node = fy_node_create_mapping(document);

2070 YAC_ASSERT(field_name_node, "failed to create mapping node");

2071

2072 // add source field name

2073 yac_yaml_map_append_scalar(field_name_node, "src", src_field_name);

2074

2075 // add target field name

2076 yac_yaml_map_append_scalar(field_name_node, "tgt", tgt_field_name);

2077

2078 return field_name_node;

2079}

2084static fy_node_t yac_yaml_create_non_default_scalar_param_node(

2085 fy_document_t document, struct yac_param const * param) {

2086

2087 // if the value is default, skip it in YAML output

2088 if (yac_param_is_default(param)) return NULL;

2089

2090 size_t buflen = 32;

2091 char * value_str = xmalloc(buflen);

2092

2093 while (1) {

2094 int ierr = yac_param_get_scalar(param, value_str, buflen);

2095 if (ierr == 0) break;

2096 YAC_ASSERT_F(buflen < (1u << 20), "%s", yac_param_get_last_error());

2097 buflen *= 2;

2098 value_str = xrealloc(value_str, buflen);

2099 }

2100

2101 fy_node_t scalar_node = yac_yaml_create_scalar(document, value_str);

2102 free(value_str);

2103

2104 return scalar_node;

2105}

2107static fy_node_t yac_yaml_create_non_default_struct_param_node(

2108 fy_document_t document, struct yac_param * param) {

2109

2110 if (yac_param_is_default(param)) return NULL;

2111

2112 size_t sub_count;

2113 int ierr = yac_param_get_sub_count(param, &sub_count);

2114 YAC_ASSERT_F(ierr == 0, "%s", yac_param_get_last_error());

2115

2116 fy_node_t map_node = fy_node_create_mapping(document);

2117 YAC_ASSERT(map_node, "failed to create mapping node");

2118

2119 int contains_non_default_values = 0;

2120 for (size_t i = 0; i < sub_count; ++i) {

2121 struct yac_param * sub_param = NULL;

2122 ierr = yac_param_get_sub_by_index(param, i, &sub_param);

2123 YAC_ASSERT_F(ierr == 0, "%s", yac_param_get_last_error());

2124

2125 fy_node_t sub_node =

2126 yac_yaml_create_non_default_param_node(document, sub_param);

2127 if (!sub_node) continue;

2128

2129 char const * sub_name = yac_param_get_name(sub_param);

2130 YAC_ASSERT(sub_name, "encountered unnamed sub-parameter");

2131

2132 yac_yaml_map_append(map_node, sub_name, sub_node);

2133 contains_non_default_values = 1;

2134 }

2135

2136 if (contains_non_default_values) return map_node;

2137

2138 fy_node_t node = NULL;

2139

2140 // One-of selection changed while active branch remained at defaults.

2141 if (sub_count == 1) {

2142 struct yac_param * active_sub_param = NULL;

2143 ierr = yac_param_get_sub_by_index(param, 0,

2144 &active_sub_param);

2145 YAC_ASSERT_F(ierr == 0, "%s", yac_param_get_last_error());

2146

2147 char const * sub_name = yac_param_get_name(active_sub_param);

2148 YAC_ASSERT(sub_name, "active sub-parameter has no name");

2149

2150 node = yac_yaml_create_scalar(document, sub_name);

2151 }

2152

2153 fy_node_free(map_node);

2154

2155 return node;

2156}

2158static fy_node_t yac_yaml_create_non_default_list_param_node(

2159 fy_document_t document, struct yac_param * param) {

2160

2161 if (yac_param_is_default(param)) return NULL;

2162

2163 size_t sub_count;

2164 int ierr = yac_param_get_sub_count(param, &sub_count);

2165 YAC_ASSERT_F(ierr == 0, "%s", yac_param_get_last_error());

2166

2167 fy_node_t sequence_node = fy_node_create_sequence(document);

2168 YAC_ASSERT(sequence_node, "failed to create sequence node");

2169

2170 for (size_t i = 0; i < sub_count; ++i) {

2171 struct yac_param * sub_param = NULL;

2172 ierr = yac_param_get_sub_by_index(param, i, &sub_param);

2173 YAC_ASSERT_F(ierr == 0, "%s", yac_param_get_last_error());

2174

2175 fy_node_t sub_node =

2176 yac_yaml_create_non_default_param_node(document, sub_param);

2177 int appending_failed = fy_node_sequence_append(sequence_node, sub_node);

2178 YAC_ASSERT(!appending_failed, "failed to append sequence element");

2179 }

2180

2181 return sequence_node;

2182}

2184static fy_node_t yac_yaml_create_non_default_param_node(

2185 fy_document_t document, struct yac_param * param) {

2186

2187 enum yac_param_type type = yac_param_get_type(param);

2188

2189 fy_node_t node = NULL;

2190

2191 switch (type) {

2192 YAC_UNREACHABLE_DEFAULT("unsupported parameter type");

2193 case (YAC_PARAM_TYPE_SCALAR):

2194 node = yac_yaml_create_non_default_scalar_param_node(document, param);

2195 break;

2196 case (YAC_PARAM_TYPE_STRUCT):

2197 node = yac_yaml_create_non_default_struct_param_node(document, param);

2198 break;

2199 case (YAC_PARAM_TYPE_LIST):

2200 node = yac_yaml_create_non_default_list_param_node(document, param);

2201 break;

2202 }

2203

2204 return node;

2205}

2207static fy_node_t yac_yaml_create_interpolation_node(

2208 fy_document_t document,

2209 struct yac_interp_method_config const * method_config) {

2210

2211 struct yac_param * root_param =

2212 yac_interp_method_config_get_param(method_config);

2213 char const * interpolation_name =

2214 yac_param_get_name(root_param);

2215 YAC_ASSERT(interpolation_name, "failed to get interpolation method name");

2216

2217 fy_node_t parameter_node =

2218 yac_yaml_create_non_default_param_node(document, root_param);

2219

2220 fy_node_t interpolation_node;

2221

2222 // if the interpolation contains non-default parameter values

2223 if (parameter_node) {

2224

2225 // create interpolation node

2226 interpolation_node = fy_node_create_mapping(document);

2227 YAC_ASSERT(interpolation_node, "failed to create mapping node");

2228 yac_yaml_map_append(

2229 interpolation_node, interpolation_name, parameter_node);

2230 } else {

2231

2232 interpolation_node =

2233 yac_yaml_create_scalar(document, interpolation_name);

2234 }

2235

2236

2237 return interpolation_node;

2238}

2240static fy_node_t yac_yaml_create_interpolation_stack_node(

2241 fy_document_t document, struct yac_couple_config * couple_config,

2242 size_t couple_idx, size_t field_couple_idx) {

2243

2244 struct yac_interp_stack_config * interp_stack =

2245 yac_couple_config_get_interp_stack(

2246 couple_config, couple_idx, field_couple_idx);

2247

2248 YAC_ASSERT(interp_stack, "invalid interpolation stack");

2249

2250 // create interpolation stack node

2251 fy_node_t interp_stack_node = fy_node_create_sequence(document);

2252 YAC_ASSERT(interp_stack_node, "failed to create sequence node");

2253

2254 size_t interp_stack_size =

2255 yac_interp_stack_config_get_size(interp_stack);

2256 YAC_ASSERT(interp_stack_size, "invalid interpolation stack size");

2257

2258 for (size_t interp_stack_idx = 0; interp_stack_idx < interp_stack_size;

2259 ++interp_stack_idx) {

2260 int appending_failed =

2261 fy_node_sequence_append(

2262 interp_stack_node,

2263 yac_yaml_create_interpolation_node(

2264 document,

2265 yac_interp_stack_config_get(interp_stack, interp_stack_idx)));

2266 YAC_ASSERT(!appending_failed, "failed to append interpolation node");

2267 }

2268

2269 return interp_stack_node;

2270}

2272static void yac_yaml_append_couple_field_nodes(

2273 fy_node_t coupling_node, struct yac_couple_config * couple_config,

2274 size_t couple_idx, size_t field_couple_idx) {

2275

2276 fy_document_t document = fy_node_document(coupling_node);

2277 YAC_ASSERT(document, "failed to get document from node");

2278

2279 // create couple node

2280 fy_node_t field_couple_node = fy_node_create_mapping(document);

2281 YAC_ASSERT(coupling_node, "failed to create mapping node");

2282

2283 // get component names

2284 char const * src_component_name;

2285 char const * tgt_component_name;

2286 yac_couple_config_get_field_couple_component_names(

2287 couple_config, couple_idx, field_couple_idx,

2288 &src_component_name, &tgt_component_name);

2289

2290 // add source component name

2291 yac_yaml_map_append_scalar(

2292 field_couple_node,

2293 yac_name_type_pair_get_name(

2294 yaml_couple_keys, yaml_couple_keys_size, SOURCE_COMPONENT),

2295 src_component_name);

2296

2297 // add target component name

2298 yac_yaml_map_append_scalar(

2299 field_couple_node,

2300 yac_name_type_pair_get_name(

2301 yaml_couple_keys, yaml_couple_keys_size, TARGET_COMPONENT),

2302 tgt_component_name);

2303

2304 // get grid names

2305 char const * src_grid_name;

2306 char const * tgt_grid_name;

2307 yac_couple_config_get_field_grid_names(

2308 couple_config, couple_idx, field_couple_idx,

2309 &src_grid_name, &tgt_grid_name);

2310

2311 // add source grid name

2312 yac_yaml_map_append_scalar(

2313 field_couple_node,

2314 yac_name_type_pair_get_name(

2315 yaml_couple_keys, yaml_couple_keys_size, SOURCE_GRID),

2316 src_grid_name);

2317

2318 // add target grid name

2319 yac_yaml_map_append_scalar(

2320 field_couple_node,

2321 yac_name_type_pair_get_name(

2322 yaml_couple_keys, yaml_couple_keys_size, TARGET_GRID),

2323 tgt_grid_name);

2324

2325 // add field names

2326 yac_yaml_map_append(

2327 field_couple_node,

2328 yac_name_type_pair_get_name(

2329 yaml_couple_keys, yaml_couple_keys_size, FIELD),

2330 yac_yaml_create_field_name_node(

2331 document, couple_config, couple_idx, field_couple_idx));

2332

2333 // add coupling period

2334 yac_yaml_map_append_scalar(

2335 field_couple_node,

2336 yac_name_type_pair_get_name(

2337 yaml_couple_keys, yaml_couple_keys_size, COUPLING_PERIOD),

2338 yac_couple_config_get_coupling_period(

2339 couple_config, couple_idx, field_couple_idx));

2340

2341 // add time reduction

2342 yac_yaml_map_append_scalar(

2343 field_couple_node,

2344 yac_name_type_pair_get_name(

2345 yaml_couple_keys, yaml_couple_keys_size, TIME_REDUCTION),

2346 yac_name_type_pair_get_name(

2347 time_operations, time_operations_size,

2348 yac_couple_config_get_coupling_period_operation(

2349 couple_config, couple_idx, field_couple_idx)));

2350

2351 // add source lag

2352 yac_yaml_map_append_scalar_int(

2353 field_couple_node,

2354 yac_name_type_pair_get_name(

2355 yaml_couple_keys, yaml_couple_keys_size, SOURCE_LAG),

2356 yac_couple_config_get_source_lag(

2357 couple_config, couple_idx, field_couple_idx));

2358

2359 // add target lag

2360 yac_yaml_map_append_scalar_int(

2361 field_couple_node,

2362 yac_name_type_pair_get_name(

2363 yaml_couple_keys, yaml_couple_keys_size, TARGET_LAG),

2364 yac_couple_config_get_target_lag(

2365 couple_config, couple_idx, field_couple_idx));

2366

2367 // add weight file name

2368 if (yac_couple_config_get_enforce_write_weight_file(

2369 couple_config, couple_idx, field_couple_idx)) {

2370 yac_yaml_map_append_scalar(

2371 field_couple_node,

2372 yac_name_type_pair_get_name(

2373 yaml_couple_keys, yaml_couple_keys_size, WEIGHT_FILE_NAME),

2374 yac_couple_config_get_weight_file_name(

2375 couple_config, couple_idx, field_couple_idx));

2376 yac_yaml_map_append_scalar(

2377 field_couple_node,

2378 yac_name_type_pair_get_name(

2379 yaml_couple_keys, yaml_couple_keys_size, WEIGHT_FILE_ON_EXISTING),

2380 yac_name_type_pair_get_name(

2381 weight_file_on_existing_types, weight_file_on_existing_types_size,

2382 yac_couple_config_get_weight_file_on_existing(

2383 couple_config, couple_idx, field_couple_idx)));

2384 }

2385

2386 // add mapping side

2387 yac_yaml_map_append_scalar(

2388 field_couple_node,

2389 yac_name_type_pair_get_name(

2390 yaml_couple_keys, yaml_couple_keys_size, MAPPING_SIDE),

2391 yac_name_type_pair_get_name(

2392 mapping_sides, mapping_sides_size,

2393 yac_couple_config_get_mapping_on_source(

2394 couple_config, couple_idx, field_couple_idx)));

2395

2396 // add scale factor

2397 yac_yaml_map_append_scalar_dble(

2398 field_couple_node,

2399 yac_name_type_pair_get_name(

2400 yaml_couple_keys, yaml_couple_keys_size, SCALE_FACTOR),

2401 yac_couple_config_get_scale_factor(

2402 couple_config, couple_idx, field_couple_idx));

2403

2404 // add scale summand

2405 yac_yaml_map_append_scalar_dble(

2406 field_couple_node,

2407 yac_name_type_pair_get_name(

2408 yaml_couple_keys, yaml_couple_keys_size, SCALE_SUMMAND),

2409 yac_couple_config_get_scale_summand(

2410 couple_config, couple_idx, field_couple_idx));

2411

2412 // add interpolation

2413 yac_yaml_map_append(

2414 field_couple_node,

2415 yac_name_type_pair_get_name(

2416 yaml_couple_keys, yaml_couple_keys_size, INTERPOLATION),

2417 yac_yaml_create_interpolation_stack_node(

2418 document, couple_config, couple_idx, field_couple_idx));

2419

2420 // add source mask names

2421 char const * const * src_mask_names;

2422 size_t num_src_mask_names;

2423 yac_couple_config_get_src_mask_names(

2424 couple_config, couple_idx, field_couple_idx,

2425 &src_mask_names, &num_src_mask_names);

2426 if (num_src_mask_names == 1)

2427 yac_yaml_map_append_scalar(

2428 field_couple_node,

2429 yac_name_type_pair_get_name(

2430 yaml_couple_keys, yaml_couple_keys_size, SOURCE_MASK_NAME),

2431 src_mask_names[0]);

2432 else if (num_src_mask_names > 1)

2433 yac_yaml_map_append(

2434 field_couple_node,

2435 yac_name_type_pair_get_name(

2436 yaml_couple_keys, yaml_couple_keys_size, SOURCE_MASK_NAMES),

2437 yac_yaml_create_sequence_scalar(

2438 document, src_mask_names, num_src_mask_names));

2439

2440 // add target mask name

2441 char const * tgt_mask_name =

2442 yac_couple_config_get_tgt_mask_name(

2443 couple_config, couple_idx, field_couple_idx);

2444 if (tgt_mask_name)

2445 yac_yaml_map_append_scalar(

2446 field_couple_node,

2447 yac_name_type_pair_get_name(

2448 yaml_couple_keys, yaml_couple_keys_size, TARGET_MASK_NAME),

2449 tgt_mask_name);

2450

2451 // add yaxt exchanger name

2452 char const * yaxt_exchanger_name =

2453 yac_couple_config_get_yaxt_exchanger_name(

2454 couple_config, couple_idx, field_couple_idx);

2455 if (yaxt_exchanger_name)

2456 yac_yaml_map_append_scalar(

2457 field_couple_node,

2458 yac_name_type_pair_get_name(

2459 yaml_couple_keys, yaml_couple_keys_size, YAXT_EXCHANGER_NAME),

2460 yaxt_exchanger_name);

2461

2462 // add collection selection

2463 struct yac_collection_selection const * collection_selection =

2464 yac_couple_config_get_collection_selection(

2465 couple_config, couple_idx, field_couple_idx);

2466 if (collection_selection) {

2467 size_t collection_size =

2468 yac_collection_selection_get_collection_size(collection_selection);

2469 size_t const * indices =

2470 yac_collection_selection_get_indices(collection_selection);

2471 size_t * continous_indices = NULL;

2472 if (indices == NULL) {

2473 continous_indices =

2474 xmalloc(collection_size * sizeof(*continous_indices));

2475 for (size_t i = 0; i < collection_size; ++i) continous_indices[i] = i;

2476 indices = continous_indices;

2477 }

2478 if (collection_size == 1) {

2479 yac_yaml_map_append_scalar_size_t(

2480 field_couple_node,

2481 yac_name_type_pair_get_name(

2482 yaml_couple_keys, yaml_couple_keys_size, COLLECTION_SELECTION),

2483 indices[0]);

2484 } else if (collection_size > 1) {

2485 yac_yaml_map_append(

2486 field_couple_node,

2487 yac_name_type_pair_get_name(

2488 yaml_couple_keys, yaml_couple_keys_size, COLLECTION_SELECTION),

2489 yac_yaml_create_sequence_scalar_size_t(

2490 document, indices, collection_size));

2491 }

2492 free(continous_indices);

2493 }

2494

2495 // add use raw exchange

2496 yac_yaml_map_append_scalar(

2497 field_couple_node,

2498 yac_name_type_pair_get_name(

2499 yaml_couple_keys, yaml_couple_keys_size, USE_RAW_EXCHANGE),

2500 yac_name_type_pair_get_name(

2501 bool_names, bool_names_size,

2502 yac_couple_config_get_use_raw_exchange(

2503 couple_config, couple_idx, field_couple_idx)));

2504

2505 int appending_failed =

2506 fy_node_sequence_append(coupling_node, field_couple_node);

2507 YAC_ASSERT(!appending_failed, "failed to append field couple node");

2508}

2510static void yac_yaml_append_couple_nodes(

2511 fy_node_t coupling_node, struct yac_couple_config * couple_config,

2512 size_t couple_idx) {

2513

2514 size_t num_couple_fields =

2515 yac_couple_config_get_num_couple_fields(couple_config, couple_idx);

2516

2517 for (size_t field_couple_idx = 0;

2518 field_couple_idx < num_couple_fields; ++field_couple_idx)

2519 yac_yaml_append_couple_field_nodes(

2520 coupling_node, couple_config, couple_idx, field_couple_idx);

2521}

2523static fy_node_t yac_yaml_create_output_grid_node(

2524 fy_document_t document, char const * grid_name, char const * file_name) {

2525

2526 fy_node_t output_grid_node = fy_node_create_mapping(document);

2527 YAC_ASSERT(output_grid_node, "failed to create mapping node");

2528

2529 yac_yaml_map_append_scalar(

2530 output_grid_node,

2531 yac_name_type_pair_get_name(

2532 yaml_debug_output_grid_keys, yaml_debug_output_grid_keys_size,

2533 OUTPUT_GRID_GRID_NAME),

2534 grid_name);

2535 yac_yaml_map_append_scalar(

2536 output_grid_node,

2537 yac_name_type_pair_get_name(

2538 yaml_debug_output_grid_keys, yaml_debug_output_grid_keys_size,

2539 OUTPUT_GRID_FILE_NAME),

2540 file_name);

2541

2542 return output_grid_node;

2543}

2545static fy_node_t yac_yaml_create_output_grids_node(

2546 fy_document_t document, struct yac_couple_config * couple_config) {

2547

2548 // count the number of output grids

2549 // (the effective file names are used here, hence an output file name that

2550 // applies to all grids is emitted as one entry per grid)

2551 size_t num_output_grids = 0;

2552 size_t num_grids =

2553 yac_couple_config_get_num_grids(couple_config);

2554 for (size_t grid_idx = 0; grid_idx < num_grids; ++grid_idx)

2555 if (yac_couple_config_get_grid_output_filename(

2556 couple_config,

2557 yac_couple_config_get_grid_name(couple_config, grid_idx)) != NULL)

2558 ++num_output_grids;

2559

2560 fy_node_t output_grids_node = NULL;

2561

2562 if (num_output_grids > 0) {

2563

2564 // create output grids node

2565 output_grids_node = fy_node_create_sequence(document);

2566 YAC_ASSERT(output_grids_node, "failed to create sequence node");

2567

2568 // for all output grids

2569 for (size_t grid_idx = 0; grid_idx < num_grids; ++grid_idx) {

2570

2571 char const * grid_name =

2572 yac_couple_config_get_grid_name(couple_config, grid_idx);

2573 char const * file_name =

2574 yac_couple_config_get_grid_output_filename(couple_config, grid_name);

2575

2576 if (file_name != NULL) {

2577 int appending_failed =

2578 fy_node_sequence_append(

2579 output_grids_node,

2580 yac_yaml_create_output_grid_node(document, grid_name, file_name));

2581 YAC_ASSERT(!appending_failed, "failed to append output grid node");

2582 }

2583 }

2584 }

2585

2586 return output_grids_node;

2587}

2589static fy_node_t yac_yaml_create_debug_node(

2590 fy_document_t document, struct yac_couple_config * couple_config) {

2591

2592 // create debug node

2593 fy_node_t debug_node = fy_node_create_mapping(document);

2594 YAC_ASSERT(debug_node, "failed to create mapping node");

2595

2596 // add output grids node

2597 yac_yaml_map_append(

2598 debug_node,

2599 yac_name_type_pair_get_name(

2600 yaml_debug_keys, yaml_debug_keys_size, OUTPUT_GRIDS),

2601 yac_yaml_create_output_grids_node(document, couple_config));

2602

2603 // add "missing_definition_is_fatal" node

2604 yac_yaml_map_append_scalar(

2605 debug_node,

2606 yac_name_type_pair_get_name(

2607 yaml_debug_keys, yaml_debug_keys_size, MISSING_DEF),

2608 yac_name_type_pair_get_name(

2609 bool_names, bool_names_size,

2610 yac_couple_config_get_missing_definition_is_fatal(couple_config)));

2611

2612 // add "apply_coordinate_checks" node

2613 yac_yaml_map_append_scalar(

2614 debug_node,

2615 yac_name_type_pair_get_name(

2616 yaml_debug_keys, yaml_debug_keys_size, APPLY_COORD_CHECK),

2617 yac_name_type_pair_get_name(

2618 bool_names, bool_names_size,

2619 yac_couple_config_get_apply_coordinate_check(couple_config)));

2620

2621 // add "coordinates_mismatch_is_fatal" node

2622 yac_yaml_map_append_scalar(

2623 debug_node,

2624 yac_name_type_pair_get_name(

2625 yaml_debug_keys, yaml_debug_keys_size, COORDS_MISMATCH_FATAL),

2626 yac_name_type_pair_get_name(

2627 bool_names, bool_names_size,

2628 yac_couple_config_get_coordinates_mismatch_is_fatal(couple_config)));

2629

2630 return debug_node;

2631}

2633static fy_node_t yac_yaml_create_coupling_node(

2634 fy_document_t document, struct yac_couple_config * couple_config) {

2635

2636 size_t num_couples =

2637 yac_couple_config_get_num_couples(couple_config);

2638

2639 if (!num_couples) return NULL;

2640

2641 // create coupling node

2642 fy_node_t coupling_node = fy_node_create_sequence(document);

2643 YAC_ASSERT(coupling_node, "failed to create sequence node");

2644

2645 // for all couples

2646 for (size_t couple_idx = 0; couple_idx < num_couples; ++couple_idx)

2647 yac_yaml_append_couple_nodes(

2648 coupling_node, couple_config, couple_idx);

2649

2650 return coupling_node;

2651}

2653static fy_node_t yac_yaml_create_field_node(

2654 fy_document_t document, struct yac_couple_config * couple_config,

2655 size_t component_idx, size_t field_idx) {

2656

2657 fy_node_t field_node = fy_node_create_mapping(document);

2658 YAC_ASSERT(field_node, "failed to create mapping node");

2659

2660 // get field parameters

2661 char const * component_name =

2662 yac_couple_config_get_component_name(

2663 couple_config, component_idx);

2664 char const * field_name =

2665 yac_couple_config_get_field_name(

2666 couple_config, component_idx, field_idx);

2667 char const * grid_name =

2668 yac_couple_config_get_field_grid_name(

2669 couple_config, component_idx, field_idx);

2670 char const * metadata =

2671 yac_couple_config_get_field_metadata(

2672 couple_config, component_name, grid_name, field_name);

2673 size_t collection_size =

2674 yac_couple_config_get_field_collection_size(

2675 couple_config, component_name, grid_name, field_name);

2676 char const * timestep =

2677 yac_couple_config_get_field_timestep(

2678 couple_config, component_name, grid_name, field_name);

2679 int role =

2680 yac_couple_config_get_field_role(

2681 couple_config, component_name, grid_name, field_name);

2682 double frac_mask_fallback_value =

2683 yac_couple_config_get_frac_mask_fallback_value(

2684 couple_config, component_name, grid_name, field_name);

2685

2686 // add field name

2687 yac_yaml_map_append_scalar(field_node, "name", field_name);

2688

2689 // add grid name

2690 yac_yaml_map_append_scalar(field_node, "grid_name", grid_name);

2691

2692 // add metadata

2693 if (metadata)

2694 yac_yaml_map_append_scalar(field_node, "metadata", metadata);

2695

2696 // add collection_size

2697 if (collection_size != SIZE_MAX)

2698 yac_yaml_map_append_scalar_int(

2699 field_node, "collection_size", (int)collection_size);

2700

2701 // add timestep

2702 if (timestep)

2703 yac_yaml_map_append_scalar(field_node, "timestep", timestep);

2704

2705 // add role

2706 yac_yaml_map_append_scalar(

2707 field_node, "role",

2708 yac_name_type_pair_get_name(

2709 role_types, role_types_size, (enum yac_field_exchange_type)role));

2710

2711 // add fractional fallback value

2712 if (YAC_FRAC_MASK_VALUE_IS_VALID(frac_mask_fallback_value))

2713 yac_yaml_map_append_scalar_dble(

2714 field_node, "frac_mask_fallback_value", frac_mask_fallback_value);

2715

2716 return field_node;

2717}

2719static fy_node_t yac_yaml_create_fields_node(

2720 fy_document_t document, struct yac_couple_config * couple_config,

2721 size_t component_idx) {

2722

2723 size_t num_fields =

2724 yac_couple_config_get_num_fields(couple_config, component_idx);

2725

2726 if (num_fields == 0) return (fy_node_t)NULL;

2727

2728 fy_node_t fields_node = fy_node_create_sequence(document);

2729 YAC_ASSERT(fields_node, "failed to create sequence node");

2730

2731 for (size_t field_idx = 0; field_idx < num_fields; ++field_idx) {

2732

2733 int appending_failed =

2734 fy_node_sequence_append(

2735 fields_node,

2736 yac_yaml_create_field_node(

2737 document, couple_config, component_idx, field_idx));

2738 YAC_ASSERT(!appending_failed, "failed to append field node");

2739 }

2740

2741 return fields_node;

2742}

2744static fy_node_t yac_yaml_create_component_node(

2745 fy_document_t document, struct yac_couple_config * couple_config,

2746 size_t component_idx) {

2747

2748 fy_node_t component_node = fy_node_create_mapping(document);

2749 YAC_ASSERT(component_node, "failed to create mapping node");

2750

2751 // get component name, component metadata, and fields

2752 char const * component_name =

2753 yac_couple_config_get_component_name(couple_config, component_idx);

2754 char const * metadata =

2755 yac_couple_config_get_component_metadata(couple_config, component_name);

2756 fy_node_t fields_node =

2757 yac_yaml_create_fields_node(

2758 document, couple_config, component_idx);

2759

2760 // add component name

2761 yac_yaml_map_append_scalar(component_node, "name", component_name);

2762

2763 // add metadata

2764 if (metadata)

2765 yac_yaml_map_append_scalar(component_node, "metadata", metadata);

2766

2767 // add fields

2768 yac_yaml_map_append(component_node, "fields", fields_node);

2769

2770 return component_node;

2771}

2773static fy_node_t yac_yaml_create_components_node(

2774 fy_document_t document, struct yac_couple_config * couple_config) {

2775

2776 // get number of components in coupling configuration

2777 size_t num_components = yac_couple_config_get_num_components(couple_config);

2778

2779 if (num_components == 0) return (fy_node_t)NULL;

2780

2781 // create sequence node

2782 fy_node_t components_node = fy_node_create_sequence(document);

2783 YAC_ASSERT(components_node, "failed to create sequence node");

2784

2785 for (size_t component_idx = 0; component_idx < num_components;

2786 ++component_idx) {

2787

2788 int appending_failed =

2789 fy_node_sequence_append(

2790 components_node,

2791 yac_yaml_create_component_node(document, couple_config, component_idx));

2792 YAC_ASSERT(!appending_failed, "failed to append component node");

2793 }

2794

2795 return components_node;

2796}

2798static fy_node_t yac_yaml_create_grid_node(

2799 fy_document_t document, struct yac_couple_config * couple_config,

2800 size_t grid_idx) {

2801

2802 fy_node_t grid_node = fy_node_create_mapping(document);

2803 YAC_ASSERT(grid_node, "failed to create mapping node");

2804

2805 // get grid name and metadata

2806 char const * grid_name =

2807 yac_couple_config_get_grid_name(couple_config, grid_idx);

2808 char const * metadata =

2809 yac_couple_config_get_grid_metadata(couple_config, grid_name);

2810

2811 // add grid name

2812 yac_yaml_map_append_scalar(grid_node, "name", grid_name);

2813

2814 // add metadata

2815 if (metadata)

2816 yac_yaml_map_append_scalar(grid_node, "metadata", metadata);

2817

2818 return grid_node;

2819}

2821static fy_node_t yac_yaml_create_grids_node(

2822 fy_document_t document, struct yac_couple_config * couple_config) {

2823

2824 // get number of grids in coupling configuration

2825 size_t num_grids = yac_couple_config_get_num_grids(couple_config);

2826

2827 if (num_grids == 0) return (fy_node_t)NULL;

2828

2829 // create sequence node

2830 fy_node_t grids_node = fy_node_create_sequence(document);

2831 YAC_ASSERT(grids_node, "failed to create sequence node");

2832

2833 for (size_t grids_idx = 0; grids_idx < num_grids; ++grids_idx) {

2834

2835 int appending_failed =

2836 fy_node_sequence_append(

2837 grids_node,

2838 yac_yaml_create_grid_node(document, couple_config, grids_idx));

2839 YAC_ASSERT(!appending_failed, "failed to append grid node");

2840 }

2841

2842 return grids_node;

2843}

2845static fy_node_t yac_yaml_create_definitions_node(

2846 fy_document_t document, struct yac_couple_config * couple_config) {

2847

2848 // create definition

2849 fy_node_t definition_node = fy_node_create_mapping(document);

2850 YAC_ASSERT(definition_node, "failed to create mapping node");

2851

2852 // add components

2853 yac_yaml_map_append(

2854 definition_node,

2855 "components", yac_yaml_create_components_node(document, couple_config));

2856

2857 // add grids

2858 yac_yaml_map_append(

2859 definition_node, "grids", yac_yaml_create_grids_node(document, couple_config));

2860

2861 return definition_node;

2862}

2864static fy_node_t yac_yaml_create_couple_config_nodes(

2865 fy_document_t document, struct yac_couple_config * couple_config,

2866 int include_definitions) {

2867

2868 // create root node

2869 fy_node_t root_node = fy_node_create_mapping(document);

2870 YAC_ASSERT(root_node, "failed to create mapping node");

2871

2872 // add debug

2873 yac_yaml_map_append(

2874 root_node,

2875 yac_name_type_pair_get_name(

2876 yaml_base_keys, yaml_base_keys_size, DEBUG),

2877 yac_yaml_create_debug_node(document, couple_config));

2878

2879 // add debug definitions (components, grids, and fields)

2880 if (include_definitions)

2881 yac_yaml_map_append(

2882 root_node, "debug_definitions",

2883 yac_yaml_create_definitions_node(document, couple_config));

2884

2885 // add start datetime

2886 char * start_datetime = yac_couple_config_get_start_datetime(couple_config);

2887 yac_yaml_map_append_scalar(

2888 root_node,

2889 yac_name_type_pair_get_name(

2890 yaml_base_keys, yaml_base_keys_size, START_DATE), start_datetime);

2891 free(start_datetime);

2892

2893 // add end datetime

2894 char * end_datetime = yac_couple_config_get_end_datetime(couple_config);

2895 yac_yaml_map_append_scalar(

2896 root_node,

2897 yac_name_type_pair_get_name(

2898 yaml_base_keys, yaml_base_keys_size, END_DATE), end_datetime);

2899 free(end_datetime);

2900

2901 // add calendar

2902 yac_yaml_map_append_scalar(

2903 root_node,

2904 yac_name_type_pair_get_name(

2905 yaml_base_keys, yaml_base_keys_size, CALENDAR),

2906 yac_name_type_pair_get_name(

2907 calendar_types, calendar_types_size, getCalendarType()));

2908

2909 // add timestep unit

2910 yac_yaml_map_append_scalar(

2911 root_node,

2912 yac_name_type_pair_get_name(

2913 yaml_base_keys, yaml_base_keys_size, TIMESTEP_UNIT),

2914 yac_name_type_pair_get_name(

2915 timestep_units, timestep_units_size, C_ISO_FORMAT));

2916

2917 // add couplings

2918 yac_yaml_map_append(

2919 root_node,

2920 yac_name_type_pair_get_name(

2921 yaml_base_keys, yaml_base_keys_size, COUPLING),

2922 yac_yaml_create_coupling_node(document, couple_config));

2923

2924 return root_node;

2925}

2927char * yac_yaml_emit_coupling(

2928 struct yac_couple_config * couple_config, int emit_flags,

2929 int include_definitions) {

2930

2931 // create an empty document

2932 fy_document_t document = fy_document_create(NULL);

2933 YAC_ASSERT(document, "failed to create document");

2934

2935 // create nodes from coupling configuration

2936 fy_node_t root_node =

2937 yac_yaml_create_couple_config_nodes(

2938 document, couple_config, include_definitions);

2939

2940 // set root node of the document

2941 int setting_root_failed =

2942 fy_document_set_root(document, root_node);

2943 YAC_ASSERT(!setting_root_failed, "failed to add root node to document");

2944

2945 // emit document to string

2946 char * str_document =

2947 fy_emit_document_to_string(

2948 document, (enum fy_emitter_cfg_flags)emit_flags);

2949

2950 YAC_ASSERT(str_document, "failed to emit document to string");

2951

2952 // destroy document

2953 fy_document_destroy(document);

2954

2955 return str_document;

2956}