[325] | 1 | /* ************************************************************************** * |
---|
[335] | 2 | * Copyright © IPSL/LSCE, xios, Avril 2010 - Octobre 2011 * |
---|
[325] | 3 | * ************************************************************************** */ |
---|
| 4 | |
---|
| 5 | #include <boost/multi_array.hpp> |
---|
[1542] | 6 | #include <memory> |
---|
[325] | 7 | #include <string> |
---|
[489] | 8 | #include <cstring> |
---|
[325] | 9 | #include <iostream> |
---|
| 10 | |
---|
| 11 | |
---|
[591] | 12 | #include "xios.hpp" |
---|
[325] | 13 | #include "oasis_cinterface.hpp" |
---|
| 14 | |
---|
[352] | 15 | #include "attribute_template.hpp" |
---|
| 16 | #include "object_template.hpp" |
---|
| 17 | #include "group_template.hpp" |
---|
[325] | 18 | |
---|
| 19 | #include "icutil.hpp" |
---|
| 20 | #include "cxios.hpp" |
---|
[342] | 21 | #include "client.hpp" |
---|
[325] | 22 | #include "field.hpp" |
---|
[352] | 23 | #include "context.hpp" |
---|
[403] | 24 | #include "context_client.hpp" |
---|
[382] | 25 | #include "mpi.hpp" |
---|
[347] | 26 | #include "timer.hpp" |
---|
[2427] | 27 | #include "mem_checker.hpp" |
---|
[369] | 28 | #include "array_new.hpp" |
---|
[325] | 29 | |
---|
[403] | 30 | |
---|
[325] | 31 | extern "C" |
---|
| 32 | { |
---|
| 33 | // /////////////////////////////// Définitions ////////////////////////////// // |
---|
| 34 | |
---|
| 35 | // ----------------------- Redéfinition de types ---------------------------- |
---|
[489] | 36 | |
---|
[325] | 37 | typedef enum { NETCDF4 = 0 } XFileType; |
---|
[489] | 38 | |
---|
[593] | 39 | typedef xios::CContext* XContextPtr; |
---|
[325] | 40 | |
---|
| 41 | // -------------------- Traitement des données ------------------------------ |
---|
[576] | 42 | |
---|
| 43 | // This function is not exported to the public Fortran interface, |
---|
| 44 | // it is only used from the parse_xml.exe standalone test tool. |
---|
| 45 | void cxios_init(void) |
---|
[1622] | 46 | TRY |
---|
[576] | 47 | { |
---|
| 48 | CXios::initialize(); |
---|
| 49 | } |
---|
[1622] | 50 | CATCH_DUMP_STACK |
---|
[576] | 51 | |
---|
[1054] | 52 | void cxios_init_server(void) |
---|
[1622] | 53 | TRY |
---|
[325] | 54 | { |
---|
[1054] | 55 | CXios::initServerSide(); |
---|
[325] | 56 | } |
---|
[1622] | 57 | CATCH_DUMP_STACK |
---|
[325] | 58 | |
---|
[593] | 59 | void cxios_init_client(const char* client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm ) |
---|
[1622] | 60 | TRY |
---|
[325] | 61 | { |
---|
[489] | 62 | std::string str; |
---|
[1639] | 63 | MPI_Comm local_comm; |
---|
| 64 | MPI_Comm return_comm; |
---|
[489] | 65 | |
---|
[325] | 66 | if (!cstr2string(client_id, len_client_id, str)) return; |
---|
[347] | 67 | |
---|
[593] | 68 | int initialized; |
---|
[1639] | 69 | MPI_Initialized(&initialized); |
---|
[2467] | 70 | if (initialized) |
---|
| 71 | { |
---|
| 72 | CTimer::get("XIOS").resume(); |
---|
| 73 | CTimer::get("XIOS init").resume(); |
---|
| 74 | local_comm=MPI_Comm_f2c(*f_local_comm); |
---|
| 75 | } |
---|
[593] | 76 | else local_comm=MPI_COMM_NULL; |
---|
| 77 | CXios::initClientSide(str, local_comm, return_comm); |
---|
| 78 | *f_return_comm=MPI_Comm_c2f(return_comm); |
---|
[2467] | 79 | if (initialized) |
---|
| 80 | { |
---|
| 81 | CTimer::get("XIOS init").suspend(); |
---|
| 82 | CTimer::get("XIOS").suspend(); |
---|
| 83 | } |
---|
[325] | 84 | } |
---|
[1622] | 85 | CATCH_DUMP_STACK |
---|
[325] | 86 | |
---|
[593] | 87 | void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm) |
---|
[1622] | 88 | TRY |
---|
[325] | 89 | { |
---|
[489] | 90 | std::string str; |
---|
[1639] | 91 | MPI_Comm comm; |
---|
[489] | 92 | |
---|
[325] | 93 | if (!cstr2string(context_id, len_context_id, str)) return; |
---|
[593] | 94 | CTimer::get("XIOS").resume(); |
---|
| 95 | CTimer::get("XIOS init context").resume(); |
---|
| 96 | comm=MPI_Comm_f2c(*f_comm); |
---|
| 97 | CClient::registerContext(str, comm); |
---|
| 98 | CTimer::get("XIOS init context").suspend(); |
---|
| 99 | CTimer::get("XIOS").suspend(); |
---|
[325] | 100 | } |
---|
[1622] | 101 | CATCH_DUMP_STACK |
---|
[489] | 102 | |
---|
[1587] | 103 | void cxios_oasis_enddef() |
---|
[1622] | 104 | TRY |
---|
[1587] | 105 | { |
---|
| 106 | CTimer::get("XIOS").resume(); |
---|
| 107 | CClient::callOasisEnddef(); |
---|
| 108 | CTimer::get("XIOS").suspend(); |
---|
| 109 | } |
---|
[1622] | 110 | CATCH_DUMP_STACK |
---|
[1587] | 111 | |
---|
[593] | 112 | void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized) |
---|
[1622] | 113 | TRY |
---|
[461] | 114 | { |
---|
[489] | 115 | std::string str; |
---|
| 116 | |
---|
[461] | 117 | if (!cstr2string(context_id, len_context_id, str)) return; |
---|
[593] | 118 | CTimer::get("XIOS").resume(); |
---|
| 119 | CContext* context = CContext::get(str, str); |
---|
| 120 | *initialized=context->isInitialized(); |
---|
| 121 | CTimer::get("XIOS").suspend(); |
---|
[489] | 122 | } |
---|
[1622] | 123 | CATCH_DUMP_STACK |
---|
[489] | 124 | |
---|
[1622] | 125 | void cxios_context_close_definition() |
---|
| 126 | TRY |
---|
[325] | 127 | { |
---|
[2427] | 128 | CMemChecker::get("XIOS close definition").resume(); |
---|
| 129 | |
---|
[593] | 130 | CTimer::get("XIOS").resume(); |
---|
| 131 | CTimer::get("XIOS close definition").resume(); |
---|
| 132 | CContext* context = CContext::getCurrent(); |
---|
| 133 | context->closeDefinition(); |
---|
| 134 | CTimer::get("XIOS close definition").suspend(); |
---|
| 135 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 136 | |
---|
| 137 | CMemChecker::get("XIOS close definition").suspend(); |
---|
[489] | 138 | } |
---|
[1622] | 139 | CATCH_DUMP_STACK |
---|
[325] | 140 | |
---|
| 141 | void cxios_context_finalize() |
---|
[1622] | 142 | TRY |
---|
[325] | 143 | { |
---|
[593] | 144 | CTimer::get("XIOS").resume(); |
---|
| 145 | CTimer::get("XIOS context finalize").resume(); |
---|
| 146 | CContext* context = CContext::getCurrent(); |
---|
| 147 | context->finalize(); |
---|
[2266] | 148 | CXios::getDaemonsManager()->eventLoop() ; |
---|
[593] | 149 | CTimer::get("XIOS context finalize").suspend(); |
---|
| 150 | CTimer::get("XIOS").suspend(); |
---|
[325] | 151 | } |
---|
[1622] | 152 | CATCH_DUMP_STACK |
---|
[489] | 153 | |
---|
[325] | 154 | void cxios_finalize() |
---|
[1622] | 155 | TRY |
---|
[325] | 156 | { |
---|
[593] | 157 | CTimer::get("XIOS").resume(); |
---|
| 158 | CTimer::get("XIOS finalize").resume(); |
---|
| 159 | CXios::clientFinalize(); |
---|
[2243] | 160 | // Delete CContext |
---|
| 161 | CObjectTemplate<CContext>::cleanStaticDataStructure(); |
---|
[325] | 162 | } |
---|
[1622] | 163 | CATCH_DUMP_STACK |
---|
[325] | 164 | |
---|
[445] | 165 | void cxios_solve_inheritance() |
---|
[1622] | 166 | TRY |
---|
[445] | 167 | { |
---|
[593] | 168 | CTimer::get("XIOS").resume(); |
---|
| 169 | CContext* context = CContext::getCurrent(); |
---|
| 170 | context->solveAllInheritance(false); |
---|
| 171 | CTimer::get("XIOS").suspend(); |
---|
[489] | 172 | } |
---|
[1622] | 173 | CATCH_DUMP_STACK |
---|
[489] | 174 | |
---|
| 175 | /*! \brief This group of functions retrieve variable information from the configuration file (.xml) |
---|
| 176 | * |
---|
| 177 | * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml), |
---|
| 178 | * from a Fortran one, for example the value of a variable with id = "using_server". |
---|
| 179 | * Each function corresponds to each basic type. |
---|
| 180 | * \param varId [in] id of the variable that we'd like to get |
---|
| 181 | * \param varIdSize [in] size of the variable type (integer, float, double, string) |
---|
| 182 | * \param dataInt [in/out] the retrieved data |
---|
| 183 | * \param isVarExisted [in/out] Verify whether variable with varId exists |
---|
| 184 | */ |
---|
[593] | 185 | void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted) |
---|
[1622] | 186 | TRY |
---|
[489] | 187 | { |
---|
| 188 | std::string varIdStr; |
---|
| 189 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 190 | |
---|
| 191 | CTimer::get("XIOS").resume(); |
---|
| 192 | CTimer::get("XIOS get variable data").resume(); |
---|
| 193 | |
---|
| 194 | CContext* context = CContext::getCurrent(); |
---|
| 195 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 196 | |
---|
| 197 | if (*isVarExisted) |
---|
| 198 | { |
---|
[593] | 199 | *data = CVariable::get(context->getId(), varIdStr)->getData<double>(); |
---|
[489] | 200 | } |
---|
| 201 | |
---|
[593] | 202 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 203 | CTimer::get("XIOS").suspend(); |
---|
[489] | 204 | } |
---|
[1622] | 205 | CATCH_DUMP_STACK |
---|
[489] | 206 | |
---|
[593] | 207 | void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted) |
---|
[1622] | 208 | TRY |
---|
[489] | 209 | { |
---|
| 210 | std::string varIdStr; |
---|
| 211 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 212 | |
---|
| 213 | CTimer::get("XIOS").resume(); |
---|
| 214 | CTimer::get("XIOS get variable data").resume(); |
---|
| 215 | |
---|
| 216 | CContext* context = CContext::getCurrent(); |
---|
| 217 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 218 | |
---|
| 219 | if (*isVarExisted) |
---|
| 220 | { |
---|
[593] | 221 | *data = CVariable::get(context->getId(), varIdStr)->getData<float>(); |
---|
[489] | 222 | } |
---|
| 223 | |
---|
[593] | 224 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 225 | CTimer::get("XIOS").suspend(); |
---|
[489] | 226 | } |
---|
[1622] | 227 | CATCH_DUMP_STACK |
---|
[489] | 228 | |
---|
[593] | 229 | void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted) |
---|
[1622] | 230 | TRY |
---|
[489] | 231 | { |
---|
| 232 | std::string varIdStr; |
---|
| 233 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 234 | |
---|
| 235 | CTimer::get("XIOS").resume(); |
---|
| 236 | CTimer::get("XIOS get variable data").resume(); |
---|
| 237 | |
---|
| 238 | CContext* context = CContext::getCurrent(); |
---|
| 239 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 240 | |
---|
| 241 | if (*isVarExisted) |
---|
| 242 | { |
---|
[593] | 243 | *data = CVariable::get(context->getId(), varIdStr)->getData<int>(); |
---|
[489] | 244 | } |
---|
| 245 | |
---|
[593] | 246 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 247 | CTimer::get("XIOS").suspend(); |
---|
[489] | 248 | } |
---|
[1622] | 249 | CATCH_DUMP_STACK |
---|
[489] | 250 | |
---|
[593] | 251 | void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted) |
---|
[1622] | 252 | TRY |
---|
[489] | 253 | { |
---|
| 254 | std::string varIdStr; |
---|
| 255 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 256 | |
---|
| 257 | CTimer::get("XIOS").resume(); |
---|
| 258 | CTimer::get("XIOS get variable data").resume(); |
---|
| 259 | |
---|
| 260 | CContext* context = CContext::getCurrent(); |
---|
| 261 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 262 | |
---|
| 263 | if (*isVarExisted) |
---|
| 264 | { |
---|
[593] | 265 | *data = CVariable::get(context->getId(), varIdStr)->getData<bool>(); |
---|
[489] | 266 | } |
---|
| 267 | |
---|
[593] | 268 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 269 | CTimer::get("XIOS").suspend(); |
---|
[489] | 270 | } |
---|
[1622] | 271 | CATCH_DUMP_STACK |
---|
[489] | 272 | |
---|
[593] | 273 | void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted) |
---|
[1622] | 274 | TRY |
---|
[489] | 275 | { |
---|
| 276 | std::string varIdStr; |
---|
| 277 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 278 | |
---|
| 279 | CTimer::get("XIOS").resume(); |
---|
| 280 | CTimer::get("XIOS get variable data").resume(); |
---|
| 281 | |
---|
| 282 | CContext* context = CContext::getCurrent(); |
---|
| 283 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 284 | |
---|
| 285 | if (*isVarExisted) |
---|
| 286 | { |
---|
[593] | 287 | int dataSizeOut = CVariable::get(context->getId(), varIdStr)->getData<string>().length(); |
---|
| 288 | strncpy(data, CVariable::get(context->getId(), varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut)); |
---|
[489] | 289 | } |
---|
| 290 | |
---|
[593] | 291 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 292 | CTimer::get("XIOS").suspend(); |
---|
[489] | 293 | } |
---|
[1622] | 294 | CATCH_DUMP_STACK |
---|
[489] | 295 | |
---|
| 296 | /*! \brief This group of functions write information into existing variable in the configuration file (.xml) |
---|
| 297 | * |
---|
| 298 | * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml), |
---|
| 299 | * from a Fortran one, for example the value of a variable with id = "using_server". |
---|
| 300 | * Each function corresponds to each basic type. |
---|
| 301 | * \param varId [in] id of the variable that we'd like to get |
---|
| 302 | * \param varIdSize [in] size of the variable type (integer, float, double, string) |
---|
| 303 | * \param data [in] the input data |
---|
| 304 | * \param isVarExisted [in/out] Verify whether variable with varId exists |
---|
| 305 | */ |
---|
[593] | 306 | void cxios_set_variable_data_k8(const char* varId, int varIdSize, double data, bool* isVarExisted) |
---|
[1622] | 307 | TRY |
---|
| 308 | { |
---|
[489] | 309 | std::string varIdStr; |
---|
| 310 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 311 | |
---|
| 312 | CTimer::get("XIOS").resume(); |
---|
| 313 | CTimer::get("XIOS set variable data").resume(); |
---|
| 314 | |
---|
[593] | 315 | CContext* context = CContext::getCurrent(); |
---|
[489] | 316 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 317 | |
---|
| 318 | if (*isVarExisted) |
---|
| 319 | { |
---|
[593] | 320 | CVariable::get(context->getId(), varIdStr)->setData<double>(data); |
---|
| 321 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 322 | } |
---|
| 323 | |
---|
[593] | 324 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 325 | CTimer::get("XIOS").suspend(); |
---|
[489] | 326 | } |
---|
[1622] | 327 | CATCH_DUMP_STACK |
---|
[489] | 328 | |
---|
[593] | 329 | void cxios_set_variable_data_k4(const char* varId, int varIdSize, float data, bool* isVarExisted) |
---|
[1622] | 330 | TRY |
---|
[489] | 331 | { |
---|
| 332 | std::string varIdStr; |
---|
| 333 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 334 | |
---|
| 335 | CTimer::get("XIOS").resume(); |
---|
| 336 | CTimer::get("XIOS set variable data").resume(); |
---|
| 337 | |
---|
[593] | 338 | CContext* context = CContext::getCurrent(); |
---|
[489] | 339 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 340 | |
---|
| 341 | if (*isVarExisted) |
---|
| 342 | { |
---|
[593] | 343 | CVariable::get(context->getId(), varIdStr)->setData<float>(data); |
---|
| 344 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 345 | } |
---|
| 346 | |
---|
[593] | 347 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 348 | CTimer::get("XIOS").suspend(); |
---|
[489] | 349 | } |
---|
[1622] | 350 | CATCH_DUMP_STACK |
---|
[489] | 351 | |
---|
[593] | 352 | void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted) |
---|
[1622] | 353 | TRY |
---|
[489] | 354 | { |
---|
| 355 | std::string varIdStr; |
---|
| 356 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 357 | |
---|
| 358 | CTimer::get("XIOS").resume(); |
---|
| 359 | CTimer::get("XIOS set variable data").resume(); |
---|
| 360 | |
---|
[593] | 361 | CContext* context = CContext::getCurrent(); |
---|
[489] | 362 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 363 | |
---|
| 364 | if (*isVarExisted) |
---|
| 365 | { |
---|
[593] | 366 | CVariable::get(context->getId(), varIdStr)->setData<int>(data); |
---|
| 367 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 368 | } |
---|
| 369 | |
---|
| 370 | |
---|
[593] | 371 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 372 | CTimer::get("XIOS").suspend(); |
---|
[489] | 373 | } |
---|
[1622] | 374 | CATCH_DUMP_STACK |
---|
[489] | 375 | |
---|
[593] | 376 | void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted) |
---|
[1622] | 377 | TRY |
---|
[489] | 378 | { |
---|
| 379 | std::string varIdStr; |
---|
| 380 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 381 | |
---|
| 382 | CTimer::get("XIOS").resume(); |
---|
| 383 | CTimer::get("XIOS set variable data").resume(); |
---|
| 384 | |
---|
[593] | 385 | CContext* context = CContext::getCurrent(); |
---|
[489] | 386 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 387 | |
---|
| 388 | if (*isVarExisted) |
---|
| 389 | { |
---|
[593] | 390 | CVariable::get(context->getId(), varIdStr)->setData<bool>(data); |
---|
| 391 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 392 | } |
---|
| 393 | |
---|
[593] | 394 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 395 | CTimer::get("XIOS").suspend(); |
---|
[489] | 396 | } |
---|
[1622] | 397 | CATCH_DUMP_STACK |
---|
[489] | 398 | |
---|
[593] | 399 | void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted) |
---|
[1622] | 400 | TRY |
---|
| 401 | { |
---|
[489] | 402 | std::string varIdStr, dataStr; |
---|
| 403 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 404 | if (!cstr2string(data, dataSizeIn, dataStr)) |
---|
| 405 | { |
---|
| 406 | *isVarExisted = false; |
---|
| 407 | return; |
---|
| 408 | } |
---|
| 409 | |
---|
| 410 | CTimer::get("XIOS").resume(); |
---|
| 411 | CTimer::get("XIOS set variable data").resume(); |
---|
| 412 | |
---|
[593] | 413 | CContext* context = CContext::getCurrent(); |
---|
[489] | 414 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 415 | |
---|
| 416 | if (*isVarExisted) |
---|
| 417 | { |
---|
[593] | 418 | CVariable::get(context->getId(), varIdStr)->setData<string>(dataStr); |
---|
| 419 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 420 | } |
---|
| 421 | |
---|
[593] | 422 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 423 | CTimer::get("XIOS").suspend(); |
---|
[489] | 424 | } |
---|
[1622] | 425 | CATCH_DUMP_STACK |
---|
[489] | 426 | |
---|
[325] | 427 | // ---------------------- Ecriture des données ------------------------------ |
---|
[2121] | 428 | |
---|
| 429 | void cxios_write_data_k80_hdl(CField* field, double* data_k8, int data_Xsize) |
---|
[1622] | 430 | TRY |
---|
[586] | 431 | { |
---|
[2427] | 432 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 433 | CTimer::get("XIOS").resume(); |
---|
| 434 | CTimer::get("XIOS send field").resume(); |
---|
| 435 | CContext* context = CContext::getCurrent(); |
---|
[704] | 436 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 437 | context->eventLoop(); |
---|
[593] | 438 | CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); |
---|
[2121] | 439 | field->setData(data); |
---|
[593] | 440 | CTimer::get("XIOS send field").suspend(); |
---|
| 441 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 442 | CMemChecker::get("XIOS send field").suspend(); |
---|
[586] | 443 | } |
---|
[1622] | 444 | CATCH_DUMP_STACK |
---|
[586] | 445 | |
---|
[2121] | 446 | void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) |
---|
[1622] | 447 | TRY |
---|
[586] | 448 | { |
---|
| 449 | std::string fieldid_str; |
---|
[593] | 450 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 451 | cxios_write_data_k80_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ; |
---|
| 452 | } |
---|
| 453 | CATCH_DUMP_STACK |
---|
[586] | 454 | |
---|
[2121] | 455 | |
---|
| 456 | |
---|
| 457 | |
---|
| 458 | void cxios_write_data_k81_hdl(CField* field, double* data_k8, int data_Xsize) |
---|
| 459 | TRY |
---|
| 460 | { |
---|
[2427] | 461 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 462 | CTimer::get("XIOS").resume(); |
---|
| 463 | CTimer::get("XIOS send field").resume(); |
---|
[586] | 464 | |
---|
[593] | 465 | CContext* context = CContext::getCurrent(); |
---|
[704] | 466 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 467 | context->eventLoop(); |
---|
[593] | 468 | |
---|
| 469 | CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); |
---|
[2121] | 470 | field->setData(data); |
---|
[593] | 471 | |
---|
| 472 | CTimer::get("XIOS send field").suspend(); |
---|
| 473 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 474 | CMemChecker::get("XIOS send field").suspend(); |
---|
[586] | 475 | } |
---|
[1622] | 476 | CATCH_DUMP_STACK |
---|
[2121] | 477 | |
---|
| 478 | void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) |
---|
[1622] | 479 | TRY |
---|
[325] | 480 | { |
---|
| 481 | std::string fieldid_str; |
---|
[489] | 482 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 483 | cxios_write_data_k81_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ; |
---|
| 484 | |
---|
| 485 | } |
---|
| 486 | CATCH_DUMP_STACK |
---|
[489] | 487 | |
---|
[2121] | 488 | |
---|
| 489 | |
---|
| 490 | void cxios_write_data_k82_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize) |
---|
| 491 | TRY |
---|
| 492 | { |
---|
[2427] | 493 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 494 | CTimer::get("XIOS").resume(); |
---|
| 495 | CTimer::get("XIOS send field").resume(); |
---|
| 496 | |
---|
| 497 | CContext* context = CContext::getCurrent(); |
---|
[704] | 498 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 499 | context->eventLoop(); |
---|
[593] | 500 | |
---|
| 501 | CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData); |
---|
[2121] | 502 | field->setData(data); |
---|
[593] | 503 | |
---|
| 504 | CTimer::get("XIOS send field").suspend(); |
---|
| 505 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 506 | CMemChecker::get("XIOS send field").suspend(); |
---|
[325] | 507 | } |
---|
[1622] | 508 | CATCH_DUMP_STACK |
---|
[489] | 509 | |
---|
[2121] | 510 | void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize) |
---|
[1622] | 511 | TRY |
---|
[325] | 512 | { |
---|
| 513 | std::string fieldid_str; |
---|
| 514 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 515 | cxios_write_data_k82_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize) ; |
---|
| 516 | } |
---|
| 517 | CATCH_DUMP_STACK |
---|
[489] | 518 | |
---|
[2121] | 519 | |
---|
| 520 | |
---|
| 521 | |
---|
| 522 | |
---|
| 523 | |
---|
| 524 | void cxios_write_data_k83_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
| 525 | TRY |
---|
| 526 | { |
---|
[2427] | 527 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 528 | CTimer::get("XIOS").resume(); |
---|
| 529 | CTimer::get("XIOS send field").resume(); |
---|
[489] | 530 | |
---|
[593] | 531 | CContext* context = CContext::getCurrent(); |
---|
[704] | 532 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 533 | context->eventLoop(); |
---|
[593] | 534 | |
---|
| 535 | CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); |
---|
[2121] | 536 | field->setData(data); |
---|
[593] | 537 | |
---|
| 538 | CTimer::get("XIOS send field").suspend(); |
---|
| 539 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 540 | CMemChecker::get("XIOS send field").suspend(); |
---|
[325] | 541 | } |
---|
[1622] | 542 | CATCH_DUMP_STACK |
---|
[2121] | 543 | |
---|
| 544 | void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
[1622] | 545 | TRY |
---|
[932] | 546 | { |
---|
| 547 | std::string fieldid_str; |
---|
| 548 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 549 | cxios_write_data_k83_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize, data_Zsize) ; |
---|
[932] | 550 | |
---|
[2121] | 551 | |
---|
| 552 | } |
---|
| 553 | CATCH_DUMP_STACK |
---|
| 554 | |
---|
| 555 | |
---|
| 556 | |
---|
| 557 | |
---|
| 558 | |
---|
| 559 | |
---|
| 560 | void cxios_write_data_k84_hdl(CField* field, double* data_k8, int data_0size, int data_1size, int data_2size, int data_3size) |
---|
| 561 | TRY |
---|
| 562 | { |
---|
[2427] | 563 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 564 | CTimer::get("XIOS").resume(); |
---|
| 565 | CTimer::get("XIOS send field").resume(); |
---|
| 566 | |
---|
| 567 | CContext* context = CContext::getCurrent(); |
---|
| 568 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 569 | context->eventLoop(); |
---|
[932] | 570 | |
---|
| 571 | CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); |
---|
[2121] | 572 | field->setData(data); |
---|
[932] | 573 | |
---|
| 574 | CTimer::get("XIOS send field").suspend(); |
---|
| 575 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 576 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 577 | } |
---|
[1622] | 578 | CATCH_DUMP_STACK |
---|
[932] | 579 | |
---|
[2121] | 580 | void cxios_write_data_k84(const char* fieldid, int fieldid_size, double* data_k8, int data_0size, int data_1size, int data_2size, int data_3size) |
---|
[1622] | 581 | TRY |
---|
[932] | 582 | { |
---|
| 583 | std::string fieldid_str; |
---|
| 584 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 585 | |
---|
| 586 | CTimer::get("XIOS").resume(); |
---|
| 587 | CTimer::get("XIOS send field").resume(); |
---|
[2121] | 588 | cxios_write_data_k84_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size) ; |
---|
| 589 | } |
---|
| 590 | CATCH_DUMP_STACK |
---|
[932] | 591 | |
---|
[2121] | 592 | |
---|
| 593 | |
---|
| 594 | |
---|
| 595 | |
---|
| 596 | void cxios_write_data_k85_hdl(CField* field, double* data_k8, |
---|
| 597 | int data_0size, int data_1size, int data_2size, |
---|
| 598 | int data_3size, int data_4size) |
---|
| 599 | TRY |
---|
| 600 | { |
---|
[2427] | 601 | CMemChecker::get("XIOS send field").resume(); |
---|
[2121] | 602 | CTimer::get("XIOS").resume(); |
---|
| 603 | CTimer::get("XIOS send field").resume(); |
---|
| 604 | |
---|
[932] | 605 | CContext* context = CContext::getCurrent(); |
---|
[2121] | 606 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 607 | context->eventLoop(); |
---|
[932] | 608 | |
---|
| 609 | CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); |
---|
[2121] | 610 | field->setData(data); |
---|
[932] | 611 | |
---|
| 612 | CTimer::get("XIOS send field").suspend(); |
---|
| 613 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 614 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 615 | } |
---|
[1622] | 616 | CATCH_DUMP_STACK |
---|
[932] | 617 | |
---|
[2121] | 618 | void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8, |
---|
[932] | 619 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 620 | int data_3size, int data_4size) |
---|
[1622] | 621 | TRY |
---|
[932] | 622 | { |
---|
| 623 | std::string fieldid_str; |
---|
| 624 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 625 | cxios_write_data_k85_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size) ; |
---|
[932] | 626 | |
---|
[2121] | 627 | } |
---|
| 628 | CATCH_DUMP_STACK |
---|
| 629 | |
---|
| 630 | |
---|
| 631 | |
---|
| 632 | void cxios_write_data_k86_hdl(CField* field, double* data_k8, |
---|
| 633 | int data_0size, int data_1size, int data_2size, |
---|
| 634 | int data_3size, int data_4size, int data_5size) |
---|
| 635 | TRY |
---|
| 636 | { |
---|
| 637 | |
---|
[2427] | 638 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 639 | CTimer::get("XIOS").resume(); |
---|
| 640 | CTimer::get("XIOS send field").resume(); |
---|
| 641 | |
---|
| 642 | CContext* context = CContext::getCurrent(); |
---|
| 643 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 644 | context->eventLoop(); |
---|
[932] | 645 | |
---|
| 646 | CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); |
---|
[2121] | 647 | field->setData(data); |
---|
[932] | 648 | |
---|
| 649 | CTimer::get("XIOS send field").suspend(); |
---|
| 650 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 651 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 652 | } |
---|
[1622] | 653 | CATCH_DUMP_STACK |
---|
[2121] | 654 | |
---|
| 655 | void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 656 | int data_0size, int data_1size, int data_2size, |
---|
| 657 | int data_3size, int data_4size, int data_5size) |
---|
| 658 | TRY |
---|
| 659 | { |
---|
| 660 | std::string fieldid_str; |
---|
| 661 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 662 | cxios_write_data_k86_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ; |
---|
[932] | 663 | |
---|
[2121] | 664 | } |
---|
| 665 | CATCH_DUMP_STACK |
---|
| 666 | |
---|
| 667 | |
---|
| 668 | |
---|
| 669 | |
---|
| 670 | void cxios_write_data_k87_hdl(CField* field, double* data_k8, |
---|
[932] | 671 | int data_0size, int data_1size, int data_2size, |
---|
| 672 | int data_3size, int data_4size, int data_5size, |
---|
| 673 | int data_6size) |
---|
[1622] | 674 | TRY |
---|
[932] | 675 | { |
---|
[2427] | 676 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 677 | CTimer::get("XIOS").resume(); |
---|
| 678 | CTimer::get("XIOS send field").resume(); |
---|
| 679 | |
---|
| 680 | CContext* context = CContext::getCurrent(); |
---|
| 681 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 682 | context->eventLoop(); |
---|
[932] | 683 | |
---|
| 684 | CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); |
---|
[2121] | 685 | field->setData(data); |
---|
[932] | 686 | |
---|
| 687 | CTimer::get("XIOS send field").suspend(); |
---|
| 688 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 689 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 690 | } |
---|
[1622] | 691 | CATCH_DUMP_STACK |
---|
[2121] | 692 | |
---|
| 693 | void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 694 | int data_0size, int data_1size, int data_2size, |
---|
| 695 | int data_3size, int data_4size, int data_5size, |
---|
| 696 | int data_6size) |
---|
[1622] | 697 | TRY |
---|
[325] | 698 | { |
---|
| 699 | std::string fieldid_str; |
---|
[489] | 700 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 701 | cxios_write_data_k87_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ; |
---|
| 702 | } |
---|
| 703 | CATCH_DUMP_STACK |
---|
| 704 | |
---|
[347] | 705 | |
---|
[2121] | 706 | |
---|
| 707 | |
---|
| 708 | |
---|
| 709 | void cxios_write_data_k40_hdl(CField* field, float* data_k4, int data_Xsize) |
---|
| 710 | TRY |
---|
| 711 | { |
---|
[2427] | 712 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 713 | CTimer::get("XIOS").resume(); |
---|
| 714 | CTimer::get("XIOS send field").resume(); |
---|
| 715 | CContext* context = CContext::getCurrent(); |
---|
[704] | 716 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 717 | context->eventLoop(); |
---|
[369] | 718 | |
---|
[593] | 719 | CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); |
---|
| 720 | CArray<double, 1> data(data_Xsize) ; |
---|
| 721 | data = data_tmp; |
---|
[2121] | 722 | field->setData(data); |
---|
[593] | 723 | CTimer::get("XIOS send field").suspend(); |
---|
| 724 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 725 | CMemChecker::get("XIOS send field").suspend(); |
---|
[325] | 726 | } |
---|
[1622] | 727 | CATCH_DUMP_STACK |
---|
[489] | 728 | |
---|
[2121] | 729 | void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) |
---|
[1622] | 730 | TRY |
---|
[325] | 731 | { |
---|
| 732 | std::string fieldid_str; |
---|
[593] | 733 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 734 | cxios_write_data_k40_hdl(CField::get(fieldid_str), data_k4, data_Xsize); |
---|
[347] | 735 | |
---|
[2121] | 736 | } |
---|
| 737 | CATCH_DUMP_STACK |
---|
| 738 | |
---|
| 739 | |
---|
| 740 | void cxios_write_data_k41_hdl(CField* field, float* data_k4, int data_Xsize) |
---|
| 741 | TRY |
---|
| 742 | { |
---|
[2427] | 743 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 744 | CTimer::get("XIOS").resume(); |
---|
| 745 | CTimer::get("XIOS send field").resume(); |
---|
[403] | 746 | |
---|
[593] | 747 | CContext* context = CContext::getCurrent(); |
---|
[704] | 748 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 749 | context->eventLoop(); |
---|
[593] | 750 | |
---|
| 751 | CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); |
---|
| 752 | CArray<double, 1> data(data_Xsize); |
---|
| 753 | data = data_tmp; |
---|
[2121] | 754 | field->setData(data); |
---|
[593] | 755 | |
---|
| 756 | CTimer::get("XIOS send field").suspend(); |
---|
| 757 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 758 | CMemChecker::get("XIOS send field").suspend(); |
---|
[325] | 759 | } |
---|
[1622] | 760 | CATCH_DUMP_STACK |
---|
[489] | 761 | |
---|
[2121] | 762 | void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) |
---|
[1622] | 763 | TRY |
---|
[325] | 764 | { |
---|
| 765 | std::string fieldid_str; |
---|
[489] | 766 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 767 | cxios_write_data_k41_hdl(CField::get(fieldid_str), data_k4, data_Xsize); |
---|
| 768 | } |
---|
| 769 | CATCH_DUMP_STACK |
---|
[347] | 770 | |
---|
[2121] | 771 | |
---|
| 772 | void cxios_write_data_k42_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize) |
---|
| 773 | TRY |
---|
| 774 | { |
---|
[2427] | 775 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 776 | CTimer::get("XIOS").resume(); |
---|
| 777 | CTimer::get("XIOS send field").resume(); |
---|
[403] | 778 | |
---|
[593] | 779 | CContext* context = CContext::getCurrent(); |
---|
[704] | 780 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 781 | context->eventLoop(); |
---|
[593] | 782 | |
---|
| 783 | CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData); |
---|
| 784 | CArray<double, 2> data(data_Xsize, data_Ysize); |
---|
| 785 | data = data_tmp; |
---|
[2121] | 786 | field->setData(data); |
---|
[593] | 787 | |
---|
| 788 | CTimer::get("XIOS send field").suspend(); |
---|
| 789 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 790 | CMemChecker::get("XIOS send field").suspend(); |
---|
[325] | 791 | } |
---|
[1622] | 792 | CATCH_DUMP_STACK |
---|
[489] | 793 | |
---|
[2121] | 794 | void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) |
---|
[1622] | 795 | TRY |
---|
[325] | 796 | { |
---|
| 797 | std::string fieldid_str; |
---|
[593] | 798 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 799 | cxios_write_data_k42_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize); |
---|
| 800 | } |
---|
| 801 | CATCH_DUMP_STACK |
---|
[489] | 802 | |
---|
[2121] | 803 | |
---|
| 804 | |
---|
| 805 | |
---|
| 806 | void cxios_write_data_k43_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
| 807 | TRY |
---|
| 808 | { |
---|
[2427] | 809 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 810 | CTimer::get("XIOS").resume(); |
---|
| 811 | CTimer::get("XIOS send field").resume(); |
---|
| 812 | |
---|
| 813 | CContext* context = CContext::getCurrent(); |
---|
[704] | 814 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 815 | context->eventLoop(); |
---|
[593] | 816 | |
---|
| 817 | CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); |
---|
| 818 | CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize); |
---|
| 819 | data = data_tmp; |
---|
[2121] | 820 | field->setData(data); |
---|
[593] | 821 | |
---|
| 822 | CTimer::get("XIOS send field").suspend(); |
---|
| 823 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 824 | CMemChecker::get("XIOS send field").suspend(); |
---|
[593] | 825 | } |
---|
[1622] | 826 | CATCH_DUMP_STACK |
---|
[2121] | 827 | |
---|
| 828 | void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
| 829 | TRY |
---|
| 830 | { |
---|
| 831 | std::string fieldid_str; |
---|
| 832 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 833 | cxios_write_data_k43_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize, data_Zsize); |
---|
| 834 | } |
---|
| 835 | CATCH_DUMP_STACK |
---|
| 836 | |
---|
[593] | 837 | |
---|
[2121] | 838 | |
---|
| 839 | void cxios_write_data_k44_hdl(CField* field, float* data_k4, |
---|
[932] | 840 | int data_0size, int data_1size, int data_2size, |
---|
| 841 | int data_3size) |
---|
[1622] | 842 | TRY |
---|
[932] | 843 | { |
---|
[2427] | 844 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 845 | CTimer::get("XIOS").resume(); |
---|
| 846 | CTimer::get("XIOS send field").resume(); |
---|
| 847 | |
---|
| 848 | CContext* context = CContext::getCurrent(); |
---|
| 849 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 850 | context->eventLoop(); |
---|
[932] | 851 | |
---|
| 852 | CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); |
---|
| 853 | CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size); |
---|
| 854 | data = data_tmp; |
---|
[2121] | 855 | field->setData(data); |
---|
[932] | 856 | |
---|
| 857 | CTimer::get("XIOS send field").suspend(); |
---|
| 858 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 859 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 860 | } |
---|
[1622] | 861 | CATCH_DUMP_STACK |
---|
[932] | 862 | |
---|
[2121] | 863 | void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4, |
---|
[932] | 864 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 865 | int data_3size) |
---|
[1622] | 866 | TRY |
---|
[932] | 867 | { |
---|
| 868 | std::string fieldid_str; |
---|
| 869 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 870 | cxios_write_data_k44_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size) ; |
---|
| 871 | } |
---|
| 872 | CATCH_DUMP_STACK |
---|
[932] | 873 | |
---|
[2121] | 874 | |
---|
| 875 | |
---|
| 876 | |
---|
| 877 | void cxios_write_data_k45_hdl(CField* field, float* data_k4, |
---|
| 878 | int data_0size, int data_1size, int data_2size, |
---|
| 879 | int data_3size, int data_4size) |
---|
| 880 | TRY |
---|
| 881 | { |
---|
[2427] | 882 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 883 | CTimer::get("XIOS").resume(); |
---|
| 884 | CTimer::get("XIOS send field").resume(); |
---|
| 885 | |
---|
| 886 | CContext* context = CContext::getCurrent(); |
---|
| 887 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 888 | context->eventLoop(); |
---|
[932] | 889 | |
---|
| 890 | CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); |
---|
| 891 | CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size); |
---|
| 892 | data = data_tmp; |
---|
[2121] | 893 | field->setData(data); |
---|
[932] | 894 | |
---|
| 895 | CTimer::get("XIOS send field").suspend(); |
---|
| 896 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 897 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 898 | } |
---|
[1622] | 899 | CATCH_DUMP_STACK |
---|
[932] | 900 | |
---|
[2121] | 901 | void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4, |
---|
[932] | 902 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 903 | int data_3size, int data_4size) |
---|
[1622] | 904 | TRY |
---|
[932] | 905 | { |
---|
| 906 | std::string fieldid_str; |
---|
| 907 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 908 | cxios_write_data_k45_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size) ; |
---|
| 909 | } |
---|
| 910 | CATCH_DUMP_STACK |
---|
[932] | 911 | |
---|
[2121] | 912 | |
---|
| 913 | |
---|
| 914 | void cxios_write_data_k46_hdl(CField* field, float* data_k4, |
---|
| 915 | int data_0size, int data_1size, int data_2size, |
---|
| 916 | int data_3size, int data_4size, int data_5size) |
---|
| 917 | TRY |
---|
| 918 | { |
---|
[2427] | 919 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 920 | CTimer::get("XIOS").resume(); |
---|
| 921 | CTimer::get("XIOS send field").resume(); |
---|
| 922 | |
---|
| 923 | CContext* context = CContext::getCurrent(); |
---|
| 924 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 925 | context->eventLoop(); |
---|
[932] | 926 | |
---|
| 927 | CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); |
---|
| 928 | CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size); |
---|
| 929 | data = data_tmp; |
---|
[2121] | 930 | field->setData(data); |
---|
[932] | 931 | |
---|
| 932 | CTimer::get("XIOS send field").suspend(); |
---|
| 933 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 934 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 935 | } |
---|
[1622] | 936 | CATCH_DUMP_STACK |
---|
[932] | 937 | |
---|
[2121] | 938 | void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4, |
---|
[932] | 939 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 940 | int data_3size, int data_4size, int data_5size) |
---|
[1622] | 941 | TRY |
---|
[932] | 942 | { |
---|
| 943 | std::string fieldid_str; |
---|
| 944 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 945 | cxios_write_data_k46_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ; |
---|
| 946 | } |
---|
| 947 | CATCH_DUMP_STACK |
---|
[932] | 948 | |
---|
[2121] | 949 | |
---|
| 950 | void cxios_write_data_k47_hdl(CField* field, float* data_k4, |
---|
| 951 | int data_0size, int data_1size, int data_2size, |
---|
| 952 | int data_3size, int data_4size, int data_5size, |
---|
| 953 | int data_6size) |
---|
| 954 | TRY |
---|
| 955 | { |
---|
[2427] | 956 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 957 | CTimer::get("XIOS").resume(); |
---|
| 958 | CTimer::get("XIOS send field").resume(); |
---|
| 959 | |
---|
| 960 | CContext* context = CContext::getCurrent(); |
---|
| 961 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 962 | context->eventLoop(); |
---|
[932] | 963 | |
---|
| 964 | CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); |
---|
| 965 | CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size); |
---|
| 966 | data = data_tmp; |
---|
[2121] | 967 | field->setData(data); |
---|
[932] | 968 | |
---|
| 969 | CTimer::get("XIOS send field").suspend(); |
---|
| 970 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 971 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 972 | } |
---|
[1622] | 973 | CATCH_DUMP_STACK |
---|
[932] | 974 | |
---|
[2121] | 975 | void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 976 | int data_0size, int data_1size, int data_2size, |
---|
| 977 | int data_3size, int data_4size, int data_5size, |
---|
| 978 | int data_6size) |
---|
[1622] | 979 | TRY |
---|
[961] | 980 | { |
---|
| 981 | std::string fieldid_str; |
---|
| 982 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 983 | cxios_write_data_k47_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ; |
---|
| 984 | } |
---|
| 985 | CATCH_DUMP_STACK |
---|
[961] | 986 | |
---|
[2121] | 987 | |
---|
| 988 | // ---------------------- Lecture des données ------------------------------ |
---|
| 989 | |
---|
| 990 | void cxios_read_data_k80_hdl(CField* field, double* data_k8, int data_Xsize) |
---|
| 991 | TRY |
---|
| 992 | { |
---|
[2427] | 993 | CMemChecker::get("XIOS send field").resume(); |
---|
[961] | 994 | CTimer::get("XIOS").resume(); |
---|
| 995 | CTimer::get("XIOS recv field").resume(); |
---|
| 996 | |
---|
| 997 | CContext* context = CContext::getCurrent(); |
---|
| 998 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 999 | context->eventLoop(); |
---|
[961] | 1000 | |
---|
| 1001 | CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); |
---|
[2121] | 1002 | field->getData(data); |
---|
[961] | 1003 | |
---|
| 1004 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1005 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1006 | CMemChecker::get("XIOS send field").suspend(); |
---|
[961] | 1007 | } |
---|
[1622] | 1008 | CATCH_DUMP_STACK |
---|
[961] | 1009 | |
---|
[2121] | 1010 | void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) |
---|
[1622] | 1011 | TRY |
---|
[593] | 1012 | { |
---|
| 1013 | std::string fieldid_str; |
---|
[489] | 1014 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1015 | cxios_read_data_k80_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ; |
---|
| 1016 | } |
---|
| 1017 | CATCH_DUMP_STACK |
---|
| 1018 | |
---|
| 1019 | |
---|
| 1020 | void cxios_read_data_k81_hdl(CField* field, double* data_k8, int data_Xsize) |
---|
| 1021 | TRY |
---|
| 1022 | { |
---|
[2427] | 1023 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 1024 | CTimer::get("XIOS").resume(); |
---|
| 1025 | CTimer::get("XIOS recv field").resume(); |
---|
[369] | 1026 | |
---|
[593] | 1027 | CContext* context = CContext::getCurrent(); |
---|
[704] | 1028 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1029 | context->eventLoop(); |
---|
[489] | 1030 | |
---|
[593] | 1031 | CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); |
---|
[2121] | 1032 | field->getData(data); |
---|
[347] | 1033 | |
---|
[593] | 1034 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1035 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1036 | CMemChecker::get("XIOS send field").suspend(); |
---|
[593] | 1037 | } |
---|
[1622] | 1038 | CATCH_DUMP_STACK |
---|
[593] | 1039 | |
---|
[2121] | 1040 | void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) |
---|
[1622] | 1041 | TRY |
---|
[593] | 1042 | { |
---|
| 1043 | std::string fieldid_str; |
---|
| 1044 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1045 | cxios_read_data_k81_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ; |
---|
| 1046 | } |
---|
| 1047 | CATCH_DUMP_STACK |
---|
[593] | 1048 | |
---|
[2121] | 1049 | void cxios_read_data_k82_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize) |
---|
| 1050 | TRY |
---|
| 1051 | { |
---|
[2427] | 1052 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 1053 | CTimer::get("XIOS").resume(); |
---|
| 1054 | CTimer::get("XIOS recv field").resume(); |
---|
| 1055 | |
---|
| 1056 | CContext* context = CContext::getCurrent(); |
---|
[704] | 1057 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1058 | context->eventLoop(); |
---|
[593] | 1059 | |
---|
| 1060 | CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData); |
---|
[2121] | 1061 | field->getData(data); |
---|
[593] | 1062 | |
---|
| 1063 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1064 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1065 | CMemChecker::get("XIOS send field").suspend(); |
---|
[593] | 1066 | } |
---|
[1622] | 1067 | CATCH_DUMP_STACK |
---|
[593] | 1068 | |
---|
[2121] | 1069 | void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize) |
---|
[1622] | 1070 | TRY |
---|
[593] | 1071 | { |
---|
| 1072 | std::string fieldid_str; |
---|
| 1073 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1074 | cxios_read_data_k82_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize) ; |
---|
| 1075 | } |
---|
| 1076 | CATCH_DUMP_STACK |
---|
[593] | 1077 | |
---|
[2121] | 1078 | |
---|
| 1079 | void cxios_read_data_k83_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
| 1080 | TRY |
---|
| 1081 | { |
---|
[2427] | 1082 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 1083 | CTimer::get("XIOS").resume(); |
---|
| 1084 | CTimer::get("XIOS recv field").resume(); |
---|
| 1085 | |
---|
| 1086 | CContext* context = CContext::getCurrent(); |
---|
[704] | 1087 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1088 | context->eventLoop(); |
---|
[593] | 1089 | |
---|
| 1090 | CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); |
---|
[2121] | 1091 | field->getData(data); |
---|
[593] | 1092 | |
---|
| 1093 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1094 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1095 | CMemChecker::get("XIOS send field").suspend(); |
---|
[593] | 1096 | } |
---|
[1622] | 1097 | CATCH_DUMP_STACK |
---|
[593] | 1098 | |
---|
[2121] | 1099 | |
---|
| 1100 | void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
[1622] | 1101 | TRY |
---|
[932] | 1102 | { |
---|
| 1103 | std::string fieldid_str; |
---|
| 1104 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1105 | cxios_read_data_k83_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize, data_Zsize) ; |
---|
| 1106 | } |
---|
| 1107 | CATCH_DUMP_STACK |
---|
[932] | 1108 | |
---|
[2121] | 1109 | void cxios_read_data_k84_hdl(CField* field, double* data_k8, |
---|
| 1110 | int data_0size, int data_1size, int data_2size, |
---|
| 1111 | int data_3size) |
---|
| 1112 | TRY |
---|
| 1113 | { |
---|
[2427] | 1114 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 1115 | CTimer::get("XIOS").resume(); |
---|
| 1116 | CTimer::get("XIOS recv field").resume(); |
---|
| 1117 | |
---|
| 1118 | CContext* context = CContext::getCurrent(); |
---|
| 1119 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1120 | context->eventLoop(); |
---|
[932] | 1121 | |
---|
| 1122 | CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); |
---|
[2121] | 1123 | field->getData(data); |
---|
[932] | 1124 | |
---|
| 1125 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1126 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1127 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 1128 | } |
---|
[1622] | 1129 | CATCH_DUMP_STACK |
---|
[932] | 1130 | |
---|
[2121] | 1131 | void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8, |
---|
[932] | 1132 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 1133 | int data_3size) |
---|
[1622] | 1134 | TRY |
---|
[932] | 1135 | { |
---|
| 1136 | std::string fieldid_str; |
---|
| 1137 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1138 | cxios_read_data_k84_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size) ; |
---|
| 1139 | } |
---|
| 1140 | CATCH_DUMP_STACK |
---|
[932] | 1141 | |
---|
[2121] | 1142 | void cxios_read_data_k85_hdl(CField* field, double* data_k8, |
---|
| 1143 | int data_0size, int data_1size, int data_2size, |
---|
| 1144 | int data_3size, int data_4size) |
---|
| 1145 | TRY |
---|
| 1146 | { |
---|
[2427] | 1147 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 1148 | CTimer::get("XIOS").resume(); |
---|
| 1149 | CTimer::get("XIOS recv field").resume(); |
---|
| 1150 | |
---|
| 1151 | CContext* context = CContext::getCurrent(); |
---|
| 1152 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1153 | context->eventLoop(); |
---|
[932] | 1154 | |
---|
| 1155 | CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); |
---|
[2121] | 1156 | field->getData(data); |
---|
[932] | 1157 | |
---|
| 1158 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1159 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1160 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 1161 | } |
---|
[1622] | 1162 | CATCH_DUMP_STACK |
---|
[932] | 1163 | |
---|
[2121] | 1164 | void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8, |
---|
[932] | 1165 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 1166 | int data_3size, int data_4size) |
---|
[1622] | 1167 | TRY |
---|
[932] | 1168 | { |
---|
| 1169 | std::string fieldid_str; |
---|
| 1170 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1171 | cxios_read_data_k85_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size) ; |
---|
| 1172 | } |
---|
| 1173 | CATCH_DUMP_STACK |
---|
[932] | 1174 | |
---|
[2121] | 1175 | void cxios_read_data_k86_hdl(CField* field, double* data_k8, |
---|
| 1176 | int data_0size, int data_1size, int data_2size, |
---|
| 1177 | int data_3size, int data_4size, int data_5size) |
---|
| 1178 | TRY |
---|
| 1179 | { |
---|
[2427] | 1180 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 1181 | CTimer::get("XIOS").resume(); |
---|
| 1182 | CTimer::get("XIOS recv field").resume(); |
---|
| 1183 | |
---|
| 1184 | CContext* context = CContext::getCurrent(); |
---|
| 1185 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1186 | context->eventLoop(); |
---|
[932] | 1187 | |
---|
| 1188 | CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); |
---|
[2121] | 1189 | field->getData(data); |
---|
[932] | 1190 | |
---|
| 1191 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1192 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1193 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 1194 | } |
---|
[1622] | 1195 | CATCH_DUMP_STACK |
---|
[932] | 1196 | |
---|
[2121] | 1197 | void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8, |
---|
[932] | 1198 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 1199 | int data_3size, int data_4size, int data_5size) |
---|
[1622] | 1200 | TRY |
---|
[932] | 1201 | { |
---|
| 1202 | std::string fieldid_str; |
---|
| 1203 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1204 | cxios_read_data_k86_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ; |
---|
| 1205 | } |
---|
| 1206 | CATCH_DUMP_STACK |
---|
[932] | 1207 | |
---|
[2121] | 1208 | void cxios_read_data_k87_hdl(CField* field, double* data_k8, |
---|
| 1209 | int data_0size, int data_1size, int data_2size, |
---|
| 1210 | int data_3size, int data_4size, int data_5size, |
---|
| 1211 | int data_6size) |
---|
| 1212 | TRY |
---|
| 1213 | { |
---|
[2427] | 1214 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 1215 | CTimer::get("XIOS").resume(); |
---|
| 1216 | CTimer::get("XIOS recv field").resume(); |
---|
| 1217 | |
---|
| 1218 | CContext* context = CContext::getCurrent(); |
---|
| 1219 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1220 | context->eventLoop(); |
---|
[932] | 1221 | |
---|
| 1222 | CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); |
---|
[2121] | 1223 | field->getData(data); |
---|
[932] | 1224 | |
---|
| 1225 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1226 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1227 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 1228 | } |
---|
[1622] | 1229 | CATCH_DUMP_STACK |
---|
[932] | 1230 | |
---|
[2121] | 1231 | void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 1232 | int data_0size, int data_1size, int data_2size, |
---|
| 1233 | int data_3size, int data_4size, int data_5size, |
---|
| 1234 | int data_6size) |
---|
[1622] | 1235 | TRY |
---|
[961] | 1236 | { |
---|
| 1237 | std::string fieldid_str; |
---|
| 1238 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1239 | cxios_read_data_k87_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ; |
---|
| 1240 | } |
---|
| 1241 | CATCH_DUMP_STACK |
---|
[961] | 1242 | |
---|
[2121] | 1243 | |
---|
| 1244 | |
---|
| 1245 | |
---|
| 1246 | |
---|
| 1247 | |
---|
| 1248 | void cxios_read_data_k40_hdl(CField* field, float* data_k4, int data_Xsize) |
---|
| 1249 | TRY |
---|
| 1250 | { |
---|
[2427] | 1251 | CMemChecker::get("XIOS send field").resume(); |
---|
[961] | 1252 | CTimer::get("XIOS").resume(); |
---|
| 1253 | CTimer::get("XIOS recv field").resume(); |
---|
| 1254 | |
---|
| 1255 | CContext* context = CContext::getCurrent(); |
---|
| 1256 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1257 | context->eventLoop(); |
---|
[961] | 1258 | |
---|
| 1259 | CArray<double, 1> data(data_Xsize); |
---|
[2121] | 1260 | field->getData(data); |
---|
[961] | 1261 | CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); |
---|
| 1262 | data_tmp = data; |
---|
| 1263 | |
---|
| 1264 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1265 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1266 | CMemChecker::get("XIOS send field").suspend(); |
---|
[961] | 1267 | } |
---|
[1622] | 1268 | CATCH_DUMP_STACK |
---|
[961] | 1269 | |
---|
[2121] | 1270 | void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) |
---|
[1622] | 1271 | TRY |
---|
[593] | 1272 | { |
---|
| 1273 | std::string fieldid_str; |
---|
| 1274 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1275 | cxios_read_data_k40_hdl(CField::get(fieldid_str), data_k4, data_Xsize) ; |
---|
| 1276 | } |
---|
| 1277 | CATCH_DUMP_STACK |
---|
[593] | 1278 | |
---|
[2121] | 1279 | |
---|
| 1280 | |
---|
| 1281 | void cxios_read_data_k41_hdl(CField* field, float* data_k4, int data_Xsize) |
---|
| 1282 | TRY |
---|
| 1283 | { |
---|
[2427] | 1284 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 1285 | CTimer::get("XIOS").resume(); |
---|
| 1286 | CTimer::get("XIOS recv field").resume(); |
---|
| 1287 | |
---|
| 1288 | CContext* context = CContext::getCurrent(); |
---|
[704] | 1289 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1290 | context->eventLoop(); |
---|
[593] | 1291 | |
---|
| 1292 | CArray<double, 1> data(data_Xsize); |
---|
[2121] | 1293 | field->getData(data); |
---|
[593] | 1294 | CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); |
---|
| 1295 | data_tmp = data; |
---|
| 1296 | |
---|
| 1297 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1298 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1299 | CMemChecker::get("XIOS send field").suspend(); |
---|
[593] | 1300 | } |
---|
[1622] | 1301 | CATCH_DUMP_STACK |
---|
[593] | 1302 | |
---|
[2121] | 1303 | void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) |
---|
[1622] | 1304 | TRY |
---|
[593] | 1305 | { |
---|
| 1306 | std::string fieldid_str; |
---|
| 1307 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1308 | cxios_read_data_k41_hdl(CField::get(fieldid_str), data_k4, data_Xsize) ; |
---|
| 1309 | } |
---|
| 1310 | CATCH_DUMP_STACK |
---|
[593] | 1311 | |
---|
[2121] | 1312 | |
---|
| 1313 | |
---|
| 1314 | |
---|
| 1315 | void cxios_read_data_k42_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize) |
---|
| 1316 | TRY |
---|
| 1317 | { |
---|
[2427] | 1318 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 1319 | CTimer::get("XIOS").resume(); |
---|
| 1320 | CTimer::get("XIOS recv field").resume(); |
---|
| 1321 | |
---|
| 1322 | CContext* context = CContext::getCurrent(); |
---|
[704] | 1323 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1324 | context->eventLoop(); |
---|
[593] | 1325 | |
---|
| 1326 | CArray<double, 2> data(data_Xsize, data_Ysize); |
---|
[2121] | 1327 | field->getData(data); |
---|
[593] | 1328 | CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData); |
---|
| 1329 | data_tmp = data; |
---|
| 1330 | |
---|
| 1331 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1332 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1333 | CMemChecker::get("XIOS send field").suspend(); |
---|
[593] | 1334 | } |
---|
[1622] | 1335 | CATCH_DUMP_STACK |
---|
[593] | 1336 | |
---|
[2121] | 1337 | void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) |
---|
[1622] | 1338 | TRY |
---|
[593] | 1339 | { |
---|
| 1340 | std::string fieldid_str; |
---|
| 1341 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1342 | cxios_read_data_k42_hdl(CField::get(fieldid_str), data_k4, data_Xsize, data_Ysize) ; |
---|
| 1343 | } |
---|
| 1344 | CATCH_DUMP_STACK |
---|
[593] | 1345 | |
---|
[2121] | 1346 | |
---|
| 1347 | |
---|
| 1348 | void cxios_read_data_k43_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
| 1349 | TRY |
---|
| 1350 | { |
---|
[2427] | 1351 | CMemChecker::get("XIOS send field").resume(); |
---|
[593] | 1352 | CTimer::get("XIOS").resume(); |
---|
| 1353 | CTimer::get("XIOS recv field").resume(); |
---|
| 1354 | |
---|
| 1355 | CContext* context = CContext::getCurrent(); |
---|
[704] | 1356 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1357 | context->eventLoop(); |
---|
[593] | 1358 | |
---|
| 1359 | CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize); |
---|
[2121] | 1360 | field->getData(data); |
---|
[593] | 1361 | CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); |
---|
| 1362 | data_tmp = data; |
---|
| 1363 | |
---|
| 1364 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1365 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1366 | CMemChecker::get("XIOS send field").suspend(); |
---|
[489] | 1367 | } |
---|
[1622] | 1368 | CATCH_DUMP_STACK |
---|
[932] | 1369 | |
---|
[2121] | 1370 | void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
[1622] | 1371 | TRY |
---|
[932] | 1372 | { |
---|
| 1373 | std::string fieldid_str; |
---|
| 1374 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1375 | cxios_read_data_k43_hdl(CField::get(fieldid_str), data_k4,data_Xsize, data_Ysize, data_Zsize) ; |
---|
| 1376 | } |
---|
| 1377 | CATCH_DUMP_STACK |
---|
[932] | 1378 | |
---|
[2121] | 1379 | |
---|
| 1380 | void cxios_read_data_k44_hdl(CField* field, float* data_k4, |
---|
| 1381 | int data_0size, int data_1size, int data_2size, |
---|
| 1382 | int data_3size) |
---|
| 1383 | TRY |
---|
| 1384 | { |
---|
[2427] | 1385 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 1386 | CTimer::get("XIOS").resume(); |
---|
| 1387 | CTimer::get("XIOS recv field").resume(); |
---|
| 1388 | |
---|
| 1389 | CContext* context = CContext::getCurrent(); |
---|
| 1390 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1391 | context->eventLoop(); |
---|
[932] | 1392 | |
---|
| 1393 | CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size); |
---|
[2121] | 1394 | field->getData(data); |
---|
[932] | 1395 | CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); |
---|
| 1396 | data_tmp = data; |
---|
| 1397 | |
---|
| 1398 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1399 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1400 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 1401 | } |
---|
[1622] | 1402 | CATCH_DUMP_STACK |
---|
[932] | 1403 | |
---|
[2121] | 1404 | void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4, |
---|
[932] | 1405 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 1406 | int data_3size) |
---|
[1622] | 1407 | TRY |
---|
[932] | 1408 | { |
---|
| 1409 | std::string fieldid_str; |
---|
| 1410 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1411 | cxios_read_data_k44_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size) ; |
---|
| 1412 | } |
---|
| 1413 | CATCH_DUMP_STACK |
---|
[932] | 1414 | |
---|
[2121] | 1415 | |
---|
| 1416 | |
---|
| 1417 | void cxios_read_data_k45_hdl(CField* field, float* data_k4, |
---|
| 1418 | int data_0size, int data_1size, int data_2size, |
---|
| 1419 | int data_3size, int data_4size) |
---|
| 1420 | TRY |
---|
| 1421 | { |
---|
[2427] | 1422 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 1423 | CTimer::get("XIOS").resume(); |
---|
| 1424 | CTimer::get("XIOS recv field").resume(); |
---|
| 1425 | |
---|
| 1426 | CContext* context = CContext::getCurrent(); |
---|
| 1427 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1428 | context->eventLoop(); |
---|
[932] | 1429 | |
---|
| 1430 | CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size); |
---|
[2121] | 1431 | field->getData(data); |
---|
[932] | 1432 | CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); |
---|
| 1433 | data_tmp = data; |
---|
| 1434 | |
---|
| 1435 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1436 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1437 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 1438 | } |
---|
[1622] | 1439 | CATCH_DUMP_STACK |
---|
[932] | 1440 | |
---|
[2121] | 1441 | void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4, |
---|
[932] | 1442 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 1443 | int data_3size, int data_4size) |
---|
[1622] | 1444 | TRY |
---|
[932] | 1445 | { |
---|
| 1446 | std::string fieldid_str; |
---|
| 1447 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1448 | cxios_read_data_k45_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size) ; |
---|
| 1449 | } |
---|
| 1450 | CATCH_DUMP_STACK |
---|
[932] | 1451 | |
---|
[2121] | 1452 | |
---|
| 1453 | void cxios_read_data_k46_hdl(CField* field, float* data_k4, |
---|
| 1454 | int data_0size, int data_1size, int data_2size, |
---|
| 1455 | int data_3size, int data_4size, int data_5size) |
---|
| 1456 | TRY |
---|
| 1457 | { |
---|
[2427] | 1458 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 1459 | CTimer::get("XIOS").resume(); |
---|
| 1460 | CTimer::get("XIOS recv field").resume(); |
---|
| 1461 | |
---|
| 1462 | CContext* context = CContext::getCurrent(); |
---|
| 1463 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1464 | context->eventLoop(); |
---|
[932] | 1465 | |
---|
| 1466 | CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size); |
---|
[2121] | 1467 | field->getData(data); |
---|
[932] | 1468 | CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); |
---|
| 1469 | data_tmp = data; |
---|
| 1470 | |
---|
| 1471 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1472 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1473 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 1474 | } |
---|
[1622] | 1475 | CATCH_DUMP_STACK |
---|
[932] | 1476 | |
---|
[2121] | 1477 | void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4, |
---|
[932] | 1478 | int data_0size, int data_1size, int data_2size, |
---|
[2121] | 1479 | int data_3size, int data_4size, int data_5size) |
---|
[1622] | 1480 | TRY |
---|
[932] | 1481 | { |
---|
| 1482 | std::string fieldid_str; |
---|
| 1483 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[2121] | 1484 | cxios_read_data_k46_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ; |
---|
| 1485 | } |
---|
| 1486 | CATCH_DUMP_STACK |
---|
[932] | 1487 | |
---|
[2121] | 1488 | |
---|
| 1489 | |
---|
| 1490 | void cxios_read_data_k47_hdl(CField* field, float* data_k4, |
---|
| 1491 | int data_0size, int data_1size, int data_2size, |
---|
| 1492 | int data_3size, int data_4size, int data_5size, |
---|
| 1493 | int data_6size) |
---|
| 1494 | TRY |
---|
| 1495 | { |
---|
[2427] | 1496 | CMemChecker::get("XIOS send field").resume(); |
---|
[932] | 1497 | CTimer::get("XIOS").resume(); |
---|
| 1498 | CTimer::get("XIOS recv field").resume(); |
---|
| 1499 | |
---|
| 1500 | CContext* context = CContext::getCurrent(); |
---|
| 1501 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
[1761] | 1502 | context->eventLoop(); |
---|
[932] | 1503 | |
---|
| 1504 | CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size); |
---|
[2121] | 1505 | field->getData(data); |
---|
[932] | 1506 | CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); |
---|
| 1507 | data_tmp = data; |
---|
| 1508 | |
---|
| 1509 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1510 | CTimer::get("XIOS").suspend(); |
---|
[2427] | 1511 | CMemChecker::get("XIOS send field").suspend(); |
---|
[932] | 1512 | } |
---|
[1622] | 1513 | CATCH_DUMP_STACK |
---|
[2121] | 1514 | |
---|
| 1515 | void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 1516 | int data_0size, int data_1size, int data_2size, |
---|
| 1517 | int data_3size, int data_4size, int data_5size, |
---|
| 1518 | int data_6size) |
---|
| 1519 | TRY |
---|
| 1520 | { |
---|
| 1521 | std::string fieldid_str; |
---|
| 1522 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 1523 | cxios_read_data_k47_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ; |
---|
| 1524 | } |
---|
| 1525 | CATCH_DUMP_STACK |
---|
[325] | 1526 | } // extern "C" |
---|