[325] | 1 | /* ************************************************************************** * |
---|
[1328] | 2 | * Copyright IPSL/LSCE, xios, Avril 2010 - Octobre 2011 * |
---|
[325] | 3 | * ************************************************************************** */ |
---|
| 4 | |
---|
| 5 | #include <boost/multi_array.hpp> |
---|
| 6 | #include <boost/shared_ptr.hpp> |
---|
| 7 | #include <string> |
---|
[489] | 8 | #include <cstring> |
---|
[325] | 9 | #include <iostream> |
---|
| 10 | |
---|
[1328] | 11 | #include "mpi_std.hpp" |
---|
[591] | 12 | #include "xios.hpp" |
---|
[1134] | 13 | //#include "oasis_cinterface.hpp" |
---|
[325] | 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" |
---|
[1328] | 25 | |
---|
[347] | 26 | #include "timer.hpp" |
---|
[325] | 27 | |
---|
| 28 | extern "C" |
---|
| 29 | { |
---|
[1328] | 30 | // /////////////////////////////// Dfinitions ////////////////////////////// // |
---|
[325] | 31 | |
---|
[1328] | 32 | // ----------------------- Redfinition de types ---------------------------- |
---|
[489] | 33 | |
---|
[325] | 34 | typedef enum { NETCDF4 = 0 } XFileType; |
---|
[489] | 35 | |
---|
[593] | 36 | typedef xios::CContext* XContextPtr; |
---|
[325] | 37 | |
---|
[1328] | 38 | // -------------------- Traitement des donnes ------------------------------ |
---|
[576] | 39 | |
---|
| 40 | // This function is not exported to the public Fortran interface, |
---|
| 41 | // it is only used from the parse_xml.exe standalone test tool. |
---|
| 42 | void cxios_init(void) |
---|
| 43 | { |
---|
| 44 | CXios::initialize(); |
---|
| 45 | } |
---|
| 46 | |
---|
[325] | 47 | void cxios_init_server(void) |
---|
| 48 | { |
---|
[489] | 49 | CXios::initServerSide(); |
---|
[325] | 50 | } |
---|
| 51 | |
---|
[593] | 52 | void cxios_init_client(const char* client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm ) |
---|
[325] | 53 | { |
---|
[489] | 54 | std::string str; |
---|
[1134] | 55 | ep_lib::MPI_Comm local_comm; |
---|
| 56 | ep_lib::MPI_Comm return_comm; |
---|
| 57 | |
---|
[489] | 58 | |
---|
[325] | 59 | if (!cstr2string(client_id, len_client_id, str)) return; |
---|
[347] | 60 | |
---|
[593] | 61 | int initialized; |
---|
| 62 | MPI_Initialized(&initialized); |
---|
[1328] | 63 | #ifdef _usingMPI |
---|
[593] | 64 | if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm); |
---|
[1328] | 65 | else local_comm=MPI_COMM_NULL; |
---|
| 66 | #elif _usingEP |
---|
| 67 | ep_lib::fc_comm_map.clear(); |
---|
[1369] | 68 | if (initialized) local_comm=ep_lib::EP_Comm_f2c((f_local_comm)); |
---|
[1328] | 69 | else local_comm=MPI_COMM_NULL; |
---|
[1134] | 70 | #endif |
---|
| 71 | |
---|
| 72 | |
---|
[1328] | 73 | |
---|
[593] | 74 | CXios::initClientSide(str, local_comm, return_comm); |
---|
[1328] | 75 | #ifdef _usingMPI |
---|
| 76 | *f_return_comm=MPI_Comm_c2f(return_comm); |
---|
| 77 | #elif _usingEP |
---|
[1369] | 78 | *f_return_comm=*static_cast<MPI_Fint*>(ep_lib::EP_Comm_c2f(return_comm)); |
---|
[1134] | 79 | #endif |
---|
[593] | 80 | CTimer::get("XIOS init").suspend(); |
---|
| 81 | CTimer::get("XIOS").suspend(); |
---|
[325] | 82 | } |
---|
| 83 | |
---|
[593] | 84 | void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm) |
---|
[325] | 85 | { |
---|
[489] | 86 | std::string str; |
---|
[1134] | 87 | ep_lib::MPI_Comm comm; |
---|
[489] | 88 | |
---|
[325] | 89 | if (!cstr2string(context_id, len_context_id, str)) return; |
---|
[593] | 90 | CTimer::get("XIOS").resume(); |
---|
| 91 | CTimer::get("XIOS init context").resume(); |
---|
[1328] | 92 | #ifdef _usingMPI |
---|
| 93 | comm=MPI_Comm_f2c(*f_comm); |
---|
| 94 | #elif _usingEP |
---|
[1369] | 95 | comm = ep_lib::EP_Comm_f2c(f_comm); |
---|
[1328] | 96 | #endif |
---|
| 97 | CClient::registerContext(str, comm); |
---|
[593] | 98 | CTimer::get("XIOS init context").suspend(); |
---|
| 99 | CTimer::get("XIOS").suspend(); |
---|
[325] | 100 | } |
---|
[489] | 101 | |
---|
[593] | 102 | void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized) |
---|
[461] | 103 | { |
---|
[489] | 104 | std::string str; |
---|
| 105 | |
---|
[461] | 106 | if (!cstr2string(context_id, len_context_id, str)) return; |
---|
[593] | 107 | CTimer::get("XIOS").resume(); |
---|
| 108 | CContext* context = CContext::get(str, str); |
---|
| 109 | *initialized=context->isInitialized(); |
---|
| 110 | CTimer::get("XIOS").suspend(); |
---|
[489] | 111 | } |
---|
| 112 | |
---|
[325] | 113 | void cxios_context_close_definition() |
---|
| 114 | { |
---|
[593] | 115 | CTimer::get("XIOS").resume(); |
---|
| 116 | CTimer::get("XIOS close definition").resume(); |
---|
| 117 | CContext* context = CContext::getCurrent(); |
---|
| 118 | context->closeDefinition(); |
---|
| 119 | CTimer::get("XIOS close definition").suspend(); |
---|
| 120 | CTimer::get("XIOS").suspend(); |
---|
[489] | 121 | } |
---|
[325] | 122 | |
---|
| 123 | void cxios_context_finalize() |
---|
| 124 | { |
---|
[593] | 125 | CTimer::get("XIOS").resume(); |
---|
| 126 | CTimer::get("XIOS context finalize").resume(); |
---|
| 127 | CContext* context = CContext::getCurrent(); |
---|
| 128 | context->finalize(); |
---|
| 129 | CTimer::get("XIOS context finalize").suspend(); |
---|
| 130 | CTimer::get("XIOS").suspend(); |
---|
[325] | 131 | } |
---|
[489] | 132 | |
---|
[325] | 133 | void cxios_finalize() |
---|
| 134 | { |
---|
[593] | 135 | CTimer::get("XIOS").resume(); |
---|
| 136 | CTimer::get("XIOS finalize").resume(); |
---|
| 137 | CXios::clientFinalize(); |
---|
[325] | 138 | } |
---|
| 139 | |
---|
[445] | 140 | void cxios_solve_inheritance() |
---|
| 141 | { |
---|
[593] | 142 | CTimer::get("XIOS").resume(); |
---|
| 143 | CContext* context = CContext::getCurrent(); |
---|
| 144 | context->solveAllInheritance(false); |
---|
| 145 | CTimer::get("XIOS").suspend(); |
---|
[489] | 146 | } |
---|
| 147 | |
---|
| 148 | /*! \brief This group of functions retrieve variable information from the configuration file (.xml) |
---|
| 149 | * |
---|
| 150 | * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml), |
---|
| 151 | * from a Fortran one, for example the value of a variable with id = "using_server". |
---|
| 152 | * Each function corresponds to each basic type. |
---|
| 153 | * \param varId [in] id of the variable that we'd like to get |
---|
| 154 | * \param varIdSize [in] size of the variable type (integer, float, double, string) |
---|
| 155 | * \param dataInt [in/out] the retrieved data |
---|
| 156 | * \param isVarExisted [in/out] Verify whether variable with varId exists |
---|
| 157 | */ |
---|
[593] | 158 | void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted) |
---|
[489] | 159 | { |
---|
| 160 | std::string varIdStr; |
---|
| 161 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 162 | |
---|
| 163 | CTimer::get("XIOS").resume(); |
---|
| 164 | CTimer::get("XIOS get variable data").resume(); |
---|
| 165 | |
---|
| 166 | CContext* context = CContext::getCurrent(); |
---|
| 167 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 168 | |
---|
| 169 | if (*isVarExisted) |
---|
| 170 | { |
---|
[593] | 171 | *data = CVariable::get(context->getId(), varIdStr)->getData<double>(); |
---|
[489] | 172 | } |
---|
| 173 | |
---|
[593] | 174 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 175 | CTimer::get("XIOS").suspend(); |
---|
[489] | 176 | } |
---|
| 177 | |
---|
[593] | 178 | void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted) |
---|
[489] | 179 | { |
---|
| 180 | std::string varIdStr; |
---|
| 181 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 182 | |
---|
| 183 | CTimer::get("XIOS").resume(); |
---|
| 184 | CTimer::get("XIOS get variable data").resume(); |
---|
| 185 | |
---|
| 186 | CContext* context = CContext::getCurrent(); |
---|
| 187 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 188 | |
---|
| 189 | if (*isVarExisted) |
---|
| 190 | { |
---|
[593] | 191 | *data = CVariable::get(context->getId(), varIdStr)->getData<float>(); |
---|
[489] | 192 | } |
---|
| 193 | |
---|
[593] | 194 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 195 | CTimer::get("XIOS").suspend(); |
---|
[489] | 196 | } |
---|
| 197 | |
---|
[593] | 198 | void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted) |
---|
[489] | 199 | { |
---|
| 200 | std::string varIdStr; |
---|
| 201 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 202 | |
---|
| 203 | CTimer::get("XIOS").resume(); |
---|
| 204 | CTimer::get("XIOS get variable data").resume(); |
---|
| 205 | |
---|
| 206 | CContext* context = CContext::getCurrent(); |
---|
| 207 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 208 | |
---|
| 209 | if (*isVarExisted) |
---|
| 210 | { |
---|
[593] | 211 | *data = CVariable::get(context->getId(), varIdStr)->getData<int>(); |
---|
[489] | 212 | } |
---|
| 213 | |
---|
[593] | 214 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 215 | CTimer::get("XIOS").suspend(); |
---|
[489] | 216 | } |
---|
| 217 | |
---|
[593] | 218 | void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted) |
---|
[489] | 219 | { |
---|
| 220 | std::string varIdStr; |
---|
| 221 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 222 | |
---|
| 223 | CTimer::get("XIOS").resume(); |
---|
| 224 | CTimer::get("XIOS get variable data").resume(); |
---|
| 225 | |
---|
| 226 | CContext* context = CContext::getCurrent(); |
---|
| 227 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 228 | |
---|
| 229 | if (*isVarExisted) |
---|
| 230 | { |
---|
[593] | 231 | *data = CVariable::get(context->getId(), varIdStr)->getData<bool>(); |
---|
[489] | 232 | } |
---|
| 233 | |
---|
[593] | 234 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 235 | CTimer::get("XIOS").suspend(); |
---|
[489] | 236 | } |
---|
| 237 | |
---|
[593] | 238 | void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted) |
---|
[489] | 239 | { |
---|
| 240 | std::string varIdStr; |
---|
| 241 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 242 | |
---|
| 243 | CTimer::get("XIOS").resume(); |
---|
| 244 | CTimer::get("XIOS get variable data").resume(); |
---|
| 245 | |
---|
| 246 | CContext* context = CContext::getCurrent(); |
---|
| 247 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 248 | |
---|
| 249 | if (*isVarExisted) |
---|
| 250 | { |
---|
[593] | 251 | int dataSizeOut = CVariable::get(context->getId(), varIdStr)->getData<string>().length(); |
---|
| 252 | strncpy(data, CVariable::get(context->getId(), varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut)); |
---|
[489] | 253 | } |
---|
| 254 | |
---|
[593] | 255 | CTimer::get("XIOS get variable data").suspend(); |
---|
| 256 | CTimer::get("XIOS").suspend(); |
---|
[489] | 257 | } |
---|
| 258 | |
---|
| 259 | /*! \brief This group of functions write information into existing variable in the configuration file (.xml) |
---|
| 260 | * |
---|
| 261 | * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml), |
---|
| 262 | * from a Fortran one, for example the value of a variable with id = "using_server". |
---|
| 263 | * Each function corresponds to each basic type. |
---|
| 264 | * \param varId [in] id of the variable that we'd like to get |
---|
| 265 | * \param varIdSize [in] size of the variable type (integer, float, double, string) |
---|
| 266 | * \param data [in] the input data |
---|
| 267 | * \param isVarExisted [in/out] Verify whether variable with varId exists |
---|
| 268 | */ |
---|
[593] | 269 | void cxios_set_variable_data_k8(const char* varId, int varIdSize, double data, bool* isVarExisted) |
---|
[489] | 270 | { |
---|
| 271 | std::string varIdStr; |
---|
| 272 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 273 | |
---|
| 274 | CTimer::get("XIOS").resume(); |
---|
| 275 | CTimer::get("XIOS set variable data").resume(); |
---|
| 276 | |
---|
[593] | 277 | CContext* context = CContext::getCurrent(); |
---|
[489] | 278 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 279 | |
---|
| 280 | if (*isVarExisted) |
---|
| 281 | { |
---|
[593] | 282 | CVariable::get(context->getId(), varIdStr)->setData<double>(data); |
---|
| 283 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 284 | } |
---|
| 285 | |
---|
[593] | 286 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 287 | CTimer::get("XIOS").suspend(); |
---|
[489] | 288 | } |
---|
| 289 | |
---|
[593] | 290 | void cxios_set_variable_data_k4(const char* varId, int varIdSize, float data, bool* isVarExisted) |
---|
[489] | 291 | { |
---|
| 292 | std::string varIdStr; |
---|
| 293 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 294 | |
---|
| 295 | CTimer::get("XIOS").resume(); |
---|
| 296 | CTimer::get("XIOS set variable data").resume(); |
---|
| 297 | |
---|
[593] | 298 | CContext* context = CContext::getCurrent(); |
---|
[489] | 299 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 300 | |
---|
| 301 | if (*isVarExisted) |
---|
| 302 | { |
---|
[593] | 303 | CVariable::get(context->getId(), varIdStr)->setData<float>(data); |
---|
| 304 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 305 | } |
---|
| 306 | |
---|
[593] | 307 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 308 | CTimer::get("XIOS").suspend(); |
---|
[489] | 309 | } |
---|
| 310 | |
---|
[593] | 311 | void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted) |
---|
[489] | 312 | { |
---|
| 313 | std::string varIdStr; |
---|
| 314 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 315 | |
---|
| 316 | CTimer::get("XIOS").resume(); |
---|
| 317 | CTimer::get("XIOS set variable data").resume(); |
---|
| 318 | |
---|
[593] | 319 | CContext* context = CContext::getCurrent(); |
---|
[489] | 320 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 321 | |
---|
| 322 | if (*isVarExisted) |
---|
| 323 | { |
---|
[593] | 324 | CVariable::get(context->getId(), varIdStr)->setData<int>(data); |
---|
| 325 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 326 | } |
---|
| 327 | |
---|
| 328 | |
---|
[593] | 329 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 330 | CTimer::get("XIOS").suspend(); |
---|
[489] | 331 | } |
---|
| 332 | |
---|
[593] | 333 | void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted) |
---|
[489] | 334 | { |
---|
| 335 | std::string varIdStr; |
---|
| 336 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 337 | |
---|
| 338 | CTimer::get("XIOS").resume(); |
---|
| 339 | CTimer::get("XIOS set variable data").resume(); |
---|
| 340 | |
---|
[593] | 341 | CContext* context = CContext::getCurrent(); |
---|
[489] | 342 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 343 | |
---|
| 344 | if (*isVarExisted) |
---|
| 345 | { |
---|
[593] | 346 | CVariable::get(context->getId(), varIdStr)->setData<bool>(data); |
---|
| 347 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 348 | } |
---|
| 349 | |
---|
[593] | 350 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 351 | CTimer::get("XIOS").suspend(); |
---|
[489] | 352 | } |
---|
| 353 | |
---|
[593] | 354 | void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted) |
---|
[489] | 355 | { |
---|
| 356 | std::string varIdStr, dataStr; |
---|
| 357 | if (!cstr2string(varId, varIdSize, varIdStr)) return; |
---|
| 358 | if (!cstr2string(data, dataSizeIn, dataStr)) |
---|
| 359 | { |
---|
| 360 | *isVarExisted = false; |
---|
| 361 | return; |
---|
| 362 | } |
---|
| 363 | |
---|
| 364 | CTimer::get("XIOS").resume(); |
---|
| 365 | CTimer::get("XIOS set variable data").resume(); |
---|
| 366 | |
---|
[593] | 367 | CContext* context = CContext::getCurrent(); |
---|
[489] | 368 | *isVarExisted = CVariable::has(context->getId(), varIdStr); |
---|
| 369 | |
---|
| 370 | if (*isVarExisted) |
---|
| 371 | { |
---|
[593] | 372 | CVariable::get(context->getId(), varIdStr)->setData<string>(dataStr); |
---|
| 373 | //CVariable::get(context->getId(), varIdStr)->sendValue(); |
---|
[489] | 374 | } |
---|
| 375 | |
---|
[593] | 376 | CTimer::get("XIOS set variable data").suspend(); |
---|
| 377 | CTimer::get("XIOS").suspend(); |
---|
[489] | 378 | } |
---|
| 379 | |
---|
| 380 | |
---|
[1328] | 381 | // ---------------------- Ecriture des donnes ------------------------------ |
---|
[489] | 382 | |
---|
[593] | 383 | void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) |
---|
[586] | 384 | { |
---|
| 385 | std::string fieldid_str; |
---|
| 386 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 387 | |
---|
[593] | 388 | CTimer::get("XIOS").resume(); |
---|
| 389 | CTimer::get("XIOS send field").resume(); |
---|
| 390 | CContext* context = CContext::getCurrent(); |
---|
[704] | 391 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 392 | context->checkBuffersAndListen(); |
---|
[593] | 393 | CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); |
---|
| 394 | CField::get(fieldid_str)->setData(data); |
---|
| 395 | CTimer::get("XIOS send field").suspend(); |
---|
| 396 | CTimer::get("XIOS").suspend(); |
---|
[586] | 397 | } |
---|
| 398 | |
---|
[593] | 399 | void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) |
---|
[586] | 400 | { |
---|
| 401 | std::string fieldid_str; |
---|
[593] | 402 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[586] | 403 | |
---|
[593] | 404 | CTimer::get("XIOS").resume(); |
---|
| 405 | CTimer::get("XIOS send field").resume(); |
---|
[586] | 406 | |
---|
[593] | 407 | CContext* context = CContext::getCurrent(); |
---|
[704] | 408 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 409 | context->checkBuffersAndListen(); |
---|
[593] | 410 | |
---|
| 411 | CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); |
---|
| 412 | CField::get(fieldid_str)->setData(data); |
---|
| 413 | |
---|
| 414 | CTimer::get("XIOS send field").suspend(); |
---|
| 415 | CTimer::get("XIOS").suspend(); |
---|
[586] | 416 | } |
---|
| 417 | |
---|
[593] | 418 | void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize) |
---|
[325] | 419 | { |
---|
| 420 | std::string fieldid_str; |
---|
[489] | 421 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 422 | |
---|
[593] | 423 | CTimer::get("XIOS").resume(); |
---|
| 424 | CTimer::get("XIOS send field").resume(); |
---|
| 425 | |
---|
| 426 | CContext* context = CContext::getCurrent(); |
---|
[704] | 427 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 428 | context->checkBuffersAndListen(); |
---|
[593] | 429 | |
---|
| 430 | CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData); |
---|
| 431 | CField::get(fieldid_str)->setData(data); |
---|
| 432 | |
---|
| 433 | CTimer::get("XIOS send field").suspend(); |
---|
| 434 | CTimer::get("XIOS").suspend(); |
---|
[325] | 435 | } |
---|
[489] | 436 | |
---|
[593] | 437 | void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
[325] | 438 | { |
---|
| 439 | std::string fieldid_str; |
---|
| 440 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[489] | 441 | |
---|
[593] | 442 | CTimer::get("XIOS").resume(); |
---|
| 443 | CTimer::get("XIOS send field").resume(); |
---|
[489] | 444 | |
---|
[593] | 445 | CContext* context = CContext::getCurrent(); |
---|
[704] | 446 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 447 | context->checkBuffersAndListen(); |
---|
[593] | 448 | |
---|
| 449 | CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); |
---|
| 450 | CField::get(fieldid_str)->setData(data); |
---|
| 451 | |
---|
| 452 | CTimer::get("XIOS send field").suspend(); |
---|
| 453 | CTimer::get("XIOS").suspend(); |
---|
[325] | 454 | } |
---|
[489] | 455 | |
---|
[932] | 456 | 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) |
---|
| 457 | { |
---|
| 458 | std::string fieldid_str; |
---|
| 459 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 460 | |
---|
| 461 | CTimer::get("XIOS").resume(); |
---|
| 462 | CTimer::get("XIOS send field").resume(); |
---|
| 463 | |
---|
| 464 | CContext* context = CContext::getCurrent(); |
---|
| 465 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 466 | context->checkBuffersAndListen(); |
---|
| 467 | |
---|
| 468 | CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); |
---|
| 469 | CField::get(fieldid_str)->setData(data); |
---|
| 470 | |
---|
| 471 | CTimer::get("XIOS send field").suspend(); |
---|
| 472 | CTimer::get("XIOS").suspend(); |
---|
| 473 | } |
---|
| 474 | |
---|
| 475 | void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 476 | int data_0size, int data_1size, int data_2size, |
---|
| 477 | int data_3size, int data_4size) |
---|
| 478 | { |
---|
| 479 | std::string fieldid_str; |
---|
| 480 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 481 | |
---|
| 482 | CTimer::get("XIOS").resume(); |
---|
| 483 | CTimer::get("XIOS send field").resume(); |
---|
| 484 | |
---|
| 485 | CContext* context = CContext::getCurrent(); |
---|
| 486 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 487 | context->checkBuffersAndListen(); |
---|
| 488 | |
---|
| 489 | CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); |
---|
| 490 | CField::get(fieldid_str)->setData(data); |
---|
| 491 | |
---|
| 492 | CTimer::get("XIOS send field").suspend(); |
---|
| 493 | CTimer::get("XIOS").suspend(); |
---|
| 494 | } |
---|
| 495 | |
---|
| 496 | void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 497 | int data_0size, int data_1size, int data_2size, |
---|
| 498 | int data_3size, int data_4size, int data_5size) |
---|
| 499 | { |
---|
| 500 | std::string fieldid_str; |
---|
| 501 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 502 | |
---|
| 503 | CTimer::get("XIOS").resume(); |
---|
| 504 | CTimer::get("XIOS send field").resume(); |
---|
| 505 | |
---|
| 506 | CContext* context = CContext::getCurrent(); |
---|
| 507 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 508 | context->checkBuffersAndListen(); |
---|
| 509 | |
---|
| 510 | CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); |
---|
| 511 | CField::get(fieldid_str)->setData(data); |
---|
| 512 | |
---|
| 513 | CTimer::get("XIOS send field").suspend(); |
---|
| 514 | CTimer::get("XIOS").suspend(); |
---|
| 515 | } |
---|
| 516 | |
---|
| 517 | void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 518 | int data_0size, int data_1size, int data_2size, |
---|
| 519 | int data_3size, int data_4size, int data_5size, |
---|
| 520 | int data_6size) |
---|
| 521 | { |
---|
| 522 | std::string fieldid_str; |
---|
| 523 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 524 | |
---|
| 525 | CTimer::get("XIOS").resume(); |
---|
| 526 | CTimer::get("XIOS send field").resume(); |
---|
| 527 | |
---|
| 528 | CContext* context = CContext::getCurrent(); |
---|
| 529 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 530 | context->checkBuffersAndListen(); |
---|
| 531 | |
---|
| 532 | CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); |
---|
| 533 | CField::get(fieldid_str)->setData(data); |
---|
| 534 | |
---|
| 535 | CTimer::get("XIOS send field").suspend(); |
---|
| 536 | CTimer::get("XIOS").suspend(); |
---|
| 537 | } |
---|
| 538 | |
---|
[593] | 539 | void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) |
---|
[325] | 540 | { |
---|
| 541 | std::string fieldid_str; |
---|
[489] | 542 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[347] | 543 | |
---|
[593] | 544 | CTimer::get("XIOS").resume(); |
---|
| 545 | CTimer::get("XIOS send field").resume(); |
---|
| 546 | CContext* context = CContext::getCurrent(); |
---|
[704] | 547 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 548 | context->checkBuffersAndListen(); |
---|
[369] | 549 | |
---|
[593] | 550 | CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); |
---|
| 551 | CArray<double, 1> data(data_Xsize) ; |
---|
| 552 | data = data_tmp; |
---|
| 553 | CField::get(fieldid_str)->setData(data); |
---|
| 554 | CTimer::get("XIOS send field").suspend(); |
---|
| 555 | CTimer::get("XIOS").suspend(); |
---|
[325] | 556 | } |
---|
[489] | 557 | |
---|
[593] | 558 | void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) |
---|
[325] | 559 | { |
---|
| 560 | std::string fieldid_str; |
---|
[593] | 561 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[347] | 562 | |
---|
[593] | 563 | CTimer::get("XIOS").resume(); |
---|
| 564 | CTimer::get("XIOS send field").resume(); |
---|
[403] | 565 | |
---|
[593] | 566 | CContext* context = CContext::getCurrent(); |
---|
[704] | 567 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 568 | context->checkBuffersAndListen(); |
---|
[593] | 569 | |
---|
| 570 | CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); |
---|
| 571 | CArray<double, 1> data(data_Xsize); |
---|
| 572 | data = data_tmp; |
---|
| 573 | CField::get(fieldid_str)->setData(data); |
---|
| 574 | |
---|
| 575 | CTimer::get("XIOS send field").suspend(); |
---|
| 576 | CTimer::get("XIOS").suspend(); |
---|
[325] | 577 | } |
---|
[489] | 578 | |
---|
[593] | 579 | void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) |
---|
[325] | 580 | { |
---|
| 581 | std::string fieldid_str; |
---|
[489] | 582 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[347] | 583 | |
---|
[593] | 584 | CTimer::get("XIOS").resume(); |
---|
| 585 | CTimer::get("XIOS send field").resume(); |
---|
[403] | 586 | |
---|
[593] | 587 | CContext* context = CContext::getCurrent(); |
---|
[704] | 588 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 589 | context->checkBuffersAndListen(); |
---|
[593] | 590 | |
---|
| 591 | CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData); |
---|
| 592 | CArray<double, 2> data(data_Xsize, data_Ysize); |
---|
| 593 | data = data_tmp; |
---|
| 594 | CField::get(fieldid_str)->setData(data); |
---|
| 595 | |
---|
| 596 | CTimer::get("XIOS send field").suspend(); |
---|
| 597 | CTimer::get("XIOS").suspend(); |
---|
[325] | 598 | } |
---|
[489] | 599 | |
---|
[593] | 600 | void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
[325] | 601 | { |
---|
| 602 | std::string fieldid_str; |
---|
[593] | 603 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
[489] | 604 | |
---|
[593] | 605 | CTimer::get("XIOS").resume(); |
---|
| 606 | CTimer::get("XIOS send field").resume(); |
---|
| 607 | |
---|
| 608 | CContext* context = CContext::getCurrent(); |
---|
[704] | 609 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 610 | context->checkBuffersAndListen(); |
---|
[593] | 611 | |
---|
| 612 | CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); |
---|
| 613 | CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize); |
---|
| 614 | data = data_tmp; |
---|
| 615 | CField::get(fieldid_str)->setData(data); |
---|
| 616 | |
---|
| 617 | CTimer::get("XIOS send field").suspend(); |
---|
| 618 | CTimer::get("XIOS").suspend(); |
---|
| 619 | } |
---|
| 620 | |
---|
[932] | 621 | void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 622 | int data_0size, int data_1size, int data_2size, |
---|
| 623 | int data_3size) |
---|
| 624 | { |
---|
| 625 | std::string fieldid_str; |
---|
| 626 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 627 | |
---|
| 628 | CTimer::get("XIOS").resume(); |
---|
| 629 | CTimer::get("XIOS send field").resume(); |
---|
| 630 | |
---|
| 631 | CContext* context = CContext::getCurrent(); |
---|
| 632 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 633 | context->checkBuffersAndListen(); |
---|
| 634 | |
---|
| 635 | CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); |
---|
| 636 | CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size); |
---|
| 637 | data = data_tmp; |
---|
| 638 | CField::get(fieldid_str)->setData(data); |
---|
| 639 | |
---|
| 640 | CTimer::get("XIOS send field").suspend(); |
---|
| 641 | CTimer::get("XIOS").suspend(); |
---|
| 642 | } |
---|
| 643 | |
---|
| 644 | void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 645 | int data_0size, int data_1size, int data_2size, |
---|
| 646 | int data_3size, int data_4size) |
---|
| 647 | { |
---|
| 648 | std::string fieldid_str; |
---|
| 649 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 650 | |
---|
| 651 | CTimer::get("XIOS").resume(); |
---|
| 652 | CTimer::get("XIOS send field").resume(); |
---|
| 653 | |
---|
| 654 | CContext* context = CContext::getCurrent(); |
---|
| 655 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 656 | context->checkBuffersAndListen(); |
---|
| 657 | |
---|
| 658 | CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); |
---|
| 659 | CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size); |
---|
| 660 | data = data_tmp; |
---|
| 661 | CField::get(fieldid_str)->setData(data); |
---|
| 662 | |
---|
| 663 | CTimer::get("XIOS send field").suspend(); |
---|
| 664 | CTimer::get("XIOS").suspend(); |
---|
| 665 | } |
---|
| 666 | |
---|
| 667 | void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 668 | int data_0size, int data_1size, int data_2size, |
---|
| 669 | int data_3size, int data_4size, int data_5size) |
---|
| 670 | { |
---|
| 671 | std::string fieldid_str; |
---|
| 672 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 673 | |
---|
| 674 | CTimer::get("XIOS").resume(); |
---|
| 675 | CTimer::get("XIOS send field").resume(); |
---|
| 676 | |
---|
| 677 | CContext* context = CContext::getCurrent(); |
---|
| 678 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 679 | context->checkBuffersAndListen(); |
---|
| 680 | |
---|
| 681 | CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); |
---|
| 682 | CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size); |
---|
| 683 | data = data_tmp; |
---|
| 684 | CField::get(fieldid_str)->setData(data); |
---|
| 685 | |
---|
| 686 | CTimer::get("XIOS send field").suspend(); |
---|
| 687 | CTimer::get("XIOS").suspend(); |
---|
| 688 | } |
---|
| 689 | |
---|
| 690 | void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 691 | int data_0size, int data_1size, int data_2size, |
---|
| 692 | int data_3size, int data_4size, int data_5size, |
---|
| 693 | int data_6size) |
---|
| 694 | { |
---|
| 695 | std::string fieldid_str; |
---|
| 696 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 697 | |
---|
| 698 | CTimer::get("XIOS").resume(); |
---|
| 699 | CTimer::get("XIOS send field").resume(); |
---|
| 700 | |
---|
| 701 | CContext* context = CContext::getCurrent(); |
---|
| 702 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 703 | context->checkBuffersAndListen(); |
---|
| 704 | |
---|
| 705 | CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); |
---|
| 706 | CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size); |
---|
| 707 | data = data_tmp; |
---|
| 708 | CField::get(fieldid_str)->setData(data); |
---|
| 709 | |
---|
| 710 | CTimer::get("XIOS send field").suspend(); |
---|
| 711 | CTimer::get("XIOS").suspend(); |
---|
| 712 | } |
---|
| 713 | |
---|
[1328] | 714 | // ---------------------- Lecture des donnes ------------------------------ |
---|
[593] | 715 | |
---|
[961] | 716 | void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) |
---|
| 717 | { |
---|
| 718 | std::string fieldid_str; |
---|
| 719 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 720 | |
---|
| 721 | CTimer::get("XIOS").resume(); |
---|
| 722 | CTimer::get("XIOS recv field").resume(); |
---|
| 723 | |
---|
| 724 | CContext* context = CContext::getCurrent(); |
---|
| 725 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 726 | context->checkBuffersAndListen(); |
---|
| 727 | |
---|
| 728 | CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); |
---|
| 729 | CField::get(fieldid_str)->getData(data); |
---|
| 730 | |
---|
| 731 | CTimer::get("XIOS recv field").suspend(); |
---|
| 732 | CTimer::get("XIOS").suspend(); |
---|
| 733 | } |
---|
| 734 | |
---|
[593] | 735 | void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) |
---|
| 736 | { |
---|
| 737 | std::string fieldid_str; |
---|
[489] | 738 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 739 | |
---|
[593] | 740 | CTimer::get("XIOS").resume(); |
---|
| 741 | CTimer::get("XIOS recv field").resume(); |
---|
[369] | 742 | |
---|
[593] | 743 | CContext* context = CContext::getCurrent(); |
---|
[704] | 744 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 745 | context->checkBuffersAndListen(); |
---|
[489] | 746 | |
---|
[593] | 747 | CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); |
---|
| 748 | CField::get(fieldid_str)->getData(data); |
---|
[347] | 749 | |
---|
[593] | 750 | CTimer::get("XIOS recv field").suspend(); |
---|
| 751 | CTimer::get("XIOS").suspend(); |
---|
| 752 | } |
---|
| 753 | |
---|
| 754 | void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize) |
---|
| 755 | { |
---|
| 756 | std::string fieldid_str; |
---|
| 757 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 758 | |
---|
| 759 | CTimer::get("XIOS").resume(); |
---|
| 760 | CTimer::get("XIOS recv field").resume(); |
---|
| 761 | |
---|
| 762 | CContext* context = CContext::getCurrent(); |
---|
[704] | 763 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 764 | context->checkBuffersAndListen(); |
---|
[593] | 765 | |
---|
| 766 | CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData); |
---|
| 767 | CField::get(fieldid_str)->getData(data); |
---|
| 768 | |
---|
| 769 | CTimer::get("XIOS recv field").suspend(); |
---|
| 770 | CTimer::get("XIOS").suspend(); |
---|
| 771 | } |
---|
| 772 | |
---|
| 773 | void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
| 774 | { |
---|
| 775 | std::string fieldid_str; |
---|
| 776 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 777 | |
---|
| 778 | CTimer::get("XIOS").resume(); |
---|
| 779 | CTimer::get("XIOS recv field").resume(); |
---|
| 780 | |
---|
| 781 | CContext* context = CContext::getCurrent(); |
---|
[704] | 782 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 783 | context->checkBuffersAndListen(); |
---|
[593] | 784 | |
---|
| 785 | CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); |
---|
| 786 | CField::get(fieldid_str)->getData(data); |
---|
| 787 | |
---|
| 788 | CTimer::get("XIOS recv field").suspend(); |
---|
| 789 | CTimer::get("XIOS").suspend(); |
---|
| 790 | } |
---|
| 791 | |
---|
[932] | 792 | void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 793 | int data_0size, int data_1size, int data_2size, |
---|
| 794 | int data_3size) |
---|
| 795 | { |
---|
| 796 | std::string fieldid_str; |
---|
| 797 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 798 | |
---|
| 799 | CTimer::get("XIOS").resume(); |
---|
| 800 | CTimer::get("XIOS recv field").resume(); |
---|
| 801 | |
---|
| 802 | CContext* context = CContext::getCurrent(); |
---|
| 803 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 804 | context->checkBuffersAndListen(); |
---|
| 805 | |
---|
| 806 | CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); |
---|
| 807 | CField::get(fieldid_str)->getData(data); |
---|
| 808 | |
---|
| 809 | CTimer::get("XIOS recv field").suspend(); |
---|
| 810 | CTimer::get("XIOS").suspend(); |
---|
| 811 | } |
---|
| 812 | |
---|
| 813 | void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 814 | int data_0size, int data_1size, int data_2size, |
---|
| 815 | int data_3size, int data_4size) |
---|
| 816 | { |
---|
| 817 | std::string fieldid_str; |
---|
| 818 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 819 | |
---|
| 820 | CTimer::get("XIOS").resume(); |
---|
| 821 | CTimer::get("XIOS recv field").resume(); |
---|
| 822 | |
---|
| 823 | CContext* context = CContext::getCurrent(); |
---|
| 824 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 825 | context->checkBuffersAndListen(); |
---|
| 826 | |
---|
| 827 | CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); |
---|
| 828 | CField::get(fieldid_str)->getData(data); |
---|
| 829 | |
---|
| 830 | CTimer::get("XIOS recv field").suspend(); |
---|
| 831 | CTimer::get("XIOS").suspend(); |
---|
| 832 | } |
---|
| 833 | |
---|
| 834 | void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 835 | int data_0size, int data_1size, int data_2size, |
---|
| 836 | int data_3size, int data_4size, int data_5size) |
---|
| 837 | { |
---|
| 838 | std::string fieldid_str; |
---|
| 839 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 840 | |
---|
| 841 | CTimer::get("XIOS").resume(); |
---|
| 842 | CTimer::get("XIOS recv field").resume(); |
---|
| 843 | |
---|
| 844 | CContext* context = CContext::getCurrent(); |
---|
| 845 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 846 | context->checkBuffersAndListen(); |
---|
| 847 | |
---|
| 848 | CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); |
---|
| 849 | CField::get(fieldid_str)->getData(data); |
---|
| 850 | |
---|
| 851 | CTimer::get("XIOS recv field").suspend(); |
---|
| 852 | CTimer::get("XIOS").suspend(); |
---|
| 853 | } |
---|
| 854 | |
---|
| 855 | void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8, |
---|
| 856 | int data_0size, int data_1size, int data_2size, |
---|
| 857 | int data_3size, int data_4size, int data_5size, |
---|
| 858 | int data_6size) |
---|
| 859 | { |
---|
| 860 | std::string fieldid_str; |
---|
| 861 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 862 | |
---|
| 863 | CTimer::get("XIOS").resume(); |
---|
| 864 | CTimer::get("XIOS recv field").resume(); |
---|
| 865 | |
---|
| 866 | CContext* context = CContext::getCurrent(); |
---|
| 867 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 868 | context->checkBuffersAndListen(); |
---|
| 869 | |
---|
| 870 | CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); |
---|
| 871 | CField::get(fieldid_str)->getData(data); |
---|
| 872 | |
---|
| 873 | CTimer::get("XIOS recv field").suspend(); |
---|
| 874 | CTimer::get("XIOS").suspend(); |
---|
| 875 | } |
---|
| 876 | |
---|
[961] | 877 | void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) |
---|
| 878 | { |
---|
| 879 | std::string fieldid_str; |
---|
| 880 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 881 | |
---|
| 882 | CTimer::get("XIOS").resume(); |
---|
| 883 | CTimer::get("XIOS recv field").resume(); |
---|
| 884 | |
---|
| 885 | CContext* context = CContext::getCurrent(); |
---|
| 886 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 887 | context->checkBuffersAndListen(); |
---|
| 888 | |
---|
| 889 | CArray<double, 1> data(data_Xsize); |
---|
| 890 | CField::get(fieldid_str)->getData(data); |
---|
| 891 | CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); |
---|
| 892 | data_tmp = data; |
---|
| 893 | |
---|
| 894 | CTimer::get("XIOS recv field").suspend(); |
---|
| 895 | CTimer::get("XIOS").suspend(); |
---|
| 896 | } |
---|
| 897 | |
---|
[593] | 898 | void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) |
---|
| 899 | { |
---|
| 900 | std::string fieldid_str; |
---|
| 901 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 902 | |
---|
| 903 | CTimer::get("XIOS").resume(); |
---|
| 904 | CTimer::get("XIOS recv field").resume(); |
---|
| 905 | |
---|
| 906 | CContext* context = CContext::getCurrent(); |
---|
[704] | 907 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 908 | context->checkBuffersAndListen(); |
---|
[593] | 909 | |
---|
| 910 | CArray<double, 1> data(data_Xsize); |
---|
| 911 | CField::get(fieldid_str)->getData(data); |
---|
| 912 | CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); |
---|
| 913 | data_tmp = data; |
---|
| 914 | |
---|
| 915 | CTimer::get("XIOS recv field").suspend(); |
---|
| 916 | CTimer::get("XIOS").suspend(); |
---|
| 917 | } |
---|
| 918 | |
---|
| 919 | void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) |
---|
| 920 | { |
---|
| 921 | std::string fieldid_str; |
---|
| 922 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 923 | |
---|
| 924 | CTimer::get("XIOS").resume(); |
---|
| 925 | CTimer::get("XIOS recv field").resume(); |
---|
| 926 | |
---|
| 927 | CContext* context = CContext::getCurrent(); |
---|
[704] | 928 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 929 | context->checkBuffersAndListen(); |
---|
[593] | 930 | |
---|
| 931 | CArray<double, 2> data(data_Xsize, data_Ysize); |
---|
| 932 | CField::get(fieldid_str)->getData(data); |
---|
| 933 | CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData); |
---|
| 934 | data_tmp = data; |
---|
| 935 | |
---|
| 936 | CTimer::get("XIOS recv field").suspend(); |
---|
| 937 | CTimer::get("XIOS").suspend(); |
---|
| 938 | } |
---|
| 939 | |
---|
| 940 | void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) |
---|
| 941 | { |
---|
| 942 | std::string fieldid_str; |
---|
| 943 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 944 | |
---|
| 945 | CTimer::get("XIOS").resume(); |
---|
| 946 | CTimer::get("XIOS recv field").resume(); |
---|
| 947 | |
---|
| 948 | CContext* context = CContext::getCurrent(); |
---|
[704] | 949 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 950 | context->checkBuffersAndListen(); |
---|
[593] | 951 | |
---|
| 952 | CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize); |
---|
| 953 | CField::get(fieldid_str)->getData(data); |
---|
| 954 | CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); |
---|
| 955 | data_tmp = data; |
---|
| 956 | |
---|
| 957 | CTimer::get("XIOS recv field").suspend(); |
---|
| 958 | CTimer::get("XIOS").suspend(); |
---|
[489] | 959 | } |
---|
[932] | 960 | |
---|
| 961 | void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 962 | int data_0size, int data_1size, int data_2size, |
---|
| 963 | int data_3size) |
---|
| 964 | { |
---|
| 965 | std::string fieldid_str; |
---|
| 966 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 967 | |
---|
| 968 | CTimer::get("XIOS").resume(); |
---|
| 969 | CTimer::get("XIOS recv field").resume(); |
---|
| 970 | |
---|
| 971 | CContext* context = CContext::getCurrent(); |
---|
| 972 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 973 | context->checkBuffersAndListen(); |
---|
| 974 | |
---|
| 975 | CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size); |
---|
| 976 | CField::get(fieldid_str)->getData(data); |
---|
| 977 | CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); |
---|
| 978 | data_tmp = data; |
---|
| 979 | |
---|
| 980 | CTimer::get("XIOS recv field").suspend(); |
---|
| 981 | CTimer::get("XIOS").suspend(); |
---|
| 982 | } |
---|
| 983 | |
---|
| 984 | void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 985 | int data_0size, int data_1size, int data_2size, |
---|
| 986 | int data_3size, int data_4size) |
---|
| 987 | { |
---|
| 988 | std::string fieldid_str; |
---|
| 989 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 990 | |
---|
| 991 | CTimer::get("XIOS").resume(); |
---|
| 992 | CTimer::get("XIOS recv field").resume(); |
---|
| 993 | |
---|
| 994 | CContext* context = CContext::getCurrent(); |
---|
| 995 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 996 | context->checkBuffersAndListen(); |
---|
| 997 | |
---|
| 998 | CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size); |
---|
| 999 | CField::get(fieldid_str)->getData(data); |
---|
| 1000 | CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); |
---|
| 1001 | data_tmp = data; |
---|
| 1002 | |
---|
| 1003 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1004 | CTimer::get("XIOS").suspend(); |
---|
| 1005 | } |
---|
| 1006 | |
---|
| 1007 | void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 1008 | int data_0size, int data_1size, int data_2size, |
---|
| 1009 | int data_3size, int data_4size, int data_5size) |
---|
| 1010 | { |
---|
| 1011 | std::string fieldid_str; |
---|
| 1012 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 1013 | |
---|
| 1014 | CTimer::get("XIOS").resume(); |
---|
| 1015 | CTimer::get("XIOS recv field").resume(); |
---|
| 1016 | |
---|
| 1017 | CContext* context = CContext::getCurrent(); |
---|
| 1018 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 1019 | context->checkBuffersAndListen(); |
---|
| 1020 | |
---|
| 1021 | CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size); |
---|
| 1022 | CField::get(fieldid_str)->getData(data); |
---|
| 1023 | CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); |
---|
| 1024 | data_tmp = data; |
---|
| 1025 | |
---|
| 1026 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1027 | CTimer::get("XIOS").suspend(); |
---|
| 1028 | } |
---|
| 1029 | |
---|
| 1030 | void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4, |
---|
| 1031 | int data_0size, int data_1size, int data_2size, |
---|
| 1032 | int data_3size, int data_4size, int data_5size, |
---|
| 1033 | int data_6size) |
---|
| 1034 | { |
---|
| 1035 | std::string fieldid_str; |
---|
| 1036 | if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; |
---|
| 1037 | |
---|
| 1038 | CTimer::get("XIOS").resume(); |
---|
| 1039 | CTimer::get("XIOS recv field").resume(); |
---|
| 1040 | |
---|
| 1041 | CContext* context = CContext::getCurrent(); |
---|
| 1042 | if (!context->hasServer && !context->client->isAttachedModeEnabled()) |
---|
| 1043 | context->checkBuffersAndListen(); |
---|
| 1044 | |
---|
| 1045 | CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size); |
---|
| 1046 | CField::get(fieldid_str)->getData(data); |
---|
| 1047 | CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); |
---|
| 1048 | data_tmp = data; |
---|
| 1049 | |
---|
| 1050 | CTimer::get("XIOS recv field").suspend(); |
---|
| 1051 | CTimer::get("XIOS").suspend(); |
---|
| 1052 | } |
---|
[325] | 1053 | } // extern "C" |
---|